Safe Haskell	Safe-Inferred
Language	Haskell2010

Indigo

Synopsis

(++) :: [a] -> [a] -> [a]
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
filter :: (a -> Bool) -> [a] -> [a]
zip :: [a] -> [b] -> [(a, b)]
otherwise :: Bool
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
realToFrac :: (Real a, Fractional b) => a -> b
guard :: Alternative f => Bool -> f ()
join :: Monad m => m (m a) -> m a
class Bounded a where
- minBound :: a
- maxBound :: a
class Enum a where
- succ :: a -> a
- pred :: a -> a
- toEnum :: Int -> a
- fromEnum :: a -> Int
- enumFrom :: a -> [a]
- enumFromThen :: a -> a -> [a]
- enumFromTo :: a -> a -> [a]
- enumFromThenTo :: a -> a -> a -> [a]
class Eq a
class Fractional a => Floating a where
- pi :: a
- exp :: a -> a
- sqrt :: a -> a
- (**) :: a -> a -> a
- logBase :: a -> a -> a
- sin :: a -> a
- cos :: a -> a
- tan :: a -> a
- asin :: a -> a
- acos :: a -> a
- atan :: a -> a
- sinh :: a -> a
- cosh :: a -> a
- tanh :: a -> a
- asinh :: a -> a
- acosh :: a -> a
- atanh :: a -> a
class Num a => Fractional a where
- recip :: a -> a
- fromRational :: Rational -> a
class (Real a, Enum a) => Integral a where
- quot :: a -> a -> a
- rem :: a -> a -> a
- quotRem :: a -> a -> (a, a)
- divMod :: a -> a -> (a, a)
- toInteger :: a -> Integer
class Applicative m => Monad (m :: Type -> Type) where
- (>>=) :: m a -> (a -> m b) -> m b
- (>>) :: m a -> m b -> m b
- return :: a -> m a
class Functor (f :: Type -> Type) where
- fmap :: (a -> b) -> f a -> f b
- (<$) :: a -> f b -> f a
class Num a where
- negate :: a -> a
- signum :: a -> a
class Eq a => Ord a where
- compare :: a -> a -> Ordering
- max :: a -> a -> a
- min :: a -> a -> a
class Read a
class (Num a, Ord a) => Real a where
- toRational :: a -> Rational
class (Real a, Fractional a) => RealFrac a where
- properFraction :: Integral b => a -> (b, a)
- truncate :: Integral b => a -> b
- round :: Integral b => a -> b
- ceiling :: Integral b => a -> b
- floor :: Integral b => a -> b
class Show a
class Typeable (a :: k)
class Monad m => MonadFail (m :: Type -> Type) where
- fail :: String -> m a
class IsString a where
- fromString :: String -> a
class Functor f => Applicative (f :: Type -> Type) where
- pure :: a -> f a
- (<*>) :: f (a -> b) -> f a -> f b
- liftA2 :: (a -> b -> c) -> f a -> f b -> f c
- (*>) :: f a -> f b -> f b
- (<*) :: f a -> f b -> f a
class Foldable (t :: Type -> Type)
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
- sequenceA :: Applicative f => t (f a) -> f (t a)
- mapM :: Monad m => (a -> m b) -> t a -> m (t b)
- sequence :: Monad m => t (m a) -> m (t a)
class Generic a
class KnownNat (n :: Nat)
class IsLabel (x :: Symbol) a where
- fromLabel :: a
class Semigroup a where
- sconcat :: NonEmpty a -> a
- stimes :: Integral b => b -> a -> a
class Semigroup a => Monoid a where
- mempty :: a
- mappend :: a -> a -> a
- mconcat :: [a] -> a
data Bool
- = False
- | True
type String = [Char]
data Char
data Double = D# Double#
data Float = F# Float#
data Int
data Int8
data Int16
data Int32
data Int64
data Integer
data Natural
data Maybe a
- = Nothing
- | Just a
data Ordering
- = LT
- | EQ
- | GT
data Ratio a = !a :% !a
type Rational = Ratio Integer
data IO a
data Word
data Word8
data Word16
data Word32
data Word64
data Ptr a
data FunPtr a
data Either a b
- = Left a
- | Right b
type Type = Type
data Constraint
type family CmpNat (a :: Nat) (b :: Nat) :: Ordering where ...
class a ~R# b => Coercible (a :: k) (b :: k)
data CallStack
data ByteString
byteSwap16 :: Word16 -> Word16
byteSwap32 :: Word32 -> Word32
byteSwap64 :: Word64 -> Word64
data MVar a
deepseq :: NFData a => a -> b -> b
force :: NFData a => a -> a
class NFData a where
- rnf :: a -> ()
data Set a
data Map k a
data SomeException = Exception e => SomeException e
(.) :: (b -> c) -> (a -> b) -> a -> c
(=<<) :: Monad m => (a -> m b) -> m a -> m b
ap :: Monad m => m (a -> b) -> m a -> m b
asTypeOf :: a -> a -> a
const :: a -> b -> a
flip :: (a -> b -> c) -> b -> a -> c
id :: a -> a
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
ord :: Char -> Int
class Applicative f => Alternative (f :: Type -> Type) where
- (<|>) :: f a -> f a -> f a
- many :: f a -> f [a]
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- mzero :: m a
- mplus :: m a -> m a -> m a
data NonEmpty a = a :| [a]
subtract :: Num a => a -> a -> a
curry :: ((a, b) -> c) -> a -> b -> c
uncurry :: (a -> b -> c) -> (a, b) -> c
(<$>) :: Functor f => (a -> b) -> f a -> f b
void :: Functor f => f a -> f ()
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
catMaybes :: [Maybe a] -> [a]
fromMaybe :: a -> Maybe a -> a
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool
listToMaybe :: [a] -> Maybe a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
maybe :: b -> (a -> b) -> Maybe a -> b
maybeToList :: Maybe a -> [a]
break :: (a -> Bool) -> [a] -> ([a], [a])
cycle :: [a] -> [a]
drop :: Int -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
iterate :: (a -> a) -> a -> [a]
repeat :: a -> [a]
replicate :: Int -> a -> [a]
reverse :: [a] -> [a]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
splitAt :: Int -> [a] -> ([a], [a])
take :: Int -> [a] -> [a]
takeWhile :: (a -> Bool) -> [a] -> [a]
unzip :: [(a, b)] -> ([a], [b])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
chr :: Int -> Char
(^^) :: (Fractional a, Integral b) => a -> b -> a
gcd :: Integral a => a -> a -> a
lcm :: Integral a => a -> a -> a
data Proxy (t :: k) = Proxy
either :: (a -> c) -> (b -> c) -> Either a b -> c
partitionEithers :: [Either a b] -> ([a], [b])
readMaybe :: Read a => String -> Maybe a
reads :: Read a => ReadS a
comparing :: Ord a => (b -> a) -> b -> b -> Ordering
intercalate :: [a] -> [[a]] -> [a]
intersperse :: a -> [a] -> [a]
isPrefixOf :: Eq a => [a] -> [a] -> Bool
sort :: Ord a => [a] -> [a]
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
newtype Const a (b :: k) = Const {
- getConst :: a
}
class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
prettyCallStack :: CallStack -> String
type FilePath = String
callStack :: HasCallStack => CallStack
withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
newtype Identity a = Identity {
- runIdentity :: a
}
optional :: Alternative f => f a -> f (Maybe a)
for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
head :: NonEmpty a -> a
init :: NonEmpty a -> [a]
last :: NonEmpty a -> a
tail :: NonEmpty a -> [a]
absurd :: Void -> a
vacuous :: Functor f => f Void -> f a
data Void
class MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- lift :: Monad m => m a -> t m a
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
fix :: (a -> a) -> a
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
(<$!>) :: Monad m => (a -> b) -> m a -> m b
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
forever :: Applicative f => f a -> f b
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
replicateM :: Applicative m => Int -> m a -> m [a]
replicateM_ :: Applicative m => Int -> m a -> m ()
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
modify :: MonadState s m => (s -> s) -> m ()
type Word62 = OddWord Word64 (One (One (One (One (One (Zero ()))))))
type Word63 = OddWord Word64 (One (One (One (One (One (One ()))))))
class Monad m => MonadReader r (m :: Type -> Type) | m -> r where
- ask :: m r
- local :: (r -> r) -> m a -> m a
- reader :: (r -> a) -> m a
class Monad m => MonadState s (m :: Type -> Type) | m -> s where
- put :: s -> m ()
- state :: (s -> (a, s)) -> m a
class Hashable a where
- hashWithSalt :: Int -> a -> Int
data Text
data HashMap k v
stdout :: Handle
data Handle
class Bifunctor (p :: Type -> Type -> Type) where
- bimap :: (a -> b) -> (c -> d) -> p a c -> p b d
- first :: (a -> b) -> p a c -> p b c
- second :: (b -> c) -> p a b -> p a c
newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) = Compose {
- getCompose :: f (g a)
}
data WrappedMonoid m
newtype Option a = Option {
- getOption :: Maybe a
}
mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
cycle1 :: Semigroup m => m -> m
sortWith :: Ord b => (a -> b) -> [a] -> [a]
nonEmpty :: [a] -> Maybe (NonEmpty a)
showStackTrace :: IO (Maybe String)
getStackTrace :: IO (Maybe [Location])
mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
fmapDefault :: Traversable t => (a -> b) -> t a -> t b
newtype ZipList a = ZipList {
- getZipList :: [a]
}
(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
stdin :: Handle
stderr :: Handle
data TVar a
data STM a
writeTVar :: TVar a -> a -> STM ()
readTVar :: TVar a -> STM a
newTVar :: a -> STM (TVar a)
data IORef a
prettySrcLoc :: SrcLoc -> String
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
transpose :: [[a]] -> [[a]]
tails :: [a] -> [[a]]
subsequences :: [a] -> [[a]]
sortOn :: Ord b => (a -> b) -> [a] -> [a]
permutations :: [a] -> [[a]]
inits :: [a] -> [[a]]
group :: Eq a => [a] -> [[a]]
genericTake :: Integral i => i -> [a] -> [a]
genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
genericReplicate :: Integral i => i -> a -> [a]
genericLength :: Num i => [a] -> i
genericDrop :: Integral i => i -> [a] -> [a]
newtype Last a = Last {
- getLast :: Maybe a
}
newtype First a = First {
- getFirst :: Maybe a
}
newtype Sum a = Sum {
- getSum :: a
}
newtype Product a = Product {
- getProduct :: a
}
newtype Endo a = Endo {
- appEndo :: a -> a
}
newtype Dual a = Dual {
- getDual :: a
}
newtype Alt (f :: k -> Type) (a :: k) = Alt {
- getAlt :: f a
}
stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
stimesIdempotent :: Integral b => b -> a -> a
newtype Down a = Down {
- getDown :: a
}
data SomeNat = KnownNat n => SomeNat (Proxy n)
someNatVal :: Natural -> SomeNat
natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Natural
rights :: [Either a b] -> [b]
lefts :: [Either a b] -> [a]
isRight :: Either a b -> Bool
isLeft :: Either a b -> Bool
data IOMode
- = ReadMode
- | WriteMode
- | AppendMode
- | ReadWriteMode
underflowError :: a
reduce :: Integral a => a -> a -> Ratio a
ratioZeroDenominatorError :: a
ratioPrec1 :: Int
ratioPrec :: Int
overflowError :: a
numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a]
numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a]
numericEnumFromThen :: Fractional a => a -> a -> [a]
numericEnumFrom :: Fractional a => a -> [a]
numerator :: Ratio a -> a
notANumber :: Rational
naturalFromInt :: Int -> Natural
integralEnumFromTo :: Integral a => a -> a -> [a]
integralEnumFromThenTo :: Integral a => a -> a -> a -> [a]
integralEnumFromThen :: (Integral a, Bounded a) => a -> a -> [a]
integralEnumFrom :: (Integral a, Bounded a) => a -> [a]
infinity :: Rational
divZeroError :: a
denominator :: Ratio a -> a
(^^%^^) :: Integral a => Rational -> a -> Rational
(^%^) :: Integral a => Rational -> a -> Rational
boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
bool :: a -> a -> Bool -> a
(&) :: a -> (a -> b) -> b
(<&>) :: Functor f => f a -> (a -> b) -> f b
($>) :: Functor f => f a -> b -> f b
swap :: (a, b) -> (b, a)
currentCallStack :: IO [String]
minInt :: Int
maxInt :: Int
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
type HasCallStack = ?callStack :: CallStack
getCallStack :: CallStack -> [([Char], SrcLoc)]
stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
data IdentityT (f :: k -> Type) (a :: k)
withDict :: HasDict c e => e -> (c => r) -> r
data IntMap a
data IntSet
data Seq a
class Default a where
- def :: a
($!!) :: NFData a => (a -> b) -> a -> b
runExceptT :: ExceptT e m a -> m (Either e a)
newtype ExceptT e (m :: Type -> Type) a = ExceptT (m (Either e a))
newtype MaybeT (m :: Type -> Type) a = MaybeT {
- runMaybeT :: m (Maybe a)
}
class Monad m => MonadThrow (m :: Type -> Type)
class MonadCatch m => MonadMask (m :: Type -> Type) where
- mask :: ((forall a. m a -> m a) -> m b) -> m b
- uninterruptibleMask :: ((forall a. m a -> m a) -> m b) -> m b
- generalBracket :: m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)
class MonadThrow m => MonadCatch (m :: Type -> Type)
type family IntBaseType a :: IntBaseTypeK
toStrict :: Text -> Text
data HashSet a
newtype StateT s (m :: Type -> Type) a = StateT {
- runStateT :: s -> m (a, s)
}
type State s = StateT s Identity
data Vector a
type Reader r = ReaderT r Identity
gets :: MonadState s m => (s -> a) -> m a
preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a)
preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)
(^..) :: s -> Getting (Endo [a]) s a -> [a]
use :: MonadState s m => Getting a s a -> m a
view :: MonadReader s m => Getting a s a -> m a
_1 :: Field1 s t a b => Lens s t a b
_2 :: Field2 s t a b => Lens s t a b
_3 :: Field3 s t a b => Lens s t a b
_4 :: Field4 s t a b => Lens s t a b
_5 :: Field5 s t a b => Lens s t a b
(.~) :: ASetter s t a b -> b -> s -> t
set :: ASetter s t a b -> b -> s -> t
over :: ASetter s t a b -> (a -> b) -> s -> t
type Lens s t a b = forall (f :: Type -> Type). Functor f => (a -> f b) -> s -> f t
type Lens' s a = Lens s s a a
type Traversal s t a b = forall (f :: Type -> Type). Applicative f => (a -> f b) -> s -> f t
type Traversal' s a = Traversal s s a a
printLorentzContract :: Bool -> Contract cp st vd -> LText
printLorentzValue :: NiceUntypedValue v => Bool -> v -> LText
cdCompilationOptionsL :: Lens' (ContractData cp st vd) CompilationOptions
cdCodeL :: forall cp st vd cp1. NiceParameterFull cp1 => Lens (ContractData cp st vd) (ContractData cp1 st vd) (ContractCode cp st) (ContractCode cp1 st)
coStringTransformerL :: Lens' CompilationOptions (Bool, MText -> MText)
coOptimizerConfL :: Lens' CompilationOptions (Maybe OptimizerConf)
coBytesTransformerL :: Lens' CompilationOptions (Bool, ByteString -> ByteString)
analyzeLorentz :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> AnalyzerRes
interpretLorentzLambda :: (IsoValue inp, IsoValue out) => ContractEnv -> (IsNotInView => Fn inp out) -> inp -> Either (MichelsonFailureWithStack Void) out
interpretLorentzInstr :: forall (inp :: [Type]) (out :: [Type]). (IsoValuesStack inp, IsoValuesStack out) => ContractEnv -> (IsNotInView => inp :-> out) -> Rec Identity inp -> Either (MichelsonFailureWithStack Void) (Rec Identity out)
noViews :: forall {k1} {k2} contract (cp :: k1) (st :: k2). contract cp st () -> contract cp st ()
setViewsRec :: forall vd cp st. NiceViewsDescriptor vd => Rec (ContractView st) (RevealViews vd) -> ContractData cp st () -> ContractData cp st vd
setViews :: forall vd cp st. (RecFromTuple (Rec (ContractView st) (RevealViews vd)), NiceViewsDescriptor vd) => IsoRecTuple (Rec (ContractView st) (RevealViews vd)) -> ContractData cp st () -> ContractData cp st vd
compileLorentzContract :: ContractData cp st vd -> Contract cp st vd
defaultContractData :: (NiceParameterFull cp, NiceStorageFull st) => (IsNotInView => '[(cp, st)] :-> ContractOut st) -> ContractData cp st ()
mkView :: forall (name :: Symbol) arg ret st. (KnownSymbol name, NiceViewable arg, NiceViewable ret, HasAnnotation arg, HasAnnotation ret, TypeHasDoc arg, TypeHasDoc ret) => ViewCode arg st ret -> ContractView st ('ViewTyInfo name arg ret)
mkContractWith :: (NiceParameterFull cp, NiceStorageFull st) => CompilationOptions -> ContractCode cp st -> Contract cp st ()
mkContract :: (NiceParameterFull cp, NiceStorageFull st) => ContractCode cp st -> Contract cp st ()
defaultContract :: (NiceParameterFull cp, NiceStorageFull st) => (IsNotInView => '[(cp, st)] :-> ContractOut st) -> Contract cp st ()
compileLorentzWithOptions :: forall (inp :: [Type]) (out :: [Type]). CompilationOptions -> (inp :-> out) -> Instr (ToTs inp) (ToTs out)
compileLorentz :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> Instr (ToTs inp) (ToTs out)
intactCompilationOptions :: CompilationOptions
defaultCompilationOptions :: CompilationOptions
data CompilationOptions = CompilationOptions {
- coOptimizerConf :: Maybe OptimizerConf
- coStringTransformer :: (Bool, MText -> MText)
- coBytesTransformer :: (Bool, ByteString -> ByteString)
}
data ContractData cp st vd = (NiceParameterFull cp, NiceStorageFull st, NiceViewsDescriptor vd) => ContractData {
- cdCode :: ContractCode cp st
- cdViews :: Rec (ContractView st) (RevealViews vd)
- cdCompilationOptions :: CompilationOptions
}
data ContractView st (v :: ViewTyInfo) where
- ContractView :: forall (name :: Symbol) arg ret st. (KnownSymbol name, NiceViewable arg, NiceViewable ret, HasAnnotation arg, HasAnnotation ret) => ViewCode arg st ret -> ContractView st ('ViewTyInfo name arg ret)
pbsUParam :: forall (ctorName :: Symbol). KnownSymbol ctorName => ParamBuildingStep
uparamFromAdt :: UParamLinearize up => up -> UParam (UParamLinearized up)
caseUParamT :: forall (entries :: [EntrypointKind]) (inp :: [Type]) (out :: [Type]) clauses. (clauses ~ Rec (CaseClauseU inp out) entries, RecFromTuple clauses, CaseUParam entries) => IsoRecTuple clauses -> UParamFallback inp out -> (UParam entries ': inp) :-> out
caseUParam :: forall (entries :: [EntrypointKind]) (inp :: [Type]) (out :: [Type]). (CaseUParam entries, RequireUniqueEntrypoints entries) => Rec (CaseClauseU inp out) entries -> UParamFallback inp out -> (UParam entries ': inp) :-> out
uparamFallbackFail :: forall (inp :: [Type]) (out :: [Type]). UParamFallback inp out
unwrapUParam :: forall (entries :: [EntrypointKind]) (s :: [Type]). (UParam entries ': s) :-> ((MText, ByteString) ': s)
mkUParam :: forall a (name :: Symbol) (entries :: [EntrypointKind]). (NicePackedValue a, LookupEntrypoint name entries ~ a, RequireUniqueEntrypoints entries) => Label name -> a -> UParam entries
type EntrypointKind = (Symbol, Type)
type (?:) (n :: Symbol) (a :: k) = '(n, a)
newtype UParam (entries :: [EntrypointKind]) = UnsafeUParam (MText, ByteString)
type SomeInterface = '['("SomeEntrypoints", Void)]
type UParam_ = UParam SomeInterface
type family LookupEntrypoint (name :: Symbol) (entries :: [EntrypointKind]) where ...
type family RequireUniqueEntrypoints (entries :: [EntrypointKind]) where ...
data ConstrainedSome (c :: Type -> Constraint) where
- ConstrainedSome :: forall (c :: Type -> Constraint) a. c a => a -> ConstrainedSome c
class UnpackUParam (c :: Type -> Constraint) (entries :: [EntrypointKind]) where
- unpackUParam :: UParam entries -> Either EntrypointLookupError (MText, ConstrainedSome c)
data EntrypointLookupError
- = NoSuchEntrypoint MText
- | ArgumentUnpackFailed
type EntrypointsImpl (inp :: [Type]) (out :: [Type]) (entries :: [EntrypointKind]) = Rec (CaseClauseU inp out) entries
type UParamFallback (inp :: [Type]) (out :: [Type]) = ((MText, ByteString) ': inp) :-> out
class CaseUParam (entries :: [EntrypointKind])
type UParamLinearize p = (Generic p, GUParamLinearize (Rep p))
type UParamLinearized p = GUParamLinearized (Rep p)
entryCaseFlattenedHiding :: forall (heps :: [Symbol]) cp (out :: [Type]) (inp :: [Type]) clauses. (CaseTC cp out inp clauses, DocumentEntrypoints (FlattenedEntrypointsKindHiding heps) cp, HasEntrypoints (ParameterEntrypointsDerivation cp) cp heps) => IsoRecTuple clauses -> (cp ': inp) :-> out
entryCaseFlattenedHiding_ :: forall (heps :: [Symbol]) cp (out :: [Type]) (inp :: [Type]). (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints (FlattenedEntrypointsKindHiding heps) cp, HasEntrypoints (ParameterEntrypointsDerivation cp) cp heps) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp ': inp) :-> out
entryCaseFlattened :: forall cp (out :: [Type]) (inp :: [Type]) clauses. (CaseTC cp out inp clauses, DocumentEntrypoints FlattenedEntrypointsKind cp) => IsoRecTuple clauses -> (cp ': inp) :-> out
entryCaseFlattened_ :: forall cp (out :: [Type]) (inp :: [Type]). (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints FlattenedEntrypointsKind cp) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp ': inp) :-> out
entryCaseSimple_ :: forall cp (out :: [Type]) (inp :: [Type]). (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints PlainEntrypointsKind cp, RequireFlatParamEps cp) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp ': inp) :-> out
areFinalizedParamBuildingSteps :: [ParamBuildingStep] -> Bool
finalizeParamCallingDoc' :: forall cp (inp :: [Type]) (out :: [Type]). (NiceParameterFull cp, HasCallStack) => Proxy cp -> (inp :-> out) -> inp :-> out
documentEntrypoint :: forall kind (epName :: Symbol) param (s :: [Type]) (out :: [Type]). (KnownSymbol epName, DocItem (DEntrypoint kind), NiceParameter param, TypeHasDoc param) => ((param ': s) :-> out) -> (param ': s) :-> out
clarifyParamBuildingSteps :: forall (inp :: [Type]) (out :: [Type]). ParamBuildingStep -> (inp :-> out) -> inp :-> out
mkDEntrypointArgSimple :: (NiceParameter t, TypeHasDoc t) => DEntrypointArg
mkDEpUType :: HasAnnotation t => Ty
emptyDEpArg :: DEntrypointArg
mkPbsWrapIn :: Text -> ParamBuilder -> ParamBuildingStep
entrypointSection :: forall kind (i :: [Type]) (o :: [Type]). EntrypointKindHasDoc kind => Text -> Proxy kind -> (i :-> o) -> i :-> o
diEntrypointToMarkdown :: HeaderLevel -> DEntrypoint level -> Markdown
pattern DEntrypointDocItem :: () => DEntrypoint kind -> SomeDocItem
data DEntrypoint kind = DEntrypoint {
- depName :: Text
- depSub :: SubDoc
}
type family EntrypointKindOverride ep
class Typeable ep => EntrypointKindHasDoc ep where
- type EntrypointKindOverride ep
- entrypointKindOverrideSpecified :: Dict ((EntrypointKindOverride ep == ep) ~ 'False)
- entrypointKindPos :: Natural
- entrypointKindSectionName :: Text
- entrypointKindSectionDescription :: Maybe Markdown
data PlainEntrypointsKind
data FlattenedEntrypointsKindHiding (hiddenEntrypoints :: [Symbol])
type FlattenedEntrypointsKind = FlattenedEntrypointsKindHiding ('[] :: [Symbol])
data CommonContractBehaviourKind
data CommonEntrypointsBehaviourKind (kind :: k)
data DEntrypointReference = DEntrypointReference Text Anchor
newtype ParamBuilder = ParamBuilder {
- unParamBuilder :: Markdown -> Markdown
}
data ParamBuildingDesc = ParamBuildingDesc {
- pbdEnglish :: Markdown
- pbdHaskell :: ParamBuilder
- pbdMichelson :: ParamBuilder
}
data ParamBuildingStep
- = PbsWrapIn Text ParamBuildingDesc
- | PbsCallEntrypoint EpName
- | PbsCustom ParamBuildingDesc
- | PbsUncallable [ParamBuildingStep]
data SomeEntrypointArg = (NiceParameter a, TypeHasDoc a) => SomeEntrypointArg (Proxy a)
data DEntrypointArg = DEntrypointArg {
- epaArg :: Maybe SomeEntrypointArg
- epaBuilding :: [ParamBuildingStep]
}
class KnownSymbol con => DeriveCtorFieldDoc (con :: Symbol) (cf :: CtorField) where
- deriveCtorFieldDoc :: DEntrypointArg
type DocumentEntrypoints kind a = (Generic a, GDocumentEntrypoints (BuildEPTree' a) kind (Rep a) ('[] :: [CaseClauseParam]))
class EntryArrow (kind :: k) (name :: Symbol) body where
- (#->) :: (Label name, Proxy kind) -> body -> body
type family RequireFlatParamEps cp where ...
type family RequireFlatEpDerivation (cp :: t) deriv where ...
stNickname :: forall (name :: Symbol). Label name -> FieldRef (FieldAlias name)
stAlias :: forall {k} (alias :: k). FieldRef (FieldAlias alias)
stNested :: StNestedImpl f SelfRef => f
this :: forall (p :: FieldRefTag). SelfRef p
mkStoreEp :: forall (epName :: Symbol) epParam epStore. Label epName -> EntrypointLambda epParam epStore -> EntrypointsField epParam epStore
zoomStoreSubmapOps :: forall {k1} {k2} store (submapName :: k1) (nameInSubmap :: k2) key value subvalue. (NiceConstant value, NiceConstant subvalue, Dupable key, Dupable store) => FieldRef submapName -> LIso (Maybe value) value -> LIso (Maybe subvalue) subvalue -> StoreSubmapOps store submapName key value -> StoreFieldOps value nameInSubmap subvalue -> StoreSubmapOps store nameInSubmap key subvalue
composeStoreEntrypointOps :: forall {k} store substore (nameInStore :: k) (epName :: Symbol) epParam epStore. (HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreEntrypointOps substore epName epParam epStore -> StoreEntrypointOps store epName epParam epStore
sequenceStoreSubmapOps :: forall {k1} {k2} store substore value (name :: k1) (subName :: k2) key1 key2. (NiceConstant substore, KnownValue value, Dupable (key1, key2), Dupable store) => FieldRef name -> LIso (Maybe substore) substore -> StoreSubmapOps store name key1 substore -> StoreSubmapOps substore subName key2 value -> StoreSubmapOps store subName (key1, key2) value
composeStoreSubmapOps :: forall {k1} {k2} store substore (nameInStore :: k1) (mname :: k2) key value. (HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreSubmapOps substore mname key value -> StoreSubmapOps store mname key value
composeStoreFieldOps :: forall {k1} {k2} substore (nameInStore :: k1) store (nameInSubstore :: k2) field. HasDupableGetters substore => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreFieldOps substore nameInSubstore field -> StoreFieldOps store nameInSubstore field
mapStoreSubmapOpsValue :: forall {k} value1 value2 store (name :: k) key. (KnownValue value1, KnownValue value2) => LIso value1 value2 -> StoreSubmapOps store name key value1 -> StoreSubmapOps store name key value2
mapStoreSubmapOpsKey :: forall {k} key2 key1 store (name :: k) value. Fn key2 key1 -> StoreSubmapOps store name key1 value -> StoreSubmapOps store name key2 value
mapStoreFieldOps :: forall {k} field1 field2 store (name :: k). KnownValue field1 => LIso field1 field2 -> StoreFieldOps store name field1 -> StoreFieldOps store name field2
storeEntrypointOpsReferTo :: forall (epName :: Symbol) store epParam epStore (desiredName :: Symbol). Label epName -> StoreEntrypointOps store epName epParam epStore -> StoreEntrypointOps store desiredName epParam epStore
storeFieldOpsReferTo :: forall {k1} {k2} (name :: k1) storage field (desiredName :: k2). FieldRef name -> StoreFieldOps storage name field -> StoreFieldOps storage desiredName field
storeSubmapOpsReferTo :: forall {k1} {k2} (name :: k1) storage key value (desiredName :: k2). FieldRef name -> StoreSubmapOps storage name key value -> StoreSubmapOps storage desiredName key value
storeEntrypointOpsDeeper :: forall store (nameInStore :: Symbol) substore (epName :: Symbol) epParam epStore. (HasFieldOfType store nameInStore substore, StoreHasEntrypoint substore epName epParam epStore, HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreEntrypointOps store epName epParam epStore
storeSubmapOpsDeeper :: forall {k} storage (bigMapPartName :: Symbol) fields key value (mname :: k). (HasFieldOfType storage bigMapPartName fields, StoreHasSubmap fields SelfRef key value, HasDupableGetters storage, Dupable fields) => FieldRef bigMapPartName -> StoreSubmapOps storage mname key value
storeFieldOpsDeeper :: forall {k} storage (fieldsPartName :: Symbol) fields (fname :: k) ftype. (HasFieldOfType storage fieldsPartName fields, StoreHasField fields fname ftype, HasDupableGetters fields) => FieldRef fieldsPartName -> StoreFieldOps storage fname ftype
storeEntrypointOpsSubmapField :: forall store (epmName :: Symbol) epParam epStore (epsName :: Symbol) (epName :: Symbol). (StoreHasSubmap store epmName MText (EntrypointLambda epParam epStore), StoreHasField store epsName epStore, KnownValue epParam, KnownValue epStore) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore
storeEntrypointOpsFields :: forall store (epmName :: Symbol) epParam epStore (epsName :: Symbol) (epName :: Symbol). (StoreHasField store epmName (EntrypointsField epParam epStore), StoreHasField store epsName epStore, KnownValue epParam, KnownValue epStore) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore
storeEntrypointOpsADT :: forall store (epmName :: Symbol) epParam epStore (epsName :: Symbol) (epName :: Symbol). (HasFieldOfType store epmName (EntrypointsField epParam epStore), HasFieldOfType store epsName epStore, KnownValue epParam, KnownValue epStore) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore
storeFieldOpsADT :: forall dt (fname :: Symbol) ftype. HasFieldOfType dt fname ftype => StoreFieldOps dt fname ftype
stSetEpStore :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). StoreHasEntrypoint store epName epParam epStore => Label epName -> (epStore ': (store ': s)) :-> (store ': s)
stGetEpStore :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (store ': s) :-> (epStore ': (store ': s))
stToEpStore :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). StoreHasEntrypoint store epName epParam epStore => Label epName -> (store ': s) :-> (epStore ': s)
stSetEpLambda :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). (StoreHasEntrypoint store epName epParam epStore, HasDupableGetters store) => Label epName -> (EntrypointLambda epParam epStore ': (store ': s)) :-> (store ': s)
stGetEpLambda :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (store ': s) :-> (EntrypointLambda epParam epStore ': (store ': s))
stToEpLambda :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). StoreHasEntrypoint store epName epParam epStore => Label epName -> (store ': s) :-> (EntrypointLambda epParam epStore ': s)
stEntrypoint :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (epParam ': (store ': s)) :-> (([Operation], store) ': s)
stGetAndUpdate :: forall {k} store (mname :: k) key value (s :: [Type]). StoreHasSubmap store mname key value => FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (Maybe value ': (store ': s))
stSetField :: forall {k} store (fname :: k) ftype (s :: [Type]). StoreHasField store fname ftype => FieldRef fname -> (ftype ': (store ': s)) :-> (store ': s)
stGetFieldNamed :: forall {k} store (fname :: k) ftype (s :: [Type]). (StoreHasField store fname ftype, FieldRefHasFinalName fname, Dupable ftype, HasDupableGetters store) => FieldRef fname -> (store ': s) :-> ((FieldRefFinalName fname :! ftype) ': (store ': s))
stToFieldNamed :: forall {k} store (fname :: k) ftype (s :: [Type]). (StoreHasField store fname ftype, FieldRefHasFinalName fname) => FieldRef fname -> (store ': s) :-> ((FieldRefFinalName fname :! ftype) ': s)
stGetField :: forall {k} store (fname :: k) ftype (s :: [Type]). (StoreHasField store fname ftype, Dupable ftype, HasDupableGetters store) => FieldRef fname -> (store ': s) :-> (ftype ': (store ': s))
stToField :: forall {k} store (fname :: k) ftype (s :: [Type]). StoreHasField store fname ftype => FieldRef fname -> (store ': s) :-> (ftype ': s)
sopSetField :: forall {k} store (fname :: k) ftype (s :: [Type]). StoreFieldOps store fname ftype -> FieldRef fname -> (ftype ': (store ': s)) :-> (store ': s)
sopGetField :: forall {k} ftype store (fname :: k) (s :: [Type]). (Dupable ftype, HasDupableGetters store) => StoreFieldOps store fname ftype -> FieldRef fname -> (store ': s) :-> (ftype ': (store ': s))
fieldNameFromLabel :: forall (n :: Symbol). Label n -> FieldSymRef n
fieldNameToLabel :: forall (n :: Symbol). FieldSymRef n -> Label n
type FieldRefKind = FieldRefTag -> Type
data FieldRefTag
type family FieldRefObject (ty :: k) = (fr :: FieldRefKind) | fr -> k ty
class KnownFieldRef (ty :: k) where
- type FieldRefObject (ty :: k) = (fr :: FieldRefKind) | fr -> k ty
- mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject ty p
type FieldRef (name :: k) = FieldRefObject name 'FieldRefTag
data FieldName (n :: Symbol) (p :: FieldRefTag)
type FieldSymRef (name :: Symbol) = FieldRef name
type family FieldRefFinalName (fr :: k) :: Symbol
class FieldRefHasFinalName (fr :: k) where
- type FieldRefFinalName (fr :: k) :: Symbol
- fieldRefFinalName :: FieldRef fr -> Label (FieldRefFinalName fr)
data StoreFieldOps store (fname :: k) ftype = StoreFieldOps {
- sopToField :: forall (s :: [Type]). FieldRef fname -> (store ': s) :-> (ftype ': s)
- sopGetFieldOpen :: forall res (s :: [Type]). HasDupableGetters store => ('[ftype] :-> '[res, ftype]) -> ('[ftype] :-> '[res]) -> FieldRef fname -> (store ': s) :-> (res ': (store ': s))
- sopSetFieldOpen :: forall new (s :: [Type]). ('[new, ftype] :-> '[ftype]) -> FieldRef fname -> (new ': (store ': s)) :-> (store ': s)
}
class StoreHasField store (fname :: k) ftype | store fname -> ftype where
- storeFieldOps :: StoreFieldOps store fname ftype
data StoreSubmapOps store (mname :: k) key value = StoreSubmapOps {
- sopMem :: forall (s :: [Type]). FieldRef mname -> (key ': (store ': s)) :-> (Bool ': s)
- sopGet :: forall (s :: [Type]). KnownValue value => FieldRef mname -> (key ': (store ': s)) :-> (Maybe value ': s)
- sopUpdate :: forall (s :: [Type]). FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (store ': s)
- sopGetAndUpdate :: forall (s :: [Type]). FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (Maybe value ': (store ': s))
- sopDelete :: forall (s :: [Type]). FieldRef mname -> (key ': (store ': s)) :-> (store ': s)
- sopInsert :: forall (s :: [Type]). FieldRef mname -> (key ': (value ': (store ': s))) :-> (store ': s)
}
class StoreHasSubmap store (mname :: k) key value | store mname -> key value where
- storeSubmapOps :: StoreSubmapOps store mname key value
type EntrypointLambda param store = Lambda (param, store) ([Operation], store)
type EntrypointsField param store = BigMap MText (EntrypointLambda param store)
data StoreEntrypointOps store (epName :: Symbol) epParam epStore = StoreEntrypointOps {
- sopToEpLambda :: forall (s :: [Type]). Label epName -> (store ': s) :-> (EntrypointLambda epParam epStore ': s)
- sopSetEpLambda :: forall (s :: [Type]). HasDupableGetters store => Label epName -> (EntrypointLambda epParam epStore ': (store ': s)) :-> (store ': s)
- sopToEpStore :: forall (s :: [Type]). Label epName -> (store ': s) :-> (epStore ': s)
- sopSetEpStore :: forall (s :: [Type]). Label epName -> (epStore ': (store ': s)) :-> (store ': s)
}
class StoreHasEntrypoint store (epName :: Symbol) epParam epStore | store epName -> epParam epStore where
- storeEpOps :: StoreEntrypointOps store epName epParam epStore
data ((l :: k1) :-| (r :: k2)) (p :: FieldRefTag) = (FieldRef l) :-| (FieldRef r)
data SelfRef (p :: FieldRefTag) = SelfRef
data FieldAlias (alias :: k) (p :: FieldRefTag)
type FieldNickname (alias :: Symbol) = FieldAlias alias
data (k2 :: k) ~> (v :: k1)
data (param :: k) ::-> (store :: k1)
type family StorageContains store (content :: [NamedField]) where ...
baseErrorDocHandlers :: [NumericErrorDocHandler]
voidResultDocHandler :: NumericErrorDocHandler
customErrorDocHandler :: NumericErrorDocHandler
applyErrorTagToErrorsDocWith :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => [NumericErrorDocHandler] -> ErrorTagMap -> (inp :-> out) -> inp :-> out
applyErrorTagToErrorsDoc :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => ErrorTagMap -> (inp :-> out) -> inp :-> out
data DDescribeErrorTagMap = DDescribeErrorTagMap {
- detmSrcLoc :: Text
}
data NumericErrorDocHandlerError
data NumericErrorDocHandler
data NumericErrorWrapper (numTag :: Nat) err
voidResultTag :: MText
data View_ a r
data Void_ a b
data VoidResult r
class NonZero t
unsafeUnwrap_ :: forall dt (name :: Symbol) (st :: [Type]). InstrUnwrapC dt name => Label name -> (dt ': st) :-> (CtorOnlyField name dt ': st)
wrapOne :: forall dt (name :: Symbol) (st :: [Type]). InstrWrapOneC dt name => Label name -> (CtorOnlyField name dt ': st) :-> (dt ': st)
wrap_ :: forall dt (name :: Symbol) (st :: [Type]). InstrWrapC dt name => Label name -> AppendCtorField (GetCtorField dt name) st :-> (dt ': st)
fieldCtor :: forall (st :: [Type]) f. HasCallStack => (st :-> (f ': st)) -> FieldConstructor st f
deconstruct :: forall dt (fields :: [Type]) (st :: [Type]). (InstrDeconstructC dt (ToTs st), fields ~ GFieldTypes (Rep dt) ('[] :: [Type]), (ToTs fields ++ ToTs st) ~ ToTs (fields ++ st)) => (dt ': st) :-> (fields ++ st)
constructStack :: forall dt (fields :: [Type]) (st :: [Type]). (InstrConstructC dt, fields ~ ConstructorFieldTypes dt, (ToTs fields ++ ToTs st) ~ ToTs (fields ++ st)) => (fields ++ st) :-> (dt ': st)
setFieldOpen :: forall dt (name :: Symbol) new (st :: [Type]). InstrSetFieldC dt name => ('[new, GetFieldType dt name] :-> '[GetFieldType dt name]) -> Label name -> (new ': (dt ': st)) :-> (dt ': st)
getFieldOpen :: forall dt (name :: Symbol) res (st :: [Type]). (InstrGetFieldC dt name, HasDupableGetters dt) => ('[GetFieldType dt name] :-> '[res, GetFieldType dt name]) -> ('[GetFieldType dt name] :-> '[res]) -> Label name -> (dt ': st) :-> (res ': (dt ': st))
modifyField :: forall dt (name :: Symbol) (st :: [Type]). (InstrGetFieldC dt name, InstrSetFieldC dt name, Dupable (GetFieldType dt name), HasDupableGetters dt) => Label name -> (forall (st0 :: [Type]). (GetFieldType dt name ': st0) :-> (GetFieldType dt name ': st0)) -> (dt ': st) :-> (dt ': st)
getFieldNamed :: forall dt (name :: Symbol) (st :: [Type]). (InstrGetFieldC dt name, Dupable (GetFieldType dt name), HasDupableGetters dt) => Label name -> (dt ': st) :-> ((name :! GetFieldType dt name) ': (dt ': st))
getField :: forall dt (name :: Symbol) (st :: [Type]). (InstrGetFieldC dt name, Dupable (GetFieldType dt name), HasDupableGetters dt) => Label name -> (dt ': st) :-> (GetFieldType dt name ': (dt ': st))
toFieldNamed :: forall dt (name :: Symbol) (st :: [Type]). InstrGetFieldC dt name => Label name -> (dt ': st) :-> ((name :! GetFieldType dt name) ': st)
toField :: forall dt (name :: Symbol) (st :: [Type]). InstrGetFieldC dt name => Label name -> (dt ': st) :-> (GetFieldType dt name ': st)
type HasFieldOfType dt (fname :: Symbol) fieldTy = (HasField dt fname, GetFieldType dt fname ~ fieldTy)
data NamedField = NamedField Symbol Type
type (:=) (n :: Symbol) ty = 'NamedField n ty
type family HasFieldsOfType dt (fs :: [NamedField]) where ...
class HasDupableGetters (a :: k)
data CaseClauseL (inp :: [Type]) (out :: [Type]) (param :: CaseClauseParam) where
- CaseClauseL :: forall (x :: CtorField) (inp :: [Type]) (out :: [Type]) (ctor :: Symbol). (AppendCtorField x inp :-> out) -> CaseClauseL inp out ('CaseClauseParam ctor x)
class CaseArrow (name :: Symbol) body clause | clause -> name, clause -> body where
- (/->) :: Label name -> body -> clause
type CaseTC dt (out :: [Type]) (inp :: [Type]) clauses = (InstrCaseC dt, RMap (CaseClauses dt), RecFromTuple clauses, clauses ~ Rec (CaseClauseL inp out) (CaseClauses dt))
errorToValNumeric :: IsError e => ErrorTagMap -> e -> (forall (t :: T). ConstantScope t => Value t -> r) -> r
errorFromValNumeric :: forall (t :: T) e. (SingI t, IsError e) => ErrorTagMap -> Value t -> Either Text e
useNumericErrors :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => (inp :-> out) -> (inp :-> out, ErrorTagMap)
applyErrorTagMapWithExclusions :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => ErrorTagMap -> ErrorTagExclusions -> (inp :-> out) -> inp :-> out
applyErrorTagMap :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => ErrorTagMap -> (inp :-> out) -> inp :-> out
excludeErrorTags :: HasCallStack => ErrorTagExclusions -> ErrorTagMap -> ErrorTagMap
buildErrorTagMap :: HashSet MText -> ErrorTagMap
addNewErrorTags :: ErrorTagMap -> HashSet MText -> ErrorTagMap
gatherErrorTags :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> HashSet MText
type ErrorTagMap = Bimap Natural MText
type ErrorTagExclusions = HashSet MText
typeDoc :: QuasiQuoter
errorDocArg :: QuasiQuoter
entrypointDoc :: QuasiQuoter
typeDocMdDescriptionReferToError :: IsError e => Markdown
isInternalErrorClass :: ErrorClass -> Bool
errorTagToText :: forall (tag :: Symbol). KnownSymbol tag => Text
errorTagToMText :: forall (tag :: Symbol). Label tag -> MText
failUnexpected :: forall (s :: [Type]) (t :: [Type]). MText -> s :-> t
simpleFailUsing :: forall e (s :: [Type]) (t :: [Type]). IsError e => e -> s :-> t
isoErrorFromVal :: forall (t :: T) e. (SingI t, KnownIsoT e, IsoValue e) => Value t -> Either Text e
isoErrorToVal :: (KnownError e, IsoValue e) => e -> (forall (t :: T). ErrorScope t => Value t -> r) -> r
type ErrorScope (t :: T) = ConstantScope t
class ErrorHasDoc e => IsError e where
- errorToVal :: e -> (forall (t :: T). ErrorScope t => Value t -> r) -> r
- errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text e
- failUsing :: forall (s :: [Type]) (t :: [Type]). IsError e => e -> s :-> t
type family ErrorRequirements e
class Typeable e => ErrorHasDoc e where
- type ErrorRequirements e
- errorDocName :: Text
- errorDocMdCause :: Markdown
- errorDocMdCauseInEntrypoint :: Markdown
- errorDocHaskellRep :: Markdown
- errorDocClass :: ErrorClass
- errorDocDependencies :: [SomeDocDefinitionItem]
- errorDocRequirements :: Dict (ErrorRequirements e)
data UnspecifiedError = UnspecifiedError
data Impossible (reason :: Symbol) = HasCallStack => Impossible
data SomeError = (IsError e, Eq e) => SomeError e
type family ErrorArg (tag :: Symbol)
data CustomError (tag :: Symbol) = CustomError {
- ceTag :: Label tag
- ceArg :: CustomErrorRep tag
}
data NoErrorArg
data UnitErrorArg
type CustomErrorRep (tag :: Symbol) = CustomErrorArgRep (ErrorArg tag)
class IsCustomErrorArgRep a where
- verifyErrorTag :: MText -> a -> Either Text a
- customErrorRepDocDeps :: [SomeDocDefinitionItem]
- customErrorHaskellRep :: forall (tag :: Symbol). (KnownSymbol tag, CustomErrorHasDoc tag) => Proxy tag -> Markdown
type MustHaveErrorArg (errorTag :: Symbol) expectedArgRep = FailUnlessEqual (CustomErrorRep errorTag) expectedArgRep ((('Text "Error argument type is " :<>: 'ShowType expectedArgRep) :<>: 'Text " but given error requires argument of type ") :<>: 'ShowType (CustomErrorRep errorTag))
data ErrorClass
- = ErrClassActionException
- | ErrClassBadArgument
- | ErrClassContractInternal
- | ErrClassUnknown
class (KnownSymbol tag, TypeHasDoc (CustomErrorRep tag), IsError (CustomError tag)) => CustomErrorHasDoc (tag :: Symbol) where
- customErrDocMdCause :: Markdown
- customErrDocMdCauseInEntrypoint :: Markdown
- customErrClass :: ErrorClass
- customErrArgumentSemantics :: Maybe Markdown
data DError where
- DError :: forall e. ErrorHasDoc e => Proxy e -> DError
data DThrows where
- DThrows :: forall e. ErrorHasDoc e => Proxy e -> DThrows
dropT :: forall a (inp :: [Type]) (dinp :: [Type]) (dout :: [Type]) (out :: [Type]). (DipT a inp dinp dout out, dinp ~ (a ': dout)) => inp :-> out
class st ~ (Head st ': Tail st) => DupT a (st :: [Type]) where
- dupT :: st :-> (a ': st)
class dipInp ~ (a ': Tail dipInp) => DipT a (inp :: [Type]) (dipInp :: [Type]) (dipOut :: [Type]) (out :: [Type]) | inp a -> dipInp, dipOut inp a -> out, inp out a -> dipOut where
- dipT :: (dipInp :-> dipOut) -> inp :-> out
mkLambdaRec :: forall (i :: [Type]) (o :: [Type]). (IsNotInView => (i ++ '[WrappedLambda i o]) :-> o) -> WrappedLambda i o
mkLambda :: forall (i :: [Type]) (o :: [Type]). (IsNotInView => i :-> o) -> WrappedLambda i o
data WrappedLambda (i :: [Type]) (o :: [Type])
- = WrappedLambda (i :-> o)
- | RecLambda ((i ++ '[WrappedLambda i o]) :-> o)
type Lambda i o = WrappedLambda '[i] '[o]
castDummyG :: (Generic a, Generic b, GCanCastTo (Rep a) (Rep b)) => Proxy a -> Proxy b -> ()
allowCheckedCoerce :: forall {k1} {k2} (a :: k1) (b :: k2). Dict (CanCastTo a b, CanCastTo b a)
allowCheckedCoerceTo :: forall {k1} {k2} (b :: k1) (a :: k2). Dict (CanCastTo a b)
checkedCoercing_ :: forall a b (s :: [Type]). Coercible_ a b => ((b ': s) :-> (b ': s)) -> (a ': s) :-> (a ': s)
checkedCoerce_ :: forall a b (s :: [Type]). Castable_ a b => (a ': s) :-> (b ': s)
checkedCoerce :: (CanCastTo a b, Coercible a b) => a -> b
fromNamed :: forall (name :: Symbol) a (s :: [Type]). Label name -> ((name :! a) ': s) :-> (a ': s)
toNamed :: forall (name :: Symbol) a (s :: [Type]). Label name -> (a ': s) :-> ((name :! a) ': s)
coerceWrap :: forall a (s :: [Type]). Wrappable a => (Unwrappabled a ': s) :-> (a ': s)
unsafeCoerceWrap :: forall a (s :: [Type]). Unwrappable a => (Unwrappabled a ': s) :-> (a ': s)
coerceUnwrap :: forall a (s :: [Type]). Unwrappable a => (a ': s) :-> (Unwrappabled a ': s)
fakeCoercing :: forall (s1 :: [Type]) (s2 :: [Type]) (s1' :: [Type]) (s2' :: [Type]). (s1 :-> s2) -> s1' :-> s2'
fakeCoerce :: forall (s1 :: [Type]) (s2 :: [Type]). s1 :-> s2
gForcedCoerce_ :: forall {k} t (a :: k) (b :: k) (s :: [Type]). MichelsonCoercible (t a) (t b) => (t a ': s) :-> (t b ': s)
forcedCoerce_ :: forall a b (s :: [Type]). MichelsonCoercible a b => (a ': s) :-> (b ': s)
type MichelsonCoercible a b = ToT a ~ ToT b
class CanCastTo (a :: k) (b :: k1) where
- castDummy :: Proxy a -> Proxy b -> ()
type Castable_ a b = (MichelsonCoercible a b, CanCastTo a b)
type Coercible_ a b = (MichelsonCoercible a b, CanCastTo a b, CanCastTo b a)
newtype ParameterWrapper deriv cp = ParameterWrapper {
- unParameterWraper :: cp
}
type family Unwrappabled s
class ToT s ~ ToT (Unwrappabled s) => Unwrappable s where
- type Unwrappabled s
class Unwrappable s => Wrappable s
class ArithOpHs aop n m r where
- evalArithOpHs :: forall (s :: [Type]). (n ': (m ': s)) :-> (r ': s)
class DefArithOp (aop :: k) where
- defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp aop n m, r ~ ArithRes aop n m) => Instr (n ': (m ': s)) (r ': s)
type family UnaryArithResHs aop n
class UnaryArithOpHs aop n where
- type UnaryArithResHs aop n
- evalUnaryArithOpHs :: forall (s :: [Type]). (n ': s) :-> (UnaryArithResHs aop n ': s)
type family DefUnaryArithOpExtraConstraints (aop :: k) (n :: T)
class DefUnaryArithOp (aop :: k) where
- type DefUnaryArithOpExtraConstraints (aop :: k) (n :: T)
- defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp aop n, r ~ UnaryArithRes aop n, DefUnaryArithOpExtraConstraints aop n) => Instr (n ': s) (r ': s)
class ToIntegerArithOpHs n where
- evalToIntOpHs :: forall (s :: [Type]). (n ': s) :-> (Integer ': s)
class ToBytesArithOpHs n where
- evalToBytesOpHs :: forall bs (s :: [Type]). BytesLike bs => (n ': s) :-> (bs ': s)
expressionToScriptExpr :: Expression -> ByteString
valueToScriptExpr :: NicePackedValue t => t -> ByteString
lEncodeValue :: NiceUntypedValue a => a -> ByteString
lUnpackValue :: NiceUnpackedValue a => Packed a -> Either UnpackError a
lPackValue :: NicePackedValue a => a -> Packed a
lUnpackValueRaw :: NiceUnpackedValue a => ByteString -> Either UnpackError a
lPackValueRaw :: NicePackedValue a => a -> ByteString
openChestT :: forall a (s :: [Type]). BytesLike a => (ChestKey ': (ChestT a ': (Natural ': s))) :-> (OpenChestT a ': s)
toHashHs :: forall (alg :: HashAlgorithmKind) bs. (BytesLike bs, KnownHashAlgorithm alg) => bs -> Hash alg bs
lSign :: (MonadRandom m, BytesLike a) => SecretKey -> a -> m (TSignature a)
class (KnownValue bs, ToT bs ~ ToT ByteString) => BytesLike bs where
- toBytes :: bs -> ByteString
newtype Packed a = Packed {
- unPacked :: ByteString
}
newtype TSignature a = TSignature {
- unTSignature :: Signature
}
newtype Hash (alg :: HashAlgorithmKind) a = UnsafeHash {
- unHash :: ByteString
}
class Typeable alg => KnownHashAlgorithm (alg :: HashAlgorithmKind) where
- hashAlgorithmName :: Proxy alg -> Text
- computeHash :: ByteString -> ByteString
- toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash alg bs ': s)
data DHashAlgorithm
data Sha256 (a :: HashAlgoTag)
data Sha512 (a :: HashAlgoTag)
data Blake2b (a :: HashAlgoTag)
data Sha3 (a :: HashAlgoTag)
data Keccak (a :: HashAlgoTag)
newtype ChestT a = ChestT {
- unChestT :: Chest
}
data OpenChestT a
- = ChestContentT a
- | ChestOpenFailedT Bool
mkDEntrypointExample :: NiceParameter a => a -> DEntrypointExample
cutLorentzNonDoc :: forall (inp :: [Type]) (out :: [Type]) (s :: [Type]). (inp :-> out) -> s :-> s
data DEntrypointExample = ParameterScope t => DEntrypointExample (Value t)
data DView = DView {
- dvName :: ViewName
- dvSub :: SubDoc
}
data DViewArg = (NiceViewable a, TypeHasDoc a) => DViewArg (Proxy a)
data DViewRet = (NiceViewable a, TypeHasDoc a) => DViewRet (Proxy a)
class (Typeable vd, RenderViewsImpl (RevealViews vd)) => ViewsDescriptorHasDoc vd where
- viewsDescriptorName :: Proxy vd -> Text
- renderViewsDescriptorDoc :: Proxy vd -> Builder
data DViewDesc = ViewsDescriptorHasDoc vd => DViewDesc (Proxy vd)
data EpdPlain
data EpdRecursive
data EpdDelegate
data EpdWithRoot (r :: Symbol) (epd :: k)
type family MemOpKeyHs c
class (MemOp (ToT c), ToT (MemOpKeyHs c) ~ MemOpKey (ToT c)) => MemOpHs c where
- type MemOpKeyHs c
type family IsoMapOpRes c b where ...
type family MapOpResHs c :: Type -> Type
type family MapOpInpHs c
class (MapOp (ToT c), ToT (MapOpInpHs c) ~ MapOpInp (ToT c), ToT (MapOpResHs c ()) ~ MapOpRes (ToT c) (ToT ())) => MapOpHs c where
- type MapOpInpHs c
- type MapOpResHs c :: Type -> Type
type family IterOpElHs c
class (IterOp (ToT c), ToT (IterOpElHs c) ~ IterOpEl (ToT c)) => IterOpHs c where
- type IterOpElHs c
class SizeOp (ToT c) => SizeOpHs c
type family UpdOpParamsHs c
type family UpdOpKeyHs c
class (UpdOp (ToT c), ToT (UpdOpKeyHs c) ~ UpdOpKey (ToT c), ToT (UpdOpParamsHs c) ~ UpdOpParams (ToT c)) => UpdOpHs c where
- type UpdOpKeyHs c
- type UpdOpParamsHs c
type family GetOpValHs c
type family GetOpKeyHs c
class (GetOp (ToT c), ToT (GetOpKeyHs c) ~ GetOpKey (ToT c), ToT (GetOpValHs c) ~ GetOpVal (ToT c)) => GetOpHs c where
- type GetOpKeyHs c
- type GetOpValHs c
class ConcatOp (ToT c) => ConcatOpHs c
class SliceOp (ToT c) => SliceOpHs c
newtype PrintAsValue a = PrintAsValue a
data OpenChest
type List = []
data Never
data ReadTicket a = ReadTicket {
- rtTicketer :: Address
- rtData :: a
- rtAmount :: Natural
}
convertContractRef :: forall cp contract2 contract1. (ToContractRef cp contract1, FromContractRef cp contract2) => contract1 -> contract2
callingDefAddress :: (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> ContractRef (GetDefaultEntrypointArg cp)
callingAddress :: forall cp vd addr (mname :: Maybe Symbol). (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> EntrypointRef mname -> ContractRef (GetEntrypointArgCustom cp mname)
newtype TAddress p vd = TAddress {
- unTAddress :: Address
}
newtype FutureContract arg = FutureContract {
- unFutureContract :: ContractRef arg
}
class ToAddress a where
- toAddress :: a -> Address
class ToTAddress cp vd a where
- toTAddress :: a -> TAddress cp vd
class ToContractRef cp contract where
- toContractRef :: contract -> ContractRef cp
class FromContractRef cp contract where
- fromContractRef :: ContractRef cp -> contract
type Entrypoint param store = '[param, store] :-> ContractOut store
type Entrypoint_ store = '[store] :-> ContractOut store
stackType :: forall (s :: [Type]). s :-> s
testAssert :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => Text -> PrintComment (ToTs inp) -> (inp :-> (Bool ': out)) -> inp :-> inp
printComment :: forall (s :: [Type]). PrintComment (ToTs s) -> s :-> s
stackRef :: forall (gn :: Nat) (st :: [T]) (n :: Peano). (n ~ ToPeano gn, SingI n, RequireLongerThan st n) => PrintComment st
optimizeLorentz :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> inp :-> out
optimizeLorentzWithConf :: forall (inp :: [Type]) (out :: [Type]). OptimizerConf -> (inp :-> out) -> inp :-> out
transformBytesLorentz :: forall (inp :: [Type]) (out :: [Type]). Bool -> (ByteString -> ByteString) -> (inp :-> out) -> inp :-> out
transformStringsLorentz :: forall (inp :: [Type]) (out :: [Type]). Bool -> (MText -> MText) -> (inp :-> out) -> inp :-> out
parseLorentzValue :: KnownValue v => MichelsonSource -> Text -> Either ParseLorentzError v
toMichelsonContract :: Contract cp st vd -> Contract (ToT cp) (ToT st)
mkContractCode :: (IsNotInView => '[(cp, st)] :-> ContractOut st) -> ContractCode cp st
iForceNotFail :: forall (i :: [Type]) (o :: [Type]). (i :-> o) -> i :-> o
iMapAnyCode :: forall (i1 :: [Type]) (i2 :: [Type]) (o :: [Type]). (forall (o' :: [T]). Instr (ToTs i1) o' -> Instr (ToTs i2) o') -> (i1 :-> o) -> i2 :-> o
iNonFailingCode :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => (inp :-> out) -> Instr (ToTs inp) (ToTs out)
iAnyCode :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> Instr (ToTs inp) (ToTs out)
iGenericIf :: forall (a :: [Type]) (b :: [Type]) (c :: [Type]) (s :: [Type]). (forall (s' :: [T]). Instr (ToTs a) s' -> Instr (ToTs b) s' -> Instr (ToTs c) s') -> (a :-> s) -> (b :-> s) -> c :-> s
pattern I :: Instr (ToTs inp) (ToTs out) -> inp :-> out
pattern FI :: (forall (out' :: [T]). Instr (ToTs inp) out') -> inp :-> out
newtype (inp :: [Type]) :-> (out :: [Type]) = LorentzInstr {
- unLorentzInstr :: RemFail Instr (ToTs inp) (ToTs out)
}
type (%>) = (:->)
type ContractOut st = '[([Operation], st)]
newtype ContractCode cp st = ContractCode {
- unContractCode :: '[(cp, st)] :-> ContractOut st
}
data SomeContractCode where
- SomeContractCode :: forall cp st. (NiceParameter cp, NiceStorage st) => ContractCode cp st -> SomeContractCode
type ViewCode arg st ret = '[(arg, st)] :-> '[ret]
cMichelsonContract :: Contract cp st vd -> Contract (ToT cp) (ToT st)
cDocumentedCode :: Contract cp st vd -> ContractCode cp st
type (&) a (b :: [Type]) = a ': b
type Fn a b = '[a] :-> '[b]
class MapLorentzInstr instr where
- mapLorentzInstr :: (forall (i :: [Type]) (o :: [Type]). (i :-> o) -> i :-> o) -> instr -> instr
decideOnDupable :: KnownValue a => DupableDecision a
type NiceParameterFull cp = (Typeable cp, ParameterDeclaresEntrypoints cp)
data DupableDecision a
- = Dupable a => IsDupable
- | IsNotDupable
type NiceViews (vs :: [ViewTyInfo]) = RequireAllUnique "view" (ViewsNames vs)
type NiceViewsDescriptor vd = NiceViews (RevealViews vd)
parameterEntrypointCallCustom :: forall cp (mname :: Maybe Symbol). ParameterDeclaresEntrypoints cp => EntrypointRef mname -> EntrypointCall cp (GetEntrypointArgCustom cp mname)
eprName :: forall (mname :: Maybe Symbol). EntrypointRef mname -> EpName
sepcCallRootChecked :: (NiceParameter cp, ForbidExplicitDefaultEntrypoint cp) => SomeEntrypointCall cp
parameterEntrypointCallDefault :: ParameterDeclaresEntrypoints cp => EntrypointCall cp (GetDefaultEntrypointArg cp)
parameterEntrypointCall :: forall cp (name :: Symbol). ParameterDeclaresEntrypoints cp => Label name -> EntrypointCall cp (GetEntrypointArg cp name)
parameterEntrypointsToNotes :: ParameterDeclaresEntrypoints cp => ParamNotes (ToT cp)
type family EpdLookupEntrypoint (deriv :: k) cp :: Symbol -> Exp (Maybe Type)
type family EpdAllEntrypoints (deriv :: k) cp :: [(Symbol, Type)]
class EntrypointsDerivation (deriv :: k) cp where
- type EpdAllEntrypoints (deriv :: k) cp :: [(Symbol, Type)]
- type EpdLookupEntrypoint (deriv :: k) cp :: Symbol -> Exp (Maybe Type)
- epdNotes :: (Notes (ToT cp), RootAnn)
- epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint deriv cp name))
- epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints deriv cp)
type RequireAllUniqueEntrypoints cp = RequireAllUniqueEntrypoints' (ParameterEntrypointsDerivation cp) cp
type family ParameterEntrypointsDerivation cp
class (EntrypointsDerivation (ParameterEntrypointsDerivation cp) cp, RequireAllUniqueEntrypoints cp) => ParameterHasEntrypoints cp where
- type ParameterEntrypointsDerivation cp
type ParameterDeclaresEntrypoints cp = (If (CanHaveEntrypoints cp) (ParameterHasEntrypoints cp) (), NiceParameter cp, EntrypointsDerivation (GetParameterEpDerivation cp) cp)
type family AllParameterEntrypoints cp :: [(Symbol, Type)] where ...
type family LookupParameterEntrypoint cp :: Symbol -> Exp (Maybe Type) where ...
type GetEntrypointArg cp (name :: Symbol) = Eval (LiftM2 (FromMaybe :: Type -> Maybe Type -> Type -> Type) (TError (('Text "Entrypoint not found: " :<>: 'ShowType name) :$$: (('Text "In contract parameter `" :<>: 'ShowType cp) :<>: 'Text "`")) :: Type -> Type) (LookupParameterEntrypoint cp name))
type GetDefaultEntrypointArg cp = Eval (LiftM2 (FromMaybe :: Type -> Maybe Type -> Type -> Type) (Pure cp) (LookupParameterEntrypoint cp DefaultEpName))
type ForbidExplicitDefaultEntrypoint cp = Eval (LiftM3 (UnMaybe :: Exp Constraint -> (Type -> Exp Constraint) -> Maybe Type -> Constraint -> Type) (Pure (Pure ())) (TError ('Text "Parameter used here must have no explicit \"default\" entrypoint" :$$: (('Text "In parameter type `" :<>: 'ShowType cp) :<>: 'Text "`")) :: (Type -> Exp Constraint) -> Type) (LookupParameterEntrypoint cp DefaultEpName))
type NoExplicitDefaultEntrypoint cp = Eval (LookupParameterEntrypoint cp DefaultEpName) ~ ('Nothing :: Maybe Type)
data EntrypointRef (mname :: Maybe Symbol) where
- CallDefault :: EntrypointRef ('Nothing :: Maybe Symbol)
- Call :: forall (name :: Symbol). NiceEntrypointName name => EntrypointRef ('Just name)
type family GetEntrypointArgCustom cp (mname :: Maybe Symbol) where ...
class HasEntrypointArg (cp :: k) name arg where
- useHasEntrypointArg :: name -> (Dict (ParameterScope (ToT arg)), EpName)
type HasDefEntrypointArg (cp :: k) defEpName defArg = (defEpName ~ EntrypointRef ('Nothing :: Maybe Symbol), HasEntrypointArg cp defEpName defArg)
newtype TrustEpName = TrustEpName EpName
type HasEntrypointOfType param (con :: Symbol) exp = (GetEntrypointArgCustom param ('Just con) ~ exp, ParameterDeclaresEntrypoints param)
type (:>) (n :: Symbol) ty = 'NamedEp n ty
type family ParameterContainsEntrypoints param (fields :: [NamedEp]) where ...
data EpdNone
newtype ShouldHaveEntrypoints a = ShouldHaveEntrypoints {
- unHasEntrypoints :: a
}
class (IsoValue a, Typeable a) => KnownValue a
class (ForbidOp (ToT a), IsoValue a) => NoOperation a
class (ForbidContract (ToT a), IsoValue a) => NoContractType a
class (ForbidBigMap (ToT a), IsoValue a) => NoBigMap a
class (HasNoNestedBigMaps (ToT a), IsoValue a) => CanHaveBigMap a
type NiceParameter a = (ProperParameterBetterErrors (ToT a), KnownValue a)
type NiceStorage a = (ProperStorageBetterErrors (ToT a), KnownValue a)
type NiceStorageFull a = (NiceStorage a, HasAnnotation a)
type NiceConstant a = (ProperConstantBetterErrors (ToT a), KnownValue a)
type Dupable a = (ProperDupableBetterErrors (ToT a), KnownValue a)
type NicePackedValue a = (ProperPackedValBetterErrors (ToT a), KnownValue a)
type NiceUnpackedValue a = (ProperUnpackedValBetterErrors (ToT a), KnownValue a)
type NiceFullPackedValue a = (NicePackedValue a, NiceUnpackedValue a)
type NiceUntypedValue a = (ProperUntypedValBetterErrors (ToT a), KnownValue a)
type NiceViewable a = (ProperViewableBetterErrors (ToT a), KnownValue a)
type NiceComparable n = (ProperNonComparableValBetterErrors (ToT n), KnownValue n, Comparable (ToT n))
type NiceNoBigMap n = (KnownValue n, HasNoBigMap (ToT n))
class HasAnnotation a
data Rec (a :: u -> Type) (b :: [u]) where
- RNil :: forall {u} (a :: u -> Type). Rec a ('[] :: [u])
- (:&) :: forall {u} (a :: u -> Type) (r :: u) (rs :: [u]). !(a r) -> !(Rec a rs) -> Rec a (r ': rs)
type ($) (f :: k1 -> k) (a :: k1) = f a
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
type (:!) (name :: Symbol) a = NamedF Identity a name
type (:?) (name :: Symbol) a = NamedF Maybe a name
data GenericStrategy
withDepths :: [CstrDepth] -> GenericStrategy
rightBalanced :: GenericStrategy
leftBalanced :: GenericStrategy
rightComb :: GenericStrategy
leftComb :: GenericStrategy
haskellBalanced :: GenericStrategy
reorderingConstrs :: EntriesReorder -> GenericStrategy -> GenericStrategy
reorderingFields :: UnnamedEntriesReorder -> EntriesReorder -> GenericStrategy -> GenericStrategy
reorderingData :: UnnamedEntriesReorder -> EntriesReorder -> GenericStrategy -> GenericStrategy
alphabetically :: EntriesReorder
leaveUnnamedFields :: UnnamedEntriesReorder
forbidUnnamedFields :: UnnamedEntriesReorder
fromDepthsStrategy :: (Int -> [Natural]) -> GenericStrategy
fromDepthsStrategy' :: (Int -> [Natural]) -> (Int -> [Natural]) -> GenericStrategy
makeRightBalDepths :: Int -> [Natural]
cstr :: forall (n :: Nat). KnownNat n => [Natural] -> CstrDepth
fld :: forall (n :: Nat). KnownNat n => Natural
customGeneric :: String -> GenericStrategy -> Q [Dec]
customGeneric' :: Maybe Type -> Name -> Type -> [Con] -> GenericStrategy -> Q [Dec]
reifyDataType :: Name -> Q (Name, Cxt, Maybe Kind, [TyVarBndr ()], [Con])
deriveFullType :: Name -> Maybe Kind -> [TyVarBndr flag] -> TypeQ
mangleGenericStrategyConstructors :: (Text -> Text) -> GenericStrategy -> GenericStrategy
mangleGenericStrategyFields :: (Text -> Text) -> GenericStrategy -> GenericStrategy
ligoLayout :: GenericStrategy
ligoCombLayout :: GenericStrategy
type Markdown = Builder
class (SingI t, WellTyped t, HasNoOp t, HasNoBigMap t, HasNoContract t, HasNoTicket t, HasNoSaplingState t) => ConstantScope (t :: T)
data Label (name :: Symbol) where
- Label :: forall (name :: Symbol). KnownSymbol name => Label name
data Chest
data ChestKey
data EpName
pattern DefEpName :: EpName
data Bls12381Fr
data Bls12381G2
data Bls12381G1
data MText
mt :: QuasiQuoter
type KeyHash = Hash 'HashKindPublicKey
data Signature
data PublicKey
data ChainId
data Timestamp
data Mutez
tz :: QuasiQuoter
toMutez :: (Integral a, CheckIntSubType a Word63) => a -> Mutez
zeroMutez :: Mutez
oneMutez :: Mutez
timestampFromSeconds :: Integer -> Timestamp
timestampFromUTCTime :: UTCTime -> Timestamp
timestampQuote :: QuasiQuoter
type Address = Constrained (NullConstraint :: AddressKind -> Constraint) KindedAddress
mkUType :: forall (x :: T). Notes x -> Ty
data EpAddress where
- EpAddress' {
  - eaAddress :: Address
  - eaEntrypoint :: EpName
  }
- pattern EpAddress :: forall (kind :: AddressKind). () => KindedAddress kind -> EpName -> EpAddress
class IsNotInView
data ContractDoc = ContractDoc {
- cdContents :: DocBlock
- cdDefinitions :: DocBlock
- cdDefinitionsSet :: Set SomeDocDefinitionItem
- cdDefinitionIds :: Set DocItemId
}
newtype SubDoc = SubDoc DocBlock
data DocSection = DocItem d => DocSection (NonEmpty $ DocElem d)
data DocElem d = DocElem {
- deItem :: d
- deSub :: Maybe SubDoc
}
data SomeDocDefinitionItem where
- SomeDocDefinitionItem :: forall d. (DocItem d, DocItemPlacement d ~ 'DocItemInDefinitions) => d -> SomeDocDefinitionItem
data SomeDocItem where
- SomeDocItem :: forall d. DocItem d => d -> SomeDocItem
data DocSectionNameStyle
- = DocSectionNameBig
- | DocSectionNameSmall
data DocItemRef (p :: DocItemPlacementKind) (r :: DocItemReferencedKind) where
- DocItemRef :: DocItemId -> DocItemRef 'DocItemInDefinitions 'True
- DocItemRefInlined :: DocItemId -> DocItemRef 'DocItemInlined 'True
- DocItemNoRef :: DocItemRef 'DocItemInlined 'False
data DocItemPlacementKind
- = DocItemInlined
- | DocItemInDefinitions
newtype DocItemPos = DocItemPos (Natural, Text)
newtype DocItemId = DocItemId Text
class (Typeable d, DOrd d) => DocItem d where
- type DocItemPlacement d :: DocItemPlacementKind
- type DocItemReferenced d :: DocItemReferencedKind
- docItemPos :: Natural
- docItemSectionName :: Maybe Text
- docItemSectionDescription :: Maybe Markdown
- docItemSectionNameStyle :: DocSectionNameStyle
- docItemRef :: d -> DocItemRef (DocItemPlacement d) (DocItemReferenced d)
- docItemToMarkdown :: HeaderLevel -> d -> Markdown
- docItemToToc :: HeaderLevel -> d -> Markdown
- docItemDependencies :: d -> [SomeDocDefinitionItem]
- docItemsOrder :: [d] -> [d]
type family DocItemPlacement d :: DocItemPlacementKind
type family DocItemReferenced d :: DocItemReferencedKind
mdTocFromRef :: (DocItem d, DocItemReferenced d ~ 'True) => HeaderLevel -> Markdown -> d -> Markdown
docItemPosition :: DocItem d => DocItemPos
docDefinitionRef :: (DocItem d, DocItemPlacement d ~ 'DocItemInDefinitions) => Markdown -> d -> Markdown
docItemSectionRef :: DocItem di => Maybe Markdown
subDocToMarkdown :: HeaderLevel -> SubDoc -> Markdown
data DAnchor = DAnchor Anchor
data DComment = DComment Text
newtype GitRepoSettings = GitRepoSettings {
- grsMkGitRevision :: Text -> Text
}
data DGitRevision
- = DGitRevisionKnown DGitRevisionInfo
- | DGitRevisionUnknown
data DDescription = DDescription Markdown
data DName = DName Text SubDoc
newtype DGeneralInfoSection = DGeneralInfoSection SubDoc
data WithFinalizedDoc a
class ContainsDoc a => ContainsUpdateableDoc a where
- modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> a -> a
class ContainsDoc a where
- buildDocUnfinalized :: a -> ContractDoc
type DocGrouping = SubDoc -> SomeDocItem
contractDocToMarkdown :: ContractDoc -> LText
finalizedAsIs :: a -> WithFinalizedDoc a
buildDoc :: ContainsDoc a => WithFinalizedDoc a -> ContractDoc
buildMarkdownDoc :: ContainsDoc a => WithFinalizedDoc a -> LText
modifyDoc :: (ContainsUpdateableDoc a, DocItem i1, DocItem i2) => (i1 -> Maybe i2) -> a -> a
morleyRepoSettings :: GitRepoSettings
mkDGitRevision :: ExpQ
attachDocCommons :: ContainsUpdateableDoc a => DGitRevision -> a -> WithFinalizedDoc a
type Operation = Operation' Instr
type Value = Value' Instr
data BigMap k v
newtype BigMapId (k2 :: k) (v :: k1) = BigMapId {
- unBigMapId :: Natural
}
data Ticket arg = Ticket {
- tTicketer :: Address
- tData :: arg
- tAmount :: Natural
}
data ContractRef arg = ContractRef {
- crAddress :: Address
- crEntrypoint :: SomeEntrypointCall arg
}
type WellTypedToT a = (IsoValue a, WellTyped (ToT a))
type SomeEntrypointCall arg = SomeEntrypointCallT (ToT arg)
type EntrypointCall param arg = EntrypointCallT (ToT param) (ToT arg)
class WellTypedToT a => IsoValue a where
- type ToT a :: T
- toVal :: a -> Value (ToT a)
- fromVal :: Value (ToT a) -> a
type family ToT a :: T
coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b
type InstrConstructC dt = (GenericIsoValue dt, GInstrConstruct (Rep dt) ('[] :: [Type]))
type ConstructorFieldTypes dt = GFieldTypes (Rep dt) ('[] :: [Type])
class IsHomomorphic (a :: k)
class HaveCommonTypeCtor (a :: k) (b :: k1)
data DType where
- DType :: forall a. TypeHasDoc a => Proxy a -> DType
data SomeTypeWithDoc where
- SomeTypeWithDoc :: forall td. TypeHasDoc td => Proxy td -> SomeTypeWithDoc
class (Typeable a, SingI (TypeDocFieldDescriptions a), FieldDescriptionsValid (TypeDocFieldDescriptions a) a) => TypeHasDoc a where
- type TypeDocFieldDescriptions a :: FieldDescriptions
- typeDocName :: Proxy a -> Text
- typeDocMdDescription :: Markdown
- typeDocMdReference :: Proxy a -> WithinParens -> Markdown
- typeDocDependencies :: Proxy a -> [SomeDocDefinitionItem]
- typeDocHaskellRep :: TypeDocHaskellRep a
- typeDocMichelsonRep :: TypeDocMichelsonRep a
type family TypeDocFieldDescriptions a :: FieldDescriptions
class TypeHasFieldNamingStrategy (a :: k) where
- typeFieldNamingStrategy :: Text -> Text
typeDocBuiltMichelsonRep :: TypeHasDoc a => Proxy a -> Builder
dTypeDep :: TypeHasDoc t => SomeDocDefinitionItem
dStorage :: TypeHasDoc store => DStorageType
customTypeDocMdReference :: (Text, DType) -> [DType] -> WithinParens -> Markdown
homomorphicTypeDocMdReference :: (Typeable t, TypeHasDoc t, IsHomomorphic t) => Proxy t -> WithinParens -> Markdown
poly1TypeDocMdReference :: forall (t :: Type -> Type) r a. (r ~ t a, Typeable t, Each '[TypeHasDoc] '[r, a], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown
poly2TypeDocMdReference :: forall (t :: Type -> Type -> Type) r a b. (r ~ t a b, Typeable t, Each '[TypeHasDoc] '[r, a, b], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown
genericTypeDocDependencies :: (Generic a, GTypeHasDoc (Rep a)) => Proxy a -> [SomeDocDefinitionItem]
homomorphicTypeDocHaskellRep :: (Generic a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep a
concreteTypeDocHaskellRep :: (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a), HaveCommonTypeCtor b a) => TypeDocHaskellRep b
unsafeConcreteTypeDocHaskellRep :: (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep b
haskellRepNoFields :: TypeDocHaskellRep a -> TypeDocHaskellRep a
haskellRepStripFieldPrefix :: TypeDocHaskellRep a -> TypeDocHaskellRep a
haskellAddNewtypeField :: Text -> TypeDocHaskellRep a -> TypeDocHaskellRep a
homomorphicTypeDocMichelsonRep :: KnownIsoT a => TypeDocMichelsonRep a
concreteTypeDocMichelsonRep :: forall {k} a (b :: k). (Typeable a, KnownIsoT a, HaveCommonTypeCtor b a) => TypeDocMichelsonRep b
unsafeConcreteTypeDocMichelsonRep :: forall {k} a (b :: k). (Typeable a, KnownIsoT a) => TypeDocMichelsonRep b
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => Text -> a
asks :: MonadReader r m => (r -> a) -> m a
newtype ReaderT r (m :: Type -> Type) a = ReaderT {
- runReaderT :: r -> m a
}
type family Each (c :: [k -> Constraint]) (as :: [k]) where ...
fromIntegral :: (Integral a, Integral b, CheckIntSubType a b) => a -> b
mkBigMap :: ToBigMap m => m -> BigMap (ToBigMapKey m) (ToBigMapValue m)
annQ :: QuasiQuoter
type FieldAnn = Annotation FieldTag
unsafeM :: (MonadFail m, Buildable a) => Either a b -> m b
unsafe :: (HasCallStack, Buildable a) => Either a b -> b
show :: forall b a. (PrettyShow a, Show a, IsString b) => a -> b
type family PrettyShow a
fromIntegralNoOverflow :: (Integral a, Integral b) => a -> Either ArithException b
fromIntegralOverflowing :: (Integral a, Num b) => a -> b
fromIntegralToRealFrac :: (Integral a, RealFrac b, CheckIntSubType a Integer) => a -> b
fromIntegralMaybe :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
type CheckIntSubType a b = (CheckIntSubTypeErrors a b (IsIntSubType a b), IsIntSubType a b ~ 'True)
all1 :: Boolean b => (a -> b) -> NonEmpty a -> b
any1 :: Boolean b => (a -> b) -> NonEmpty a -> b
all :: (Container c, BooleanMonoid b) => (Element c -> b) -> c -> b
any :: (Container c, BooleanMonoid b) => (Element c -> b) -> c -> b
and1 :: Boolean a => NonEmpty a -> a
or1 :: Boolean a => NonEmpty a -> a
class Boolean a
class Boolean a => BooleanMonoid a where
- false :: a
- true :: a
newtype All a = All {
- getAll :: a
}
newtype Any a = Any {
- getAny :: a
}
newtype ApplicativeBoolean (f :: k -> Type) (bool :: k) = ApplicativeBoolean (f bool)
pass :: Applicative f => f ()
someNE :: Alternative f => f a -> f (NonEmpty a)
($!) :: (a -> b) -> a -> b
map :: Functor f => (a -> b) -> f a -> f b
(<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
newEmptyMVar :: MonadIO m => m (MVar a)
newMVar :: MonadIO m => a -> m (MVar a)
putMVar :: MonadIO m => MVar a -> a -> m ()
readMVar :: MonadIO m => MVar a -> m a
swapMVar :: MonadIO m => MVar a -> a -> m a
takeMVar :: MonadIO m => MVar a -> m a
tryPutMVar :: MonadIO m => MVar a -> a -> m Bool
tryReadMVar :: MonadIO m => MVar a -> m (Maybe a)
tryTakeMVar :: MonadIO m => MVar a -> m (Maybe a)
atomically :: MonadIO m => STM a -> m a
newTVarIO :: MonadIO m => a -> m (TVar a)
readTVarIO :: MonadIO m => TVar a -> m a
updateMVar' :: MonadIO m => MVar s -> StateT s IO a -> m a
updateTVar' :: TVar s -> StateT s STM a -> STM a
exitWith :: MonadIO m => ExitCode -> m a
exitFailure :: MonadIO m => m a
exitSuccess :: MonadIO m => m a
die :: MonadIO m => String -> m a
appendFile :: MonadIO m => FilePath -> Text -> m ()
getLine :: MonadIO m => m Text
openFile :: MonadIO m => FilePath -> IOMode -> m Handle
hClose :: MonadIO m => Handle -> m ()
withFile :: (MonadIO m, MonadMask m) => FilePath -> IOMode -> (Handle -> m a) -> m a
newIORef :: MonadIO m => a -> m (IORef a)
readIORef :: MonadIO m => IORef a -> m a
writeIORef :: MonadIO m => IORef a -> a -> m ()
modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m ()
modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m ()
atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
atomicWriteIORef :: MonadIO m => IORef a -> a -> m ()
whenJust :: Applicative f => Maybe a -> (a -> f ()) -> f ()
whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
whenNothing :: Applicative f => Maybe a -> f a -> f a
whenNothing_ :: Applicative f => Maybe a -> f () -> f ()
whenNothingM :: Monad m => m (Maybe a) -> m a -> m a
whenNothingM_ :: Monad m => m (Maybe a) -> m () -> m ()
fromLeft :: a -> Either a b -> a
fromRight :: b -> Either a b -> b
leftToMaybe :: Either l r -> Maybe l
rightToMaybe :: Either l r -> Maybe r
maybeToRight :: l -> Maybe r -> Either l r
maybeToLeft :: r -> Maybe l -> Either l r
whenLeftM :: Monad m => m (Either l r) -> (l -> m ()) -> m ()
whenRightM :: Monad m => m (Either l r) -> (r -> m ()) -> m ()
usingReaderT :: r -> ReaderT r m a -> m a
usingReader :: r -> Reader r a -> a
usingStateT :: s -> StateT s m a -> m (a, s)
usingState :: s -> State s a -> (a, s)
evaluatingStateT :: Functor f => s -> StateT s f a -> f a
evaluatingState :: s -> State s a -> a
executingStateT :: Functor f => s -> StateT s f a -> f s
executingState :: s -> State s a -> s
hoistMaybe :: forall (m :: Type -> Type) a. Applicative m => Maybe a -> MaybeT m a
hoistEither :: forall (m :: Type -> Type) e a. Applicative m => Either e a -> ExceptT e m a
maybeToMonoid :: Monoid m => Maybe m -> m
class One x where
- type OneItem x
- one :: OneItem x -> x
type family OneItem x
class Container t where
- type Element t
- toList :: t -> [Element t]
- null :: t -> Bool
- foldr :: (Element t -> b -> b) -> b -> t -> b
- foldl :: (b -> Element t -> b) -> b -> t -> b
- foldl' :: (b -> Element t -> b) -> b -> t -> b
- length :: t -> Int
- elem :: Element t -> t -> Bool
- foldMap :: Monoid m => (Element t -> m) -> t -> m
- fold :: t -> Element t
- foldr' :: (Element t -> b -> b) -> b -> t -> b
- notElem :: Element t -> t -> Bool
- find :: (Element t -> Bool) -> t -> Maybe (Element t)
- safeHead :: t -> Maybe (Element t)
- safeMaximum :: t -> Maybe (Element t)
- safeMinimum :: t -> Maybe (Element t)
- safeFoldr1 :: (Element t -> Element t -> Element t) -> t -> Maybe (Element t)
- safeFoldl1 :: (Element t -> Element t -> Element t) -> t -> Maybe (Element t)
type family Element t
class FromList l where
- type ListElement l
- type FromListC l
- fromList :: [ListElement l] -> l
type family ListElement l
type family FromListC l
class ToPairs t where
- toPairs :: t -> [(Key t, Val t)]
- keys :: t -> [Key t]
- elems :: t -> [Val t]
flipfoldl' :: (Container t, Element t ~ a) => (a -> b -> b) -> b -> t -> b
sum :: (Container t, Num (Element t)) => t -> Element t
product :: (Container t, Num (Element t)) => t -> Element t
traverse_ :: (Container t, Applicative f) => (Element t -> f b) -> t -> f ()
for_ :: (Container t, Applicative f) => t -> (Element t -> f b) -> f ()
mapM_ :: (Container t, Monad m) => (Element t -> m b) -> t -> m ()
forM_ :: (Container t, Monad m) => t -> (Element t -> m b) -> m ()
sequenceA_ :: (Container t, Applicative f, Element t ~ f a) => t -> f ()
sequence_ :: (Container t, Monad m, Element t ~ m a) => t -> m ()
asum :: (Container t, Alternative f, Element t ~ f a) => t -> f a
concatMapM :: (Applicative f, Monoid m, Container (l m), Element (l m) ~ m, Traversable l) => (a -> f m) -> l a -> f m
concatForM :: (Applicative f, Monoid m, Container (l m), Element (l m) ~ m, Traversable l) => l a -> (a -> f m) -> f m
andM :: (Container f, Element f ~ m Bool, Monad m) => f -> m Bool
orM :: (Container f, Element f ~ m Bool, Monad m) => f -> m Bool
allM :: (Container f, Monad m) => (Element f -> m Bool) -> f -> m Bool
anyM :: (Container f, Monad m) => (Element f -> m Bool) -> f -> m Bool
uncons :: [a] -> Maybe (a, [a])
whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f ()
whenNotNullM :: Monad m => m [a] -> (NonEmpty a -> m ()) -> m ()
foldl1 :: (a -> a -> a) -> NonEmpty a -> a
foldr1 :: (a -> a -> a) -> NonEmpty a -> a
minimumBy :: (a -> a -> Ordering) -> NonEmpty a -> a
minimum :: Ord a => NonEmpty a -> a
maximumBy :: (a -> a -> Ordering) -> NonEmpty a -> a
maximum :: Ord a => NonEmpty a -> a
data Bug = Bug SomeException CallStack
pattern Exc :: Exception e => e -> SomeException
bug :: (HasCallStack, Exception e) => e -> a
note :: MonadError e m => e -> Maybe a -> m a
evaluateWHNF :: MonadIO m => a -> m a
evaluateWHNF_ :: MonadIO m => a -> m ()
evaluateNF :: (NFData a, MonadIO m) => a -> m a
evaluateNF_ :: (NFData a, MonadIO m) => a -> m ()
whenM :: Monad m => m Bool -> m () -> m ()
unlessM :: Monad m => m Bool -> m () -> m ()
ifM :: Monad m => m Bool -> m a -> m a -> m a
guardM :: MonadPlus m => m Bool -> m ()
ordNub :: Ord a => [a] -> [a]
hashNub :: (Eq a, Hashable a) => [a] -> [a]
sortNub :: Ord a => [a] -> [a]
unstableNub :: (Eq a, Hashable a) => [a] -> [a]
class Print a
hPutStr :: (Print a, MonadIO m) => Handle -> a -> m ()
hPutStrLn :: (Print a, MonadIO m) => Handle -> a -> m ()
putStr :: (Print a, MonadIO m) => a -> m ()
putStrLn :: (Print a, MonadIO m) => a -> m ()
print :: forall a m. (MonadIO m, Show a) => a -> m ()
hPrint :: (MonadIO m, Show a) => Handle -> a -> m ()
putText :: MonadIO m => Text -> m ()
putTextLn :: MonadIO m => Text -> m ()
putLText :: MonadIO m => Text -> m ()
putLTextLn :: MonadIO m => Text -> m ()
data Undefined = Undefined
trace :: Text -> a -> a
traceShow :: Show a => a -> b -> b
traceShowId :: Show a => a -> a
traceIdWith :: (a -> Text) -> a -> a
traceShowIdWith :: Show s => (a -> s) -> a -> a
traceShowM :: (Show a, Monad m) => a -> m ()
traceM :: Monad m => Text -> m ()
traceId :: Text -> Text
class ToString a where
- toString :: a -> String
class ToLText a where
- toLText :: a -> Text
class ToText a where
- toText :: a -> Text
class ConvertUtf8 a b where
- encodeUtf8 :: a -> b
- decodeUtf8 :: b -> a
- decodeUtf8Strict :: b -> Either UnicodeException a
type LByteString = ByteString
type LText = Text
readEither :: (ToString a, Read b) => a -> Either Text b
type With (a :: [k -> Constraint]) (b :: k) = a <+> b
class SuperComposition a b c | a b -> c where
- (...) :: a -> b -> c
exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a
maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a
lenientDecode :: OnDecodeError
strictDecode :: OnDecodeError
type OnDecodeError = OnError Word8 Char
type OnError a b = String -> Maybe a -> Maybe b
data UnicodeException
decodeUtf8' :: ByteString -> Either UnicodeException Text
decodeUtf8With :: OnDecodeError -> ByteString -> Text
lines :: Text -> [Text]
unlines :: [Text] -> Text
unwords :: [Text] -> Text
words :: Text -> [Text]
fromStrict :: Text -> Text
modifyTVar' :: TVar a -> (a -> a) -> STM ()
throwM :: (MonadThrow m, Exception e) => e -> m a
catch :: (MonadCatch m, Exception e) => m a -> (e -> m a) -> m a
catchAny :: MonadCatch m => m a -> (SomeException -> m a) -> m a
handleAny :: MonadCatch m => (SomeException -> m a) -> m a -> m a
try :: (MonadCatch m, Exception e) => m a -> m (Either e a)
tryAny :: MonadCatch m => m a -> m (Either SomeException a)
onException :: MonadMask m => m a -> m b -> m a
bracket :: MonadMask m => m a -> (a -> m b) -> (a -> m c) -> m c
bracket_ :: MonadMask m => m a -> m b -> m c -> m c
finally :: MonadMask m => m a -> m b -> m a
bracketOnError :: MonadMask m => m a -> (a -> m b) -> (a -> m c) -> m c
withState :: (s -> s) -> State s a -> State s a
runState :: State s a -> s -> (a, s)
execStateT :: Monad m => StateT s m a -> s -> m s
execState :: State s a -> s -> s
evalStateT :: Monad m => StateT s m a -> s -> m a
evalState :: State s a -> s -> a
runReader :: Reader r a -> r -> a
modify' :: MonadState s m => (s -> s) -> m ()
(#) :: (a :-> b) -> (b :-> c) -> a :-> c
type HasStorage st = (Given (Var st), KnownValue st)
type HasSideEffects = Given (Var Ops)
type Ops = [Operation]
data Var a = Var RefId
data StackVars (stk :: [Type]) where
- StkElements :: Rec StkEl stk -> StackVars stk
- FailureStack :: StackVars stk
type StackVars' stk = Rec StkEl stk
data StkEl a where
- NoRef :: (KnownValue a, KnownIsoT a) => StkEl a
- Ref :: (KnownValue a, KnownIsoT a) => RefId -> StkEl a
data RefId
emptyStack :: StackVars '[]
assignVarAt :: (KnownValue a, a ~ At n inp, RequireLongerThan inp n) => Var a -> StackVars inp -> Sing n -> StackVars inp
pushRef :: KnownValue a => Var a -> StackVars inp -> StackVars (a ': inp)
pushNoRef :: KnownValue a => StackVars inp -> StackVars (a ': inp)
popNoRef :: StackVars (a ': inp) -> StackVars inp
operationsVar :: HasSideEffects => Var Ops
storageVar :: HasStorage st => Var st
type ComplexObjectC a = (ToDeconstructC a, ToConstructC a, AllConstrained IsObject (FieldTypes a), RecordToList (FieldTypes a))
type FieldTypes a = MapGFT a (ConstructorFieldNames a)
class IsObject' (TypeDecision a) a => IsObject a
data TypedFieldObj a where
- TypedFieldObj :: IsObject a => Object a -> TypedFieldObj a
data SomeObject where
- SomeObject :: IsObject a => Object a -> SomeObject
type Object a = IndigoObjectF (NamedFieldObj a) a
data NamedFieldObj a name where
- NamedFieldObj :: IsObject (GetFieldType a name) => {..} -> NamedFieldObj a name
data IndigoObjectF f a where
- Cell :: KnownValue a => RefId -> IndigoObjectF f a
- Decomposed :: ComplexObjectC a => Rec f (ConstructorFieldNames a) -> IndigoObjectF f a
namedToTypedRec :: forall a f g. (forall name. f name -> g (GetFieldType a name)) -> Rec f (ConstructorFieldNames a) -> Rec g (FieldTypes a)
typedToNamedRec :: forall a f g. KnownList (ConstructorFieldNames a) => (forall name. f (GetFieldType a name) -> g name) -> Rec f (FieldTypes a) -> Rec g (ConstructorFieldNames a)
castFieldConstructors :: forall a st. CastFieldConstructors (FieldTypes a) (ConstructorFieldTypes a) => Rec (FieldConstructor st) (FieldTypes a) -> Rec (FieldConstructor st) (ConstructorFieldTypes a)
namedToTypedFieldObj :: forall a name. NamedFieldObj a name -> TypedFieldObj (GetFieldType a name)
typedToNamedFieldObj :: forall a name. TypedFieldObj (GetFieldType a name) -> NamedFieldObj a name
withInstrDeconstructC :: forall a st r. InstrDeconstructCGeneral a => (InstrDeconstructCClass a st => r) -> r
complexObjectDict :: forall a. IsObject a => Maybe (Dict (ComplexObjectC a))
data GenCode inp out = GenCode {
- gcStack :: ~(StackVars out)
- gcCode :: inp :-> out
- gcClear :: out :-> inp
}
data GenCodeHooks = GenCodeHooks {
- gchStmtHook :: forall inp out. Text -> (inp :-> out) -> inp :-> out
- gchAuxiliaryHook :: forall inp out. Text -> (inp :-> out) -> inp :-> out
- gchExprHook :: forall inp out. Text -> (inp :-> out) -> inp :-> out
}
data MetaData inp = MetaData {
- mdStack :: StackVars inp
- mdObjects :: DecomposedObjects
- mdHooks :: GenCodeHooks
}
type DecomposedObjects = Map RefId SomeObject
newtype IndigoState inp out = IndigoState {
- runIndigoState :: MetaData inp -> GenCode inp out
}
usingIndigoState :: MetaData inp -> IndigoState inp out -> GenCode inp out
iput :: GenCode inp out -> IndigoState inp out
nopState :: IndigoState inp inp
assignTopVar :: KnownValue x => Var x -> IndigoState (x ': inp) (x ': inp)
withObject :: forall a r. KnownValue a => DecomposedObjects -> Var a -> (Object a -> r) -> r
withObjectState :: forall a inp out. KnownValue a => Var a -> (Object a -> IndigoState inp out) -> IndigoState inp out
withStackVars :: (StackVars inp -> IndigoState inp out) -> IndigoState inp out
emptyGenCodeHooks :: GenCodeHooks
stmtHook :: forall inp out any. MetaData any -> Text -> (inp :-> out) -> inp :-> out
stmtHookState :: Text -> IndigoState inp out -> IndigoState inp out
auxiliaryHook :: forall inp out any. MetaData any -> Text -> (inp :-> out) -> inp :-> out
auxiliaryHookState :: Text -> IndigoState inp out -> IndigoState inp out
exprHook :: forall inp out any. MetaData any -> Text -> (inp :-> out) -> inp :-> out
exprHookState :: Text -> IndigoState inp out -> IndigoState inp out
replStkMd :: MetaData inp -> StackVars inp1 -> MetaData inp1
alterStkMd :: MetaData inp -> (StackVars inp -> StackVars inp1) -> MetaData inp1
pushRefMd :: KnownValue a => Var a -> MetaData inp -> MetaData (a ': inp)
pushNoRefMd :: KnownValue a => MetaData inp -> MetaData (a ': inp)
popNoRefMd :: MetaData (a ': inp) -> MetaData inp
cleanGenCode :: GenCode inp out -> inp :-> inp
(##) :: (a :-> b) -> (b :-> c) -> a :-> c
newtype SomeIndigoState inp = SomeIndigoState {
- unSIS :: MetaData inp -> SomeGenCode inp
}
data SomeGenCode inp where
- SomeGenCode :: GenCode inp out -> SomeGenCode inp
runSIS :: SomeIndigoState inp -> MetaData inp -> (forall out. GenCode inp out -> r) -> r
toSIS :: IndigoState inp out -> SomeIndigoState inp
thenSIS :: SomeIndigoState inp -> (forall out. SomeIndigoState out) -> SomeIndigoState inp
overSIS :: (forall out. GenCode inp out -> SomeGenCode inp) -> SomeIndigoState inp -> SomeIndigoState inp
class (KnownValue ftype, KnownValue dt) => HasField dt fname ftype | dt fname -> ftype where
- fieldLens :: FieldLens dt fname ftype
data FieldLens dt fname ftype where
- TargetField :: (InstrGetFieldC dt fname, InstrSetFieldC dt fname, GetFieldType dt fname ~ targetFType, AccessFieldC dt fname) => Label fname -> StoreFieldOps dt targetFName targetFType -> FieldLens dt targetFName targetFType
- DeeperField :: (AccessFieldC dt fname, InstrSetFieldC dt fname, HasField (GetFieldType dt fname) targetFName targetFType) => Label fname -> StoreFieldOps dt targetFName targetFType -> FieldLens dt targetFName targetFType
type AccessFieldC a name = RElem name (ConstructorFieldNames a) (RIndex name (ConstructorFieldNames a))
fetchField :: forall a name f proxy. AccessFieldC a name => proxy name -> Rec f (ConstructorFieldNames a) -> f name
assignField :: forall a name f proxy. AccessFieldC a name => proxy name -> f name -> Rec f (ConstructorFieldNames a) -> Rec f (ConstructorFieldNames a)
flSFO :: FieldLens dt fname ftype -> StoreFieldOps dt fname ftype
fieldLensADT :: forall dt targetFName targetFType fname. (InstrGetFieldC dt fname, InstrSetFieldC dt fname, GetFieldType dt fname ~ targetFType, AccessFieldC dt fname) => Label fname -> FieldLens dt targetFName targetFType
fieldLensDeeper :: forall dt targetName targetType fname. (AccessFieldC dt fname, HasFieldOfType dt fname (GetFieldType dt fname), HasDupableGetters (GetFieldType dt fname), HasField (GetFieldType dt fname) targetName targetType) => Label fname -> FieldLens dt targetName targetType
data ObjectManipulation a where
- Object :: Expr a -> ObjectManipulation a
- ToField :: HasField dt fname ftype => ObjectManipulation dt -> Label fname -> ObjectManipulation ftype
- SetField :: HasField dt fname ftype => ObjectManipulation dt -> Label fname -> Expr ftype -> ObjectManipulation dt
data Expr a where
- C :: NiceConstant a => a -> Expr a
- V :: KnownValue a => Var a -> Expr a
- ObjMan :: ObjectManipulation a -> Expr a
- Cast :: KnownValue a => Expr a -> Expr a
- Size :: SizeOpHs c => Expr c -> Expr Natural
- Update :: (UpdOpHs c, KnownValue c) => Expr c -> Expr (UpdOpKeyHs c) -> Expr (UpdOpParamsHs c) -> Expr c
- Add :: (ArithOpHs Add n m r, KnownValue r) => Expr n -> Expr m -> Expr r
- Sub :: (ArithOpHs Sub n m r, KnownValue r) => Expr n -> Expr m -> Expr r
- Mul :: (ArithOpHs Mul n m r, KnownValue r) => Expr n -> Expr m -> Expr r
- Div :: (KnownValue ratio, ArithOpHs EDiv n m (Maybe (ratio, reminder))) => Expr n -> Expr m -> Proxy reminder -> Expr ratio
- Mod :: (KnownValue reminder, ArithOpHs EDiv n m (Maybe (ratio, reminder))) => Expr n -> Expr m -> Proxy ratio -> Expr reminder
- Abs :: (UnaryArithOpHs Abs n, KnownValue (UnaryArithResHs Abs n)) => Expr n -> Expr (UnaryArithResHs Abs n)
- Neg :: (UnaryArithOpHs Neg n, KnownValue (UnaryArithResHs Neg n)) => Expr n -> Expr (UnaryArithResHs Neg n)
- Lsl :: (ArithOpHs Lsl n m r, KnownValue r) => Expr n -> Expr m -> Expr r
- Lsr :: (ArithOpHs Lsr n m r, KnownValue r) => Expr n -> Expr m -> Expr r
- Eq' :: NiceComparable n => Expr n -> Expr n -> Expr Bool
- Neq :: NiceComparable n => Expr n -> Expr n -> Expr Bool
- Le :: NiceComparable n => Expr n -> Expr n -> Expr Bool
- Lt :: NiceComparable n => Expr n -> Expr n -> Expr Bool
- Ge :: NiceComparable n => Expr n -> Expr n -> Expr Bool
- Gt :: NiceComparable n => Expr n -> Expr n -> Expr Bool
- Or :: (ArithOpHs Or n m r, KnownValue r) => Expr n -> Expr m -> Expr r
- Xor :: (ArithOpHs Xor n m r, KnownValue r) => Expr n -> Expr m -> Expr r
- And :: (ArithOpHs And n m r, KnownValue r) => Expr n -> Expr m -> Expr r
- Not :: (UnaryArithOpHs Not n, KnownValue (UnaryArithResHs Not n)) => Expr n -> Expr (UnaryArithResHs Not n)
- Int' :: Expr Natural -> Expr Integer
- IsNat :: Expr Integer -> Expr (Maybe Natural)
- Coerce :: (Castable_ a b, KnownValue b) => Expr a -> Expr b
- ForcedCoerce :: (MichelsonCoercible a b, KnownValue b) => Expr a -> Expr b
- Fst :: KnownValue n => Expr (n, m) -> Expr n
- Snd :: KnownValue m => Expr (n, m) -> Expr m
- Pair :: KnownValue (n, m) => Expr n -> Expr m -> Expr (n, m)
- Some :: KnownValue (Maybe t) => Expr t -> Expr (Maybe t)
- None :: KnownValue t => Expr (Maybe t)
- Right' :: (KnownValue y, KnownValue (Either y x)) => Expr x -> Expr (Either y x)
- Left' :: (KnownValue x, KnownValue (Either y x)) => Expr y -> Expr (Either y x)
- Mem :: MemOpHs c => Expr (MemOpKeyHs c) -> Expr c -> Expr Bool
- StGet :: (StoreHasSubmap store name key value, KnownValue value) => Label name -> Expr key -> Expr store -> Expr (Maybe value)
- StInsertNew :: (StoreHasSubmap store name key value, KnownValue store, Dupable key, IsError err, Buildable err) => Label name -> err -> Expr key -> Expr value -> Expr store -> Expr store
- StInsert :: (StoreHasSubmap store name key value, KnownValue store) => Label name -> Expr key -> Expr value -> Expr store -> Expr store
- StMem :: (StoreHasSubmap store name key val, KnownValue val) => Label name -> Expr key -> Expr store -> Expr Bool
- StUpdate :: (StoreHasSubmap store name key val, KnownValue store) => Label name -> Expr key -> Expr (Maybe val) -> Expr store -> Expr store
- StDelete :: (StoreHasSubmap store name key val, KnownValue store, KnownValue val) => Label name -> Expr key -> Expr store -> Expr store
- Wrap :: (InstrWrapOneC dt name, KnownValue dt) => Label name -> Expr (CtorOnlyField name dt) -> Expr dt
- Unwrap :: (InstrUnwrapC dt name, KnownValue (CtorOnlyField name dt)) => Label name -> Expr dt -> Expr (CtorOnlyField name dt)
- Construct :: (InstrConstructC dt, RMap (ConstructorFieldTypes dt), RecordToList (ConstructorFieldTypes dt), KnownValue dt) => Proxy dt -> Rec Expr (ConstructorFieldTypes dt) -> Expr dt
- ConstructWithoutNamed :: ComplexObjectC dt => Proxy dt -> Rec Expr (FieldTypes dt) -> Expr dt
- Name :: KnownValue (name :! t) => Label name -> Expr t -> Expr (name :! t)
- UnName :: KnownValue t => Label name -> Expr (name :! t) -> Expr t
- EmptySet :: (NiceComparable key, KnownValue (Set key)) => Expr (Set key)
- Get :: (GetOpHs c, KnownValue (Maybe (GetOpValHs c)), KnownValue (GetOpValHs c)) => Expr (GetOpKeyHs c) -> Expr c -> Expr (Maybe (GetOpValHs c))
- EmptyMap :: (KnownValue value, NiceComparable key, KnownValue (Map key value)) => Expr (Map key value)
- EmptyBigMap :: (KnownValue value, NiceComparable key, KnownValue (BigMap key value)) => Expr (BigMap key value)
- Pack :: NicePackedValue a => Expr a -> Expr (Packed a)
- Unpack :: NiceUnpackedValue a => Expr (Packed a) -> Expr (Maybe a)
- PackRaw :: NicePackedValue a => Expr a -> Expr ByteString
- UnpackRaw :: NiceUnpackedValue a => Expr ByteString -> Expr (Maybe a)
- Cons :: KnownValue (List a) => Expr a -> Expr (List a) -> Expr (List a)
- Nil :: KnownValue a => Expr (List a)
- Concat :: (ConcatOpHs c, KnownValue c) => Expr c -> Expr c -> Expr c
- Concat' :: (ConcatOpHs c, KnownValue c) => Expr (List c) -> Expr c
- Slice :: (SliceOpHs c, KnownValue c) => Expr Natural -> Expr Natural -> Expr c -> Expr (Maybe c)
- Contract :: (NiceParameterFull p, NoExplicitDefaultEntrypoint p, IsoValue (ContractRef p), ToTAddress p vd addr, ToT addr ~ ToT Address) => Proxy vd -> Expr addr -> Expr (Maybe (ContractRef p))
- Self :: (NiceParameterFull p, NoExplicitDefaultEntrypoint p, IsoValue (ContractRef p), IsNotInView) => Expr (ContractRef p)
- SelfAddress :: Expr Address
- ContractAddress :: Expr (ContractRef p) -> Expr Address
- ContractCallingUnsafe :: (NiceParameter arg, IsoValue (ContractRef arg)) => EpName -> Expr Address -> Expr (Maybe (ContractRef arg))
- RunFutureContract :: (NiceParameter p, IsoValue (ContractRef p)) => Expr (FutureContract p) -> Expr (Maybe (ContractRef p))
- ImplicitAccount :: Expr KeyHash -> Expr (ContractRef ())
- ConvertEpAddressToContract :: (NiceParameter p, IsoValue (ContractRef p)) => Expr EpAddress -> Expr (Maybe (ContractRef p))
- MakeView :: KnownValue (View_ a r) => Expr a -> Expr (ContractRef r) -> Expr (View_ a r)
- MakeVoid :: KnownValue (Void_ a b) => Expr a -> Expr (Lambda b b) -> Expr (Void_ a b)
- CheckSignature :: BytesLike bs => Expr PublicKey -> Expr (TSignature bs) -> Expr bs -> Expr Bool
- Sha256 :: BytesLike bs => Expr bs -> Expr (Hash Sha256 bs)
- Sha512 :: BytesLike bs => Expr bs -> Expr (Hash Sha512 bs)
- Blake2b :: BytesLike bs => Expr bs -> Expr (Hash Blake2b bs)
- Sha3 :: BytesLike bs => Expr bs -> Expr (Hash Sha3 bs)
- Keccak :: BytesLike bs => Expr bs -> Expr (Hash Keccak bs)
- HashKey :: Expr PublicKey -> Expr KeyHash
- ChainId :: Expr ChainId
- Level :: Expr Natural
- Now :: Expr Timestamp
- Amount :: Expr Mutez
- Balance :: Expr Mutez
- Sender :: Expr Address
- VotingPower :: Expr KeyHash -> Expr Natural
- TotalVotingPower :: Expr Natural
- Exec :: KnownValue b => Expr a -> Expr (Lambda a b) -> Expr b
- NonZero :: (NonZero n, KnownValue (Maybe n)) => Expr n -> Expr (Maybe n)
type IsSizeExpr exN n = (exN :~> n, SizeOpHs n)
type IsMemExpr exKey exN n = (exKey :~> MemOpKeyHs n, exN :~> n, MemOpHs n)
type IsUpdExpr exKey exVal exMap map = (exKey :~> UpdOpKeyHs map, exVal :~> UpdOpParamsHs map, exMap :~> map, UpdOpHs map)
type IsGetExpr exKey exMap map = (exKey :~> GetOpKeyHs map, exMap :~> map, GetOpHs map, KnownValue (GetOpValHs map))
type IsSliceExpr exN n = (exN :~> n, SliceOpHs n)
type IsConcatListExpr exN n = (exN :~> List n, ConcatOpHs n, KnownValue n)
type IsConcatExpr exN1 exN2 n = (exN1 :~> n, exN2 :~> n, ConcatOpHs n)
type IsModExpr exN exM n m ratio reminder = (exN :~> n, exM :~> m, KnownValue reminder, ArithOpHs EDiv n m (Maybe (ratio, reminder)))
type IsDivExpr exN exM n m ratio reminder = (exN :~> n, exM :~> m, KnownValue ratio, ArithOpHs EDiv n m (Maybe (ratio, reminder)))
type IsArithExpr exN exM a n m r = (exN :~> n, exM :~> m, ArithOpHs a n m r, KnownValue r)
type IsUnaryArithExpr exN a n = (exN :~> n, UnaryArithOpHs a n, KnownValue (UnaryArithResHs a n))
class ToExpr' (Decide x) x => ToExpr x
type ExprType a = ExprType' (Decide a) a
type (:~>) op n = IsExpr op n
type IsExpr op n = (ToExpr op, ExprType op ~ n, KnownValue n)
type ObjectExpr a = IndigoObjectF (NamedFieldExpr a) a
data NamedFieldExpr a name where
- NamedFieldExpr :: {..} -> NamedFieldExpr a name
toExpr :: forall a. ToExpr a => a -> Expr (ExprType a)
remove :: (ExprRemovable c, exStruct :~> c, exKey :~> UpdOpKeyHs c) => exKey -> exStruct -> Expr c
insert :: (ExprInsertable c insParam, ex :~> c) => insParam -> ex -> Expr c
empty :: (ExprMagma c, NiceComparable (UpdOpKeyHs c), KnownValue c) => Expr c
odd :: (ParityExpr n m, ArithOpHs EDiv n m r, exN :~> n) => exN -> Expr Bool
even :: (ParityExpr n m, ArithOpHs EDiv n m r, exN :~> n) => exN -> Expr Bool
constExpr :: forall a. NiceConstant a => a -> Expr a
varExpr :: KnownValue a => Var a -> Expr a
cast :: ex :~> a => ex -> Expr a
add :: IsArithExpr exN exM Add n m r => exN -> exM -> Expr r
(+) :: IsArithExpr exN exM Add n m r => exN -> exM -> Expr r
sub :: IsArithExpr exN exM Sub n m r => exN -> exM -> Expr r
(-) :: IsArithExpr exN exM Sub n m r => exN -> exM -> Expr r
mul :: IsArithExpr exN exM Mul n m r => exN -> exM -> Expr r
(*) :: IsArithExpr exN exM Mul n m r => exN -> exM -> Expr r
div :: forall reminder exN exM n m ratio. IsDivExpr exN exM n m ratio reminder => exN -> exM -> Expr ratio
(/) :: forall reminder exN exM n m ratio. IsDivExpr exN exM n m ratio reminder => exN -> exM -> Expr ratio
mod :: forall ratio exN exM n m reminder. IsModExpr exN exM n m ratio reminder => exN -> exM -> Expr reminder
(%) :: forall ratio exN exM n m reminder. IsModExpr exN exM n m ratio reminder => exN -> exM -> Expr reminder
abs :: IsUnaryArithExpr exN Abs n => exN -> Expr (UnaryArithResHs Abs n)
neg :: IsUnaryArithExpr exN Neg n => exN -> Expr (UnaryArithResHs Neg n)
eq :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
(==) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
neq :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
(/=) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
lt :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
(<) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
gt :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
(>) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
le :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
(<=) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
ge :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
(>=) :: (NiceComparable n, c :~> n, c1 :~> n) => c -> c1 -> Expr Bool
isNat :: ex :~> Integer => ex -> Expr (Maybe Natural)
toInt :: ex :~> Natural => ex -> Expr Integer
nonZero :: (ex :~> n, NonZero n, KnownValue (Maybe n)) => ex -> Expr (Maybe n)
coerce :: forall b a ex. (Castable_ a b, KnownValue b, ex :~> a) => ex -> Expr b
forcedCoerce :: forall b a ex. (MichelsonCoercible a b, KnownValue b, ex :~> a) => ex -> Expr b
lsl :: IsArithExpr exN exM Lsl n m r => exN -> exM -> Expr r
(<<<) :: IsArithExpr exN exM Lsl n m r => exN -> exM -> Expr r
lsr :: IsArithExpr exN exM Lsr n m r => exN -> exM -> Expr r
(>>>) :: IsArithExpr exN exM Lsr n m r => exN -> exM -> Expr r
or :: IsArithExpr exN exM Or n m r => exN -> exM -> Expr r
(||) :: IsArithExpr exN exM Or n m r => exN -> exM -> Expr r
and :: IsArithExpr exN exM And n m r => exN -> exM -> Expr r
(&&) :: IsArithExpr exN exM And n m r => exN -> exM -> Expr r
xor :: IsArithExpr exN exM Xor n m r => exN -> exM -> Expr r
(^) :: IsArithExpr exN exM Xor n m r => exN -> exM -> Expr r
not :: IsUnaryArithExpr exN Not n => exN -> Expr (UnaryArithResHs Not n)
pack :: (ex :~> a, NicePackedValue a) => ex -> Expr (Packed a)
unpack :: (NiceUnpackedValue a, exb :~> Packed a) => exb -> Expr (Maybe a)
packRaw :: (ex :~> a, NicePackedValue a) => ex -> Expr ByteString
unpackRaw :: (NiceUnpackedValue a, exb :~> ByteString) => exb -> Expr (Maybe a)
pair :: (ex1 :~> n, ex2 :~> m, KnownValue (n, m)) => ex1 -> ex2 -> Expr (n, m)
car :: (op :~> (n, m), KnownValue n) => op -> Expr n
fst :: (op :~> (n, m), KnownValue n) => op -> Expr n
cdr :: (op :~> (n, m), KnownValue m) => op -> Expr m
snd :: (op :~> (n, m), KnownValue m) => op -> Expr m
some :: (ex :~> t, KnownValue (Maybe t)) => ex -> Expr (Maybe t)
none :: KnownValue t => Expr (Maybe t)
right :: (ex :~> x, KnownValue y, KnownValue (Either y x)) => ex -> Expr (Either y x)
left :: (ex :~> y, KnownValue x, KnownValue (Either y x)) => ex -> Expr (Either y x)
slice :: (an :~> Natural, bn :~> Natural, IsSliceExpr ex c) => (an, bn) -> ex -> Expr (Maybe c)
concat :: IsConcatExpr exN1 exN2 n => exN1 -> exN2 -> Expr n
(<>) :: IsConcatExpr exN1 exN2 n => exN1 -> exN2 -> Expr n
cons :: (ex1 :~> a, ex2 :~> List a) => ex1 -> ex2 -> Expr (List a)
(.:) :: (ex1 :~> a, ex2 :~> List a) => ex1 -> ex2 -> Expr (List a)
concatAll :: IsConcatListExpr exN n => exN -> Expr n
nil :: KnownValue a => Expr (List a)
get :: IsGetExpr exKey exMap map => exKey -> exMap -> Expr (Maybe (GetOpValHs map))
update :: IsUpdExpr exKey exVal exMap map => (exKey, exVal) -> exMap -> Expr map
mem :: IsMemExpr exKey exN n => exKey -> exN -> Expr Bool
size :: IsSizeExpr exN n => exN -> Expr Natural
(#:) :: IsGetExpr exKey exMap map => exMap -> exKey -> Expr (Maybe (GetOpValHs map))
(!:) :: IsUpdExpr exKey exVal exMap map => exMap -> (exKey, exVal) -> Expr map
(+:) :: (ExprInsertable c exParam, exStructure :~> c) => exStructure -> exParam -> Expr c
(-:) :: (ExprRemovable c, exStruct :~> c, exKey :~> UpdOpKeyHs c) => exStruct -> exKey -> Expr c
(?:) :: IsMemExpr exKey exN n => exN -> exKey -> Expr Bool
emptyBigMap :: (KnownValue value, NiceComparable key, KnownValue (BigMap key value)) => Expr (BigMap key value)
emptyMap :: (KnownValue value, NiceComparable key, KnownValue (Map key value)) => Expr (Map key value)
emptySet :: (NiceComparable key, KnownValue (Set key)) => Expr (Set key)
stGet :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr (Maybe value)
(#@) :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr (Maybe value)
stUpdate :: (StoreHasSubmap store name key value, exKey :~> key, exVal :~> Maybe value, exStore :~> store) => exStore -> (Label name, exKey, exVal) -> Expr store
(!@) :: (StoreHasSubmap store name key value, exKey :~> key, exVal :~> Maybe value, exStore :~> store) => exStore -> (Label name, exKey, exVal) -> Expr store
stInsert :: (StoreHasSubmap store name key value, exKey :~> key, exVal :~> value, exStore :~> store) => exStore -> (Label name, exKey, exVal) -> Expr store
(+@) :: (StoreHasSubmap store name key value, exKey :~> key, exVal :~> value, exStore :~> store) => exStore -> (Label name, exKey, exVal) -> Expr store
stInsertNew :: (StoreHasSubmap store name key value, Dupable key, IsError err, Buildable err, exKey :~> key, exVal :~> value, exStore :~> store) => exStore -> (Label name, err, exKey, exVal) -> Expr store
(++@) :: (StoreHasSubmap store name key value, Dupable key, IsError err, Buildable err, exKey :~> key, exVal :~> value, exStore :~> store) => exStore -> (Label name, err, exKey, exVal) -> Expr store
stDelete :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr store
(-@) :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr store
stMem :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr Bool
(?@) :: (StoreHasSubmap store name key value, KnownValue value, exKey :~> key, exStore :~> store) => exStore -> (Label name, exKey) -> Expr Bool
wrap :: (InstrWrapOneC dt name, exField :~> CtorOnlyField name dt, KnownValue dt) => Label name -> exField -> Expr dt
unwrap :: (InstrUnwrapC dt name, exDt :~> dt, KnownValue (CtorOnlyField name dt)) => Label name -> exDt -> Expr (CtorOnlyField name dt)
(#!) :: (HasField dt name ftype, exDt :~> dt) => exDt -> Label name -> Expr ftype
(!!) :: (HasField dt name ftype, exDt :~> dt, exFld :~> ftype) => exDt -> (Label name, exFld) -> Expr dt
name :: (ex :~> t, KnownValue (name :! t)) => Label name -> ex -> Expr (name :! t)
unName :: (ex :~> (name :! t), KnownValue t) => Label name -> ex -> Expr t
(!~) :: (ex :~> t, KnownValue (name :! t)) => ex -> Label name -> Expr (name :! t)
(#~) :: (ex :~> (name :! t), KnownValue t) => ex -> Label name -> Expr t
construct :: (InstrConstructC dt, KnownValue dt, RMap (ConstructorFieldTypes dt), RecordToList (ConstructorFieldTypes dt), fields ~ Rec Expr (ConstructorFieldTypes dt), RecFromTuple fields) => IsoRecTuple fields -> Expr dt
constructRec :: (InstrConstructC dt, RMap (ConstructorFieldTypes dt), RecordToList (ConstructorFieldTypes dt), KnownValue dt) => Rec Expr (ConstructorFieldTypes dt) -> Expr dt
contract :: forall p vd addr exAddr. (NiceParameterFull p, NoExplicitDefaultEntrypoint p, IsoValue (ContractRef p), ToTAddress p vd addr, ToT addr ~ ToT Address, exAddr :~> addr) => exAddr -> Expr (Maybe (ContractRef p))
self :: (NiceParameterFull p, NoExplicitDefaultEntrypoint p, IsoValue (ContractRef p), IsNotInView) => Expr (ContractRef p)
selfAddress :: Expr Address
contractAddress :: exc :~> ContractRef p => exc -> Expr Address
contractCallingUnsafe :: (NiceParameter arg, IsoValue (ContractRef arg), exAddr :~> Address) => EpName -> exAddr -> Expr (Maybe (ContractRef arg))
contractCallingString :: (NiceParameter arg, IsoValue (ContractRef arg), exAddr :~> Address) => MText -> exAddr -> Expr (Maybe (ContractRef arg))
runFutureContract :: (NiceParameter p, IsoValue (ContractRef p), conExpr :~> FutureContract p) => conExpr -> Expr (Maybe (ContractRef p))
implicitAccount :: exkh :~> KeyHash => exkh -> Expr (ContractRef ())
convertEpAddressToContract :: (NiceParameter p, IsoValue (ContractRef p), epExpr :~> EpAddress) => epExpr -> Expr (Maybe (ContractRef p))
makeView :: (KnownValue (View_ a r), exa :~> a, exCRef :~> ContractRef r) => exa -> exCRef -> Expr (View_ a r)
makeVoid :: (KnownValue (Void_ a b), exa :~> a, exCRef :~> Lambda b b) => exa -> exCRef -> Expr (Void_ a b)
now :: Expr Timestamp
amount :: Expr Mutez
sender :: Expr Address
checkSignature :: (pkExpr :~> PublicKey, sigExpr :~> TSignature bs, hashExpr :~> bs, BytesLike bs) => pkExpr -> sigExpr -> hashExpr -> Expr Bool
sha256 :: (hashExpr :~> bs, BytesLike bs) => hashExpr -> Expr (Hash Sha256 bs)
sha512 :: (hashExpr :~> bs, BytesLike bs) => hashExpr -> Expr (Hash Sha512 bs)
blake2b :: (hashExpr :~> bs, BytesLike bs) => hashExpr -> Expr (Hash Blake2b bs)
sha3 :: (hashExpr :~> bs, BytesLike bs) => hashExpr -> Expr (Hash Sha3 bs)
keccak :: (hashExpr :~> bs, BytesLike bs) => hashExpr -> Expr (Hash Keccak bs)
hashKey :: keyExpr :~> PublicKey => keyExpr -> Expr KeyHash
chainId :: Expr ChainId
balance :: Expr Mutez
level :: Expr Natural
votingPower :: keyExpr :~> KeyHash => keyExpr -> Expr Natural
totalVotingPower :: Expr Natural
type ReturnableValue ret = ReturnableValue' (ClassifyReturnValue ret) ret
type RetVars ret = RetVars' (ClassifyReturnValue ret) ret
type IndigoContract param st = (HasStorage st, HasSideEffects, IsNotInView) => Var param -> IndigoM ()
newtype IndigoM a = IndigoM {
- unIndigoM :: Program (StatementF IndigoM) a
}
data Program instr a where
- Done :: a -> Program instr a
- Instr :: instr a -> Program instr a
- Bind :: Program instr a -> (a -> Program instr b) -> Program instr b
interpretProgram :: Monad m => (forall x. instr x -> m x) -> Program instr a -> m a
data CommentsVerbosity
- = NoComments
- | LogTopLevelFrontendStatements
- | LogBackendStatements
- | LogAuxCode
- | LogExpressionsComputations
data CommentSettings = CommentSettings {
- csVerbosity :: CommentsVerbosity
- csPrintFullStackTrace :: Bool
- csPrintFileName :: Bool
}
defaultCommentSettings :: CommentsVerbosity -> CommentSettings
compileIndigo :: forall n inp a. (AreIndigoParams n inp, KnownValue a, Default (StackVars inp)) => IndigoWithParams n inp a -> inp :-> inp
compileIndigoContractFull :: forall param st. (KnownValue param, IsObject st) => CommentSettings -> IndigoContract param st -> ContractCode param st
compileIndigoContract :: forall param st. (KnownValue param, IsObject st) => IndigoContract param st -> ContractCode param st
type IndigoEntrypoint param = param -> IndigoProcedure
type IndigoProcedure = IndigoM ()
type IndigoFunction ret = IndigoM (RetVars ret)
liftIndigoState :: (forall inp. SomeIndigoState inp) -> IndigoM ()
new :: (IsExpr ex x, HasCallStack) => ex -> IndigoM (Var x)
setVar :: (IsExpr ex x, HasCallStack) => Var x -> ex -> IndigoM ()
(=:) :: (IsExpr ex x, HasCallStack) => Var x -> ex -> IndigoM ()
setField :: (ex :~> ftype, IsObject dt, IsObject ftype, HasField dt fname ftype, HasCallStack) => Var dt -> Label fname -> ex -> IndigoM ()
(+=) :: (IsExpr ex1 n, IsObject m, ArithOpHs Add n m m, HasCallStack) => Var m -> ex1 -> IndigoM ()
(-=) :: (IsExpr ex1 n, IsObject m, ArithOpHs Sub n m m, HasCallStack) => Var m -> ex1 -> IndigoM ()
(*=) :: (IsExpr ex1 n, IsObject m, ArithOpHs Mul n m m, HasCallStack) => Var m -> ex1 -> IndigoM ()
(||=) :: (IsExpr ex1 n, IsObject m, ArithOpHs Or n m m, HasCallStack) => Var m -> ex1 -> IndigoM ()
(&&=) :: (IsExpr ex1 n, IsObject m, ArithOpHs And n m m, HasCallStack) => Var m -> ex1 -> IndigoM ()
(^=) :: (IsExpr ex1 n, IsObject m, ArithOpHs Xor n m m, HasCallStack) => Var m -> ex1 -> IndigoM ()
(<<<=) :: (IsExpr ex1 n, IsObject m, ArithOpHs Lsl n m m, HasCallStack) => Var m -> ex1 -> IndigoM ()
(>>>=) :: (IsExpr ex1 n, IsObject m, ArithOpHs Lsr n m m, HasCallStack) => Var m -> ex1 -> IndigoM ()
setStorageField :: forall store name ftype ex. (HasStorage store, ex :~> ftype, IsObject store, IsObject ftype, HasField store name ftype, HasCallStack) => Label name -> ex -> IndigoM ()
updateStorageField :: forall store ftype fname fex. (HasStorage store, fex :~> ftype, HasField store fname ftype, IsObject store, IsObject ftype, HasCallStack) => Label fname -> (Var ftype -> IndigoM fex) -> IndigoM ()
getStorageField :: forall store ftype fname. (HasStorage store, HasField store fname ftype, HasCallStack) => Label fname -> IndigoM (Var ftype)
if_ :: forall a b ex. (IfConstraint a b, ex :~> Bool, HasCallStack) => ex -> IndigoM a -> IndigoM b -> IndigoM (RetVars a)
when :: (exc :~> Bool, HasCallStack) => exc -> IndigoM () -> IndigoM ()
unless :: (exc :~> Bool, HasCallStack) => exc -> IndigoM () -> IndigoM ()
ifSome :: forall x a b ex. (KnownValue x, ex :~> Maybe x, IfConstraint a b, HasCallStack) => ex -> (Var x -> IndigoM a) -> IndigoM b -> IndigoM (RetVars a)
ifNone :: forall x a b ex. (KnownValue x, ex :~> Maybe x, IfConstraint a b, HasCallStack) => ex -> IndigoM b -> (Var x -> IndigoM a) -> IndigoM (RetVars a)
whenSome :: forall x exa. (KnownValue x, exa :~> Maybe x, HasCallStack) => exa -> (Var x -> IndigoM ()) -> IndigoM ()
whenNone :: forall x exa. (KnownValue x, exa :~> Maybe x, HasCallStack) => exa -> IndigoM () -> IndigoM ()
ifRight :: forall x y a b ex. (KnownValue x, KnownValue y, ex :~> Either y x, IfConstraint a b, HasCallStack) => ex -> (Var x -> IndigoM a) -> (Var y -> IndigoM b) -> IndigoM (RetVars a)
ifLeft :: forall x y a b ex. (KnownValue x, KnownValue y, ex :~> Either y x, IfConstraint a b, HasCallStack) => ex -> (Var y -> IndigoM b) -> (Var x -> IndigoM a) -> IndigoM (RetVars a)
whenRight :: forall x y ex. (KnownValue x, KnownValue y, ex :~> Either y x, HasCallStack) => ex -> (Var x -> IndigoM ()) -> IndigoM ()
whenLeft :: forall x y ex. (KnownValue x, KnownValue y, ex :~> Either y x, HasCallStack) => ex -> (Var y -> IndigoM ()) -> IndigoM ()
ifCons :: forall x a b ex. (KnownValue x, ex :~> List x, IfConstraint a b, HasCallStack) => ex -> (Var x -> Var (List x) -> IndigoM a) -> IndigoM b -> IndigoM (RetVars a)
caseRec :: forall dt guard ret clauses. (CaseCommonF (IndigoMCaseClauseL IndigoM) dt ret clauses, guard :~> dt, HasCallStack) => guard -> clauses -> IndigoM (RetVars ret)
case_ :: forall dt guard ret clauses. (CaseCommonF (IndigoMCaseClauseL IndigoM) dt ret clauses, RecFromTuple clauses, guard :~> dt, HasCallStack) => guard -> IsoRecTuple clauses -> IndigoM (RetVars ret)
entryCaseRec :: forall dt entrypointKind guard ret clauses. (CaseCommonF (IndigoMCaseClauseL IndigoM) dt ret clauses, DocumentEntrypoints entrypointKind dt, guard :~> dt, HasCallStack) => Proxy entrypointKind -> guard -> clauses -> IndigoM (RetVars ret)
entryCase :: forall dt entrypointKind guard ret clauses. (CaseCommonF (IndigoMCaseClauseL IndigoM) dt ret clauses, RecFromTuple clauses, DocumentEntrypoints entrypointKind dt, guard :~> dt, HasCallStack) => Proxy entrypointKind -> guard -> IsoRecTuple clauses -> IndigoM (RetVars ret)
entryCaseSimple :: forall cp guard ret clauses. (CaseCommonF (IndigoMCaseClauseL IndigoM) cp ret clauses, RecFromTuple clauses, DocumentEntrypoints PlainEntrypointsKind cp, NiceParameterFull cp, RequireFlatParamEps cp, guard :~> cp, HasCallStack) => guard -> IsoRecTuple clauses -> IndigoM (RetVars ret)
(//->) :: (name ~ AppendSymbol "c" ctor, KnownValue x, ScopeCodeGen retBr, ret ~ RetExprs retBr, RetOutStack ret ~ RetOutStack retBr) => Label name -> (Var x -> IndigoM retBr) -> IndigoMCaseClauseL IndigoM ret ('CaseClauseParam ctor ('OneField x))
(#=) :: (name ~ AppendSymbol "c" ctor, KnownValue x, ScopeCodeGen retBr, ret ~ RetExprs retBr, RetOutStack ret ~ RetOutStack retBr) => Label name -> (Var x -> IndigoM retBr) -> IndigoMCaseClauseL IndigoM ret ('CaseClauseParam ctor ('OneField x))
scope :: forall a. (ScopeCodeGen a, HasCallStack) => IndigoM a -> IndigoFunction a
defFunction :: forall a. (ScopeCodeGen a, HasCallStack) => IndigoM a -> IndigoFunction a
defContract :: HasCallStack => ((HasSideEffects, IsNotInView) => IndigoM ()) -> (HasSideEffects, IsNotInView) => IndigoProcedure
defNamedEffLambda1 :: forall st argExpr res. (ToExpr argExpr, Typeable res, ExecuteLambdaEff1C st (ExprType argExpr) res, CreateLambdaEff1C st (ExprType argExpr) res, HasCallStack) => String -> (Var (ExprType argExpr) -> IndigoM res) -> argExpr -> IndigoM (RetVars res)
defNamedLambda1 :: forall st argExpr res. (ToExpr argExpr, Typeable res, ExecuteLambda1C st (ExprType argExpr) res, CreateLambda1C st (ExprType argExpr) res, HasCallStack) => String -> (Var (ExprType argExpr) -> IndigoM res) -> argExpr -> IndigoM (RetVars res)
defNamedLambda0 :: forall st res. (Typeable res, ExecuteLambda1C st () res, CreateLambda1C st () res, HasCallStack) => String -> IndigoM res -> IndigoM (RetVars res)
defNamedPureLambda1 :: forall argExpr res. (ToExpr argExpr, Typeable res, ExecuteLambdaPure1C (ExprType argExpr) res, CreateLambdaPure1C (ExprType argExpr) res, HasCallStack) => String -> (Var (ExprType argExpr) -> IndigoM res) -> argExpr -> IndigoM (RetVars res)
while :: forall ex. (ex :~> Bool, HasCallStack) => ex -> IndigoM () -> IndigoM ()
whileLeft :: forall x y ex. (ex :~> Either y x, KnownValue y, KnownValue x, HasCallStack) => ex -> (Var y -> IndigoM ()) -> IndigoM (Var x)
forEach :: forall a e. (IterOpHs a, KnownValue (IterOpElHs a), e :~> a, HasCallStack) => e -> (Var (IterOpElHs a) -> IndigoM ()) -> IndigoM ()
doc :: (DocItem di, HasCallStack) => di -> IndigoM ()
docGroup :: (DocItem di, HasCallStack) => (SubDoc -> di) -> IndigoM () -> IndigoM ()
docStorage :: forall storage. (TypeHasDoc storage, HasCallStack) => IndigoM ()
contractName :: HasCallStack => Text -> IndigoM () -> IndigoM ()
contractGeneral :: HasCallStack => IndigoM () -> IndigoM ()
contractGeneralDefault :: HasCallStack => IndigoM ()
finalizeParamCallingDoc :: forall param. (ToExpr param, NiceParameterFull (ExprType param), RequireSumType (ExprType param), HasCallStack) => (Var (ExprType param) -> IndigoM ()) -> param -> IndigoM ()
description :: HasCallStack => Markdown -> IndigoM ()
anchor :: HasCallStack => Text -> IndigoM ()
example :: forall a. (NiceParameter a, HasCallStack) => a -> IndigoM ()
selfCalling :: forall p mname. (NiceParameterFull p, KnownValue (GetEntrypointArgCustom p mname), IsoValue (ContractRef (GetEntrypointArgCustom p mname)), HasCallStack, IsNotInView) => EntrypointRef mname -> IndigoM (Var (ContractRef (GetEntrypointArgCustom p mname)))
contractCalling :: forall cp vd epRef epArg addr exAddr. (HasEntrypointArg cp epRef epArg, ToTAddress cp vd addr, ToT addr ~ ToT Address, exAddr :~> addr, KnownValue epArg, IsoValue (ContractRef epArg), HasCallStack) => epRef -> exAddr -> IndigoM (Var (Maybe (ContractRef epArg)))
transferTokens :: (IsExpr exp p, IsExpr exm Mutez, IsExpr exc (ContractRef p), NiceParameter p, HasSideEffects, HasCallStack, IsNotInView) => exp -> exm -> exc -> IndigoM ()
setDelegate :: (HasSideEffects, IsExpr ex (Maybe KeyHash), HasCallStack, IsNotInView) => ex -> IndigoM ()
createContract :: forall st exk exm exs param. (IsObject st, IsExpr exk (Maybe KeyHash), IsExpr exm Mutez, IsExpr exs st, NiceStorageFull st, NiceParameterFull param, HasSideEffects, HasCallStack, IsNotInView) => (HasStorage st => Var param -> IndigoM ()) -> exk -> exm -> exs -> IndigoM (Var Address)
createLorentzContract :: (IsObject st, IsExpr exk (Maybe KeyHash), IsExpr exm Mutez, IsExpr exs st, NiceStorage st, NiceParameterFull param, NiceViewsDescriptor vd, Typeable vd, HasSideEffects, HasCallStack, IsNotInView) => Contract param st vd -> exk -> exm -> exs -> IndigoM (Var Address)
emit :: (HasSideEffects, NicePackedValue a, HasAnnotation a, HasCallStack) => FieldAnn -> Expr a -> IndigoM ()
failWith :: forall ret a ex. (NiceConstant a, IsExpr ex a, ReturnableValue ret, HasCallStack) => ex -> IndigoM (RetVars ret)
failCustom :: forall ret tag err ex. (ReturnableValue ret, MustHaveErrorArg tag (MText, err), CustomErrorHasDoc tag, NiceConstant err, ex :~> err, HasCallStack) => Label tag -> ex -> IndigoM (RetVars ret)
failCustom_ :: forall ret tag. (ReturnableValue ret, MustHaveErrorArg tag (MText, ()), CustomErrorHasDoc tag, HasCallStack) => Label tag -> IndigoM (RetVars ret)
failCustomNoArg :: forall ret tag. (ReturnableValue ret, MustHaveErrorArg tag MText, CustomErrorHasDoc tag, HasCallStack) => Label tag -> IndigoM (RetVars ret)
failUnexpected_ :: forall ret. (ReturnableValue ret, HasCallStack) => MText -> IndigoM (RetVars ret)
assert :: forall x ex. (IsError x, Buildable x, IsExpr ex Bool, HasCallStack) => x -> ex -> IndigoM ()
assertCustom :: forall tag err errEx ex. (MustHaveErrorArg tag (MText, err), CustomErrorHasDoc tag, NiceConstant err, IsExpr errEx err, IsExpr ex Bool, HasCallStack) => Label tag -> errEx -> ex -> IndigoM ()
assertCustom_ :: forall tag ex. (MustHaveErrorArg tag (MText, ()), CustomErrorHasDoc tag, IsExpr ex Bool, HasCallStack) => Label tag -> ex -> IndigoM ()
assertCustomNoArg :: forall tag ex. (MustHaveErrorArg tag MText, CustomErrorHasDoc tag, IsExpr ex Bool, HasCallStack) => Label tag -> ex -> IndigoM ()
assertSome :: forall x err ex. (IsError err, Buildable err, KnownValue x, ex :~> Maybe x, HasCallStack) => err -> ex -> IndigoM ()
assertNone :: forall x err ex. (IsError err, Buildable err, KnownValue x, ex :~> Maybe x, HasCallStack) => err -> ex -> IndigoM ()
assertRight :: forall x y err ex. (IsError err, Buildable err, KnownValue x, KnownValue y, ex :~> Either y x, HasCallStack) => err -> ex -> IndigoM ()
assertLeft :: forall x y err ex. (IsError err, Buildable err, KnownValue x, KnownValue y, ex :~> Either y x, HasCallStack) => err -> ex -> IndigoM ()
justComment :: HasCallStack => Text -> IndigoM ()
comment :: HasCallStack => CommentType -> IndigoM ()
commentAroundFun :: HasCallStack => Text -> IndigoM a -> IndigoM a
commentAroundStmt :: HasCallStack => Text -> IndigoM a -> IndigoM a
printIndigoContract :: forall param st. (IsObject st, NiceParameterFull param, NiceStorageFull st) => Bool -> CommentSettings -> IndigoContract param st -> LText
renderIndigoDoc :: forall param st. (IsObject st, NiceParameterFull param, NiceStorageFull st) => IndigoContract param st -> LText
printAsMichelson :: forall param st m. (IsObject st, NiceParameterFull param, NiceStorageFull st, MonadIO m) => CommentSettings -> IndigoContract param st -> m ()
saveAsMichelson :: forall param st m. (IsObject st, NiceParameterFull param, NiceStorageFull st, MonadIO m, MonadMask m) => CommentSettings -> IndigoContract param st -> FilePath -> m ()
printDocumentation :: forall param st m. (IsObject st, NiceParameterFull param, NiceStorageFull st, MonadIO m) => IndigoContract param st -> m ()
saveDocumentation :: forall param st m. (IsObject st, NiceParameterFull param, NiceStorageFull st, MonadIO m, MonadMask m) => IndigoContract param st -> FilePath -> m ()
ifThenElse :: (IfConstraint a b, IsExpr exa Bool) => exa -> IndigoM a -> IndigoM b -> IndigoM (RetVars a)
nat :: NumType 'Nat Natural
int :: NumType 'Int Integer
mutez :: NumType 'Mtz Mutez
fromInteger :: Integer -> NumType n t -> t
view_ :: forall arg r viewExpr exr. (KnownValue arg, NiceParameter r, viewExpr :~> View_ arg r, exr :~> r, HasSideEffects, IsNotInView) => (Expr arg -> IndigoM exr) -> viewExpr -> IndigoM ()
project :: forall arg r viewExpr exr. (KnownValue arg, NiceParameter r, viewExpr :~> View_ arg r, exr :~> r, HasSideEffects, IsNotInView) => viewExpr -> (Expr arg -> IndigoM exr) -> IndigoM ()
void_ :: forall a b voidExpr exb. (KnownValue a, IsError (VoidResult b), NiceConstant b, voidExpr :~> Void_ a b, exb :~> b) => (Expr a -> IndigoM exb) -> voidExpr -> IndigoM ()
projectVoid :: forall a b voidExpr exb. (KnownValue a, IsError (VoidResult b), NiceConstant b, voidExpr :~> Void_ a b, exb :~> b) => voidExpr -> (Expr a -> IndigoM exb) -> IndigoM ()
subGt0 :: (ex1 :~> Natural, ex2 :~> Natural) => ex1 -> ex2 -> IndigoM () -> IndigoFunction (Maybe Natural)

Documentation

(++) :: [a] -> [a] -> [a] infixr 5 #

Append two lists, i.e.,

[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

If the first list is not finite, the result is the first list.

seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b infixr 0 #

The value of seq a b is bottom if a is bottom, and otherwise equal to b. In other words, it evaluates the first argument a to weak head normal form (WHNF). seq is usually introduced to improve performance by avoiding unneeded laziness.

A note on evaluation order: the expression seq a b does not guarantee that a will be evaluated before b. The only guarantee given by seq is that the both a and b will be evaluated before seq returns a value. In particular, this means that b may be evaluated before a. If you need to guarantee a specific order of evaluation, you must use the function pseq from the "parallel" package.

filter :: (a -> Bool) -> [a] -> [a] #

$\mathcal{O}(n)$. filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,

filter p xs = [ x | x <- xs, p x]

>>> filter odd [1, 2, 3]
[1,3]

zip :: [a] -> [b] -> [(a, b)] #

$\mathcal{O}(\min(m,n))$. zip takes two lists and returns a list of corresponding pairs.

>>> zip [1, 2] ['a', 'b']
[(1, 'a'), (2, 'b')]

If one input list is shorter than the other, excess elements of the longer list are discarded, even if one of the lists is infinite:

>>> zip [1] ['a', 'b']
[(1, 'a')]
>>> zip [1, 2] ['a']
[(1, 'a')]
>>> zip [] [1..]
[]
>>> zip [1..] []
[]

zip is right-lazy:

>>> zip [] _|_
[]
>>> zip _|_ []
_|_

zip is capable of list fusion, but it is restricted to its first list argument and its resulting list.

otherwise :: Bool #

otherwise is defined as the value True. It helps to make guards more readable. eg.

 f x | x < 0     = ...
     | otherwise = ...

($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 #

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs.

Note that ($) is levity-polymorphic in its result type, so that foo $ True where foo :: Bool -> Int# is well-typed.

realToFrac :: (Real a, Fractional b) => a -> b #

general coercion to fractional types

guard :: Alternative f => Bool -> f () #

Conditional failure of Alternative computations. Defined by

guard True  = pure ()
guard False = empty

Examples

Expand

Common uses of guard include conditionally signaling an error in an error monad and conditionally rejecting the current choice in an Alternative-based parser.

As an example of signaling an error in the error monad Maybe, consider a safe division function safeDiv x y that returns Nothing when the denominator y is zero and Just (x `div` y) otherwise. For example:

>>> safeDiv 4 0
Nothing
>>> safeDiv 4 2
Just 2

A definition of safeDiv using guards, but not guard:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y | y /= 0    = Just (x `div` y)
            | otherwise = Nothing

A definition of safeDiv using guard and Monad do-notation:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y = do
  guard (y /= 0)
  return (x `div` y)

join :: Monad m => m (m a) -> m a #

The join function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

'join bss' can be understood as the do expression

do bs <- bss
   bs

Examples

Expand

A common use of join is to run an IO computation returned from an STM transaction, since STM transactions can't perform IO directly. Recall that

atomically :: STM a -> IO a

is used to run STM transactions atomically. So, by specializing the types of atomically and join to

atomically :: STM (IO b) -> IO (IO b)
join       :: IO (IO b)  -> IO b

we can compose them as

join . atomically :: STM (IO b) -> IO b

to run an STM transaction and the IO action it returns.

class Bounded a where #

The Bounded class is used to name the upper and lower limits of a type. Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds.

The Bounded class may be derived for any enumeration type; minBound is the first constructor listed in the data declaration and maxBound is the last. Bounded may also be derived for single-constructor datatypes whose constituent types are in Bounded.

Methods

minBound :: a #

maxBound :: a #

Instances

Instances details

Bounded CabalSpecVersion
Instance details Defined in Distribution.CabalSpecVersion Methods minBound :: CabalSpecVersion # maxBound :: CabalSpecVersion #
Bounded PWarnType
Instance details Defined in Distribution.Parsec.Warning Methods minBound :: PWarnType # maxBound :: PWarnType #
Bounded KnownExtension
Instance details Defined in Language.Haskell.Extension Methods minBound :: KnownExtension # maxBound :: KnownExtension #
Bounded All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: All # maxBound :: All #
Bounded Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Any # maxBound :: Any #
Bounded Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: Associativity # maxBound :: Associativity #
Bounded DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: DecidedStrictness # maxBound :: DecidedStrictness #
Bounded SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceStrictness # maxBound :: SourceStrictness #
Bounded SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceUnpackedness # maxBound :: SourceUnpackedness #
Bounded Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int16 # maxBound :: Int16 #
Bounded Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int32 # maxBound :: Int32 #
Bounded Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int64 # maxBound :: Int64 #
Bounded Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int8 # maxBound :: Int8 #
Bounded GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Unicode Methods minBound :: GeneralCategory # maxBound :: GeneralCategory #
Bounded Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word16 # maxBound :: Word16 #
Bounded Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word32 # maxBound :: Word32 #
Bounded Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word64 # maxBound :: Word64 #
Bounded Encoding
Instance details Defined in Basement.String Methods minBound :: Encoding # maxBound :: Encoding #
Bounded UTF32_Invalid
Instance details Defined in Basement.String.Encoding.UTF32 Methods minBound :: UTF32_Invalid # maxBound :: UTF32_Invalid #
Bounded Bit
Instance details Defined in Data.Bit.Internal Methods minBound :: Bit # maxBound :: Bit #
Bounded TimeSpec
Instance details Defined in System.Clock Methods minBound :: TimeSpec # maxBound :: TimeSpec #
Bounded Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods minBound :: Extension # maxBound :: Extension #
Bounded Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering # maxBound :: Ordering #
Bounded BlstError
Instance details Defined in Crypto.BLST.Internal.Bindings Methods minBound :: BlstError # maxBound :: BlstError #
Bounded EncodeMethod
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods minBound :: EncodeMethod # maxBound :: EncodeMethod #
Bounded RefId Source #
Instance details Defined in Indigo.Common.Var Methods minBound :: RefId # maxBound :: RefId #
Bounded CommentsVerbosity Source #
Instance details Defined in Indigo.Compilation.Hooks Methods minBound :: CommentsVerbosity # maxBound :: CommentsVerbosity #
Bounded AddressKind
Instance details Defined in Morley.Tezos.Address.Kinds Methods minBound :: AddressKind # maxBound :: AddressKind #
Bounded Mutez
Instance details Defined in Morley.Tezos.Core Methods minBound :: Mutez # maxBound :: Mutez #
Bounded KeyType
Instance details Defined in Morley.Tezos.Crypto Methods minBound :: KeyType # maxBound :: KeyType #
Bounded Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods minBound :: Bls12381Fr # maxBound :: Bls12381Fr #
Bounded TLTime
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods minBound :: TLTime # maxBound :: TLTime #
Bounded Mod2
Instance details Defined in Data.Semiring Methods minBound :: Mod2 # maxBound :: Mod2 #
Bounded Undefined
Instance details Defined in Universum.Debug Methods minBound :: Undefined # maxBound :: Undefined #
Bounded Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word8 # maxBound :: Word8 #
Bounded ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: () # maxBound :: () #
Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool # maxBound :: Bool #
Bounded Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char # maxBound :: Char #
Bounded Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int # maxBound :: Int #
Bounded VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecCount # maxBound :: VecCount #
Bounded VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecElem # maxBound :: VecElem #
Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word # maxBound :: Word #
() :=> (Bounded Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Ordering #
() :=> (Bounded ())
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded () #
() :=> (Bounded Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Bool #
() :=> (Bounded Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Char #
() :=> (Bounded Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Int #
() :=> (Bounded Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Word #
a :=> (Bounded (Dict a))
Instance details Defined in Data.Constraint Methods ins :: a :- Bounded (Dict a) #
Class () (Bounded a)
Instance details Defined in Data.Constraint Methods cls :: Bounded a :- () #
Bounded a => Bounded (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a # maxBound :: Identity a #
Bounded a => Bounded (Down a)	Swaps `minBound` and `maxBound` of the underlying type. Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods minBound :: Down a # maxBound :: Down a #
Bounded a => Bounded (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: First a # maxBound :: First a #
Bounded a => Bounded (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Last a # maxBound :: Last a #
Bounded a => Bounded (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Max a # maxBound :: Max a #
Bounded a => Bounded (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Min a # maxBound :: Min a #
Bounded m => Bounded (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: WrappedMonoid m # maxBound :: WrappedMonoid m #
Bounded a => Bounded (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Dual a # maxBound :: Dual a #
Bounded a => Bounded (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Product a # maxBound :: Product a #
Bounded a => Bounded (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Sum a # maxBound :: Sum a #
SizeValid n => Bounded (Bits n)
Instance details Defined in Basement.Bits Methods minBound :: Bits n # maxBound :: Bits n #
a => Bounded (Dict a)
Instance details Defined in Data.Constraint Methods minBound :: Dict a # maxBound :: Dict a #
KnownNat p => Bounded (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods minBound :: Binary p # maxBound :: Binary p #
KnownNat p => Bounded (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods minBound :: Prime p # maxBound :: Prime p #
KnownNat m => Bounded (Mod m)
Instance details Defined in Data.Mod Methods minBound :: Mod m # maxBound :: Mod m #
Bounded a => Bounded (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods minBound :: StringEncode a # maxBound :: StringEncode a #
Bounded a => Bounded (All a)
Instance details Defined in Morley.Prelude.Boolean Methods minBound :: All a # maxBound :: All a #
Bounded a => Bounded (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods minBound :: Any a # maxBound :: Any a #
Bounded a => Bounded (Add a)
Instance details Defined in Data.Semiring Methods minBound :: Add a # maxBound :: Add a #
Bounded a => Bounded (Mul a)
Instance details Defined in Data.Semiring Methods minBound :: Mul a # maxBound :: Mul a #
Bounded a => Bounded (WrappedNum a)
Instance details Defined in Data.Semiring Methods minBound :: WrappedNum a # maxBound :: WrappedNum a #
(Bounded a) :=> (Bounded (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Bounded a :- Bounded (Const a b) #
(Bounded a) :=> (Bounded (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Bounded a :- Bounded (Identity a) #
(Num a, Bits a, TypeNum n) => Bounded (OddWord a n)
Instance details Defined in Data.Word.Odd Methods minBound :: OddWord a n # maxBound :: OddWord a n #
Bounded (Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods minBound :: Proxy t # maxBound :: Proxy t #
(Bounded a, Bounded b) => Bounded (Pair a b)
Instance details Defined in Data.Strict.Tuple Methods minBound :: Pair a b # maxBound :: Pair a b #
(Bounded a, Bounded b) => Bounded (a, b)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b) # maxBound :: (a, b) #
(Bounded a, Bounded b) :=> (Bounded (a, b))
Instance details Defined in Data.Constraint Methods ins :: (Bounded a, Bounded b) :- Bounded (a, b) #
Bounded a => Bounded (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b # maxBound :: Const a b #
(Applicative f, Bounded a) => Bounded (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods minBound :: Ap f a # maxBound :: Ap f a #
Coercible a b => Bounded (Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods minBound :: Coercion a b # maxBound :: Coercion a b #
a ~ b => Bounded (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~: b # maxBound :: a :~: b #
Bounded b => Bounded (Tagged s b)
Instance details Defined in Data.Tagged Methods minBound :: Tagged s b # maxBound :: Tagged s b #
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c) # maxBound :: (a, b, c) #
a ~~ b => Bounded (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods minBound :: a :~~: b # maxBound :: a :~~: b #
(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d) # maxBound :: (a, b, c, d) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e) # maxBound :: (a, b, c, d, e) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f) # maxBound :: (a, b, c, d, e, f) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g) # maxBound :: (a, b, c, d, e, f, g) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h) # maxBound :: (a, b, c, d, e, f, g, h) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i) # maxBound :: (a, b, c, d, e, f, g, h, i) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j) # maxBound :: (a, b, c, d, e, f, g, h, i, j) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #

class Enum a where #

Class Enum defines operations on sequentially ordered types.

The enumFrom... methods are used in Haskell's translation of arithmetic sequences.

Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details.

For any type that is an instance of class Bounded as well as Enum, the following should hold:

The calls succ maxBound and pred minBound should result in a runtime error.
fromEnum and toEnum should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool is an error.
enumFrom and enumFromThen should be defined with an implicit bound, thus:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
     where
       bound | fromEnum y >= fromEnum x = maxBound
             | otherwise                = minBound

Minimal complete definition

toEnum, fromEnum

Methods

succ :: a -> a #

the successor of a value. For numeric types, succ adds 1.

pred :: a -> a #

the predecessor of a value. For numeric types, pred subtracts 1.

toEnum :: Int -> a #

Convert from an Int.

fromEnum :: a -> Int #

Convert to an Int. It is implementation-dependent what fromEnum returns when applied to a value that is too large to fit in an Int.

enumFrom :: a -> [a] #

Used in Haskell's translation of [n..] with [n..] = enumFrom n, a possible implementation being enumFrom n = n : enumFrom (succ n). For example:

```
enumFrom 4 :: [Integer] = [4,5,6,7,...]
```

enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound :: Int]

enumFromThen :: a -> a -> [a] #

Used in Haskell's translation of [n,n'..] with [n,n'..] = enumFromThen n n', a possible implementation being enumFromThen n n' = n : n' : worker (f x) (f x n'), worker s v = v : worker s (s v), x = fromEnum n' - fromEnum n and f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n + 1) (pred y) | otherwise = y For example:

enumFromThen 4 6 :: [Integer] = [4,6,8,10...]

enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound :: Int]

enumFromTo :: a -> a -> [a] #

Used in Haskell's translation of [n..m] with [n..m] = enumFromTo n m, a possible implementation being enumFromTo n m | n <= m = n : enumFromTo (succ n) m | otherwise = []. For example:

```
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
```
```
enumFromTo 42 1 :: [Integer] = []
```

enumFromThenTo :: a -> a -> a -> [a] #

Used in Haskell's translation of [n,n'..m] with [n,n'..m] = enumFromThenTo n n' m, a possible implementation being enumFromThenTo n n' m = worker (f x) (c x) n m, x = fromEnum n' - fromEnum n, c x = bool (>=) ((x 0) f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n + 1) (pred y) | otherwise = y and worker s c v m | c v m = v : worker s c (s v) m | otherwise = [] For example:

enumFromThenTo 4 2 -6 :: [Integer] = [4,2,0,-2,-4,-6]

```
enumFromThenTo 6 8 2 :: [Int] = []
```

Instances

Instances details

Enum CabalSpecVersion
Instance details Defined in Distribution.CabalSpecVersion Methods succ :: CabalSpecVersion -> CabalSpecVersion # pred :: CabalSpecVersion -> CabalSpecVersion # toEnum :: Int -> CabalSpecVersion # fromEnum :: CabalSpecVersion -> Int # enumFrom :: CabalSpecVersion -> [CabalSpecVersion] # enumFromThen :: CabalSpecVersion -> CabalSpecVersion -> [CabalSpecVersion] # enumFromTo :: CabalSpecVersion -> CabalSpecVersion -> [CabalSpecVersion] # enumFromThenTo :: CabalSpecVersion -> CabalSpecVersion -> CabalSpecVersion -> [CabalSpecVersion] #
Enum PWarnType
Instance details Defined in Distribution.Parsec.Warning Methods succ :: PWarnType -> PWarnType # pred :: PWarnType -> PWarnType # toEnum :: Int -> PWarnType # fromEnum :: PWarnType -> Int # enumFrom :: PWarnType -> [PWarnType] # enumFromThen :: PWarnType -> PWarnType -> [PWarnType] # enumFromTo :: PWarnType -> PWarnType -> [PWarnType] # enumFromThenTo :: PWarnType -> PWarnType -> PWarnType -> [PWarnType] #
Enum KnownExtension
Instance details Defined in Language.Haskell.Extension Methods succ :: KnownExtension -> KnownExtension # pred :: KnownExtension -> KnownExtension # toEnum :: Int -> KnownExtension # fromEnum :: KnownExtension -> Int # enumFrom :: KnownExtension -> [KnownExtension] # enumFromThen :: KnownExtension -> KnownExtension -> [KnownExtension] # enumFromTo :: KnownExtension -> KnownExtension -> [KnownExtension] # enumFromThenTo :: KnownExtension -> KnownExtension -> KnownExtension -> [KnownExtension] #
Enum Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] #
Enum DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] #
Enum SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] #
Enum SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] #
Enum IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods succ :: IOMode -> IOMode # pred :: IOMode -> IOMode # toEnum :: Int -> IOMode # fromEnum :: IOMode -> Int # enumFrom :: IOMode -> [IOMode] # enumFromThen :: IOMode -> IOMode -> [IOMode] # enumFromTo :: IOMode -> IOMode -> [IOMode] # enumFromThenTo :: IOMode -> IOMode -> IOMode -> [IOMode] #
Enum Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int16 -> Int16 # pred :: Int16 -> Int16 # toEnum :: Int -> Int16 # fromEnum :: Int16 -> Int # enumFrom :: Int16 -> [Int16] # enumFromThen :: Int16 -> Int16 -> [Int16] # enumFromTo :: Int16 -> Int16 -> [Int16] # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] #
Enum Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Enum Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Enum Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int8 -> Int8 # pred :: Int8 -> Int8 # toEnum :: Int -> Int8 # fromEnum :: Int8 -> Int # enumFrom :: Int8 -> [Int8] # enumFromThen :: Int8 -> Int8 -> [Int8] # enumFromTo :: Int8 -> Int8 -> [Int8] # enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8] #
Enum DoCostCentres	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods succ :: DoCostCentres -> DoCostCentres # pred :: DoCostCentres -> DoCostCentres # toEnum :: Int -> DoCostCentres # fromEnum :: DoCostCentres -> Int # enumFrom :: DoCostCentres -> [DoCostCentres] # enumFromThen :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromTo :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromThenTo :: DoCostCentres -> DoCostCentres -> DoCostCentres -> [DoCostCentres] #
Enum DoHeapProfile	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods succ :: DoHeapProfile -> DoHeapProfile # pred :: DoHeapProfile -> DoHeapProfile # toEnum :: Int -> DoHeapProfile # fromEnum :: DoHeapProfile -> Int # enumFrom :: DoHeapProfile -> [DoHeapProfile] # enumFromThen :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromTo :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromThenTo :: DoHeapProfile -> DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] #
Enum DoTrace	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods succ :: DoTrace -> DoTrace # pred :: DoTrace -> DoTrace # toEnum :: Int -> DoTrace # fromEnum :: DoTrace -> Int # enumFrom :: DoTrace -> [DoTrace] # enumFromThen :: DoTrace -> DoTrace -> [DoTrace] # enumFromTo :: DoTrace -> DoTrace -> [DoTrace] # enumFromThenTo :: DoTrace -> DoTrace -> DoTrace -> [DoTrace] #
Enum GiveGCStats	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods succ :: GiveGCStats -> GiveGCStats # pred :: GiveGCStats -> GiveGCStats # toEnum :: Int -> GiveGCStats # fromEnum :: GiveGCStats -> Int # enumFrom :: GiveGCStats -> [GiveGCStats] # enumFromThen :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromTo :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromThenTo :: GiveGCStats -> GiveGCStats -> GiveGCStats -> [GiveGCStats] #
Enum IoSubSystem	Since: base-4.9.0.0
Instance details Defined in GHC.RTS.Flags Methods succ :: IoSubSystem -> IoSubSystem # pred :: IoSubSystem -> IoSubSystem # toEnum :: Int -> IoSubSystem # fromEnum :: IoSubSystem -> Int # enumFrom :: IoSubSystem -> [IoSubSystem] # enumFromThen :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromTo :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromThenTo :: IoSubSystem -> IoSubSystem -> IoSubSystem -> [IoSubSystem] #
Enum GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Unicode Methods succ :: GeneralCategory -> GeneralCategory # pred :: GeneralCategory -> GeneralCategory # toEnum :: Int -> GeneralCategory # fromEnum :: GeneralCategory -> Int # enumFrom :: GeneralCategory -> [GeneralCategory] # enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] #
Enum Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Enum Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Enum Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Enum Encoding
Instance details Defined in Basement.String Methods succ :: Encoding -> Encoding # pred :: Encoding -> Encoding # toEnum :: Int -> Encoding # fromEnum :: Encoding -> Int # enumFrom :: Encoding -> [Encoding] # enumFromThen :: Encoding -> Encoding -> [Encoding] # enumFromTo :: Encoding -> Encoding -> [Encoding] # enumFromThenTo :: Encoding -> Encoding -> Encoding -> [Encoding] #
Enum UTF32_Invalid
Instance details Defined in Basement.String.Encoding.UTF32 Methods succ :: UTF32_Invalid -> UTF32_Invalid # pred :: UTF32_Invalid -> UTF32_Invalid # toEnum :: Int -> UTF32_Invalid # fromEnum :: UTF32_Invalid -> Int # enumFrom :: UTF32_Invalid -> [UTF32_Invalid] # enumFromThen :: UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # enumFromTo :: UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # enumFromThenTo :: UTF32_Invalid -> UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] #
Enum F2Poly
Instance details Defined in Data.Bit.F2Poly Methods succ :: F2Poly -> F2Poly # pred :: F2Poly -> F2Poly # toEnum :: Int -> F2Poly # fromEnum :: F2Poly -> Int # enumFrom :: F2Poly -> [F2Poly] # enumFromThen :: F2Poly -> F2Poly -> [F2Poly] # enumFromTo :: F2Poly -> F2Poly -> [F2Poly] # enumFromThenTo :: F2Poly -> F2Poly -> F2Poly -> [F2Poly] #
Enum Bit
Instance details Defined in Data.Bit.Internal Methods succ :: Bit -> Bit # pred :: Bit -> Bit # toEnum :: Int -> Bit # fromEnum :: Bit -> Int # enumFrom :: Bit -> [Bit] # enumFromThen :: Bit -> Bit -> [Bit] # enumFromTo :: Bit -> Bit -> [Bit] # enumFromThenTo :: Bit -> Bit -> Bit -> [Bit] #
Enum Clock
Instance details Defined in System.Clock Methods succ :: Clock -> Clock # pred :: Clock -> Clock # toEnum :: Int -> Clock # fromEnum :: Clock -> Int # enumFrom :: Clock -> [Clock] # enumFromThen :: Clock -> Clock -> [Clock] # enumFromTo :: Clock -> Clock -> [Clock] # enumFromThenTo :: Clock -> Clock -> Clock -> [Clock] #
Enum TimeSpec
Instance details Defined in System.Clock Methods succ :: TimeSpec -> TimeSpec # pred :: TimeSpec -> TimeSpec # toEnum :: Int -> TimeSpec # fromEnum :: TimeSpec -> Int # enumFrom :: TimeSpec -> [TimeSpec] # enumFromThen :: TimeSpec -> TimeSpec -> [TimeSpec] # enumFromTo :: TimeSpec -> TimeSpec -> [TimeSpec] # enumFromThenTo :: TimeSpec -> TimeSpec -> TimeSpec -> [TimeSpec] #
Enum CryptoError
Instance details Defined in Crypto.Error.Types Methods succ :: CryptoError -> CryptoError # pred :: CryptoError -> CryptoError # toEnum :: Int -> CryptoError # fromEnum :: CryptoError -> Int # enumFrom :: CryptoError -> [CryptoError] # enumFromThen :: CryptoError -> CryptoError -> [CryptoError] # enumFromTo :: CryptoError -> CryptoError -> [CryptoError] # enumFromThenTo :: CryptoError -> CryptoError -> CryptoError -> [CryptoError] #
Enum Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # toEnum :: Int -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Enum BlstError	Generate secret key from bytes. Input must be at least 32 bytes long.
Instance details Defined in Crypto.BLST.Internal.Bindings Methods succ :: BlstError -> BlstError # pred :: BlstError -> BlstError # toEnum :: Int -> BlstError # fromEnum :: BlstError -> Int # enumFrom :: BlstError -> [BlstError] # enumFromThen :: BlstError -> BlstError -> [BlstError] # enumFromTo :: BlstError -> BlstError -> [BlstError] # enumFromThenTo :: BlstError -> BlstError -> BlstError -> [BlstError] #
Enum EncodeMethod
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods succ :: EncodeMethod -> EncodeMethod # pred :: EncodeMethod -> EncodeMethod # toEnum :: Int -> EncodeMethod # fromEnum :: EncodeMethod -> Int # enumFrom :: EncodeMethod -> [EncodeMethod] # enumFromThen :: EncodeMethod -> EncodeMethod -> [EncodeMethod] # enumFromTo :: EncodeMethod -> EncodeMethod -> [EncodeMethod] # enumFromThenTo :: EncodeMethod -> EncodeMethod -> EncodeMethod -> [EncodeMethod] #
Enum RefId Source #
Instance details Defined in Indigo.Common.Var Methods succ :: RefId -> RefId # pred :: RefId -> RefId # toEnum :: Int -> RefId # fromEnum :: RefId -> Int # enumFrom :: RefId -> [RefId] # enumFromThen :: RefId -> RefId -> [RefId] # enumFromTo :: RefId -> RefId -> [RefId] # enumFromThenTo :: RefId -> RefId -> RefId -> [RefId] #
Enum CommentsVerbosity Source #
Instance details Defined in Indigo.Compilation.Hooks Methods succ :: CommentsVerbosity -> CommentsVerbosity # pred :: CommentsVerbosity -> CommentsVerbosity # toEnum :: Int -> CommentsVerbosity # fromEnum :: CommentsVerbosity -> Int # enumFrom :: CommentsVerbosity -> [CommentsVerbosity] # enumFromThen :: CommentsVerbosity -> CommentsVerbosity -> [CommentsVerbosity] # enumFromTo :: CommentsVerbosity -> CommentsVerbosity -> [CommentsVerbosity] # enumFromThenTo :: CommentsVerbosity -> CommentsVerbosity -> CommentsVerbosity -> [CommentsVerbosity] #
Enum FailureType
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods succ :: FailureType -> FailureType # pred :: FailureType -> FailureType # toEnum :: Int -> FailureType # fromEnum :: FailureType -> Int # enumFrom :: FailureType -> [FailureType] # enumFromThen :: FailureType -> FailureType -> [FailureType] # enumFromTo :: FailureType -> FailureType -> [FailureType] # enumFromThenTo :: FailureType -> FailureType -> FailureType -> [FailureType] #
Enum HasAnns
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods succ :: HasAnns -> HasAnns # pred :: HasAnns -> HasAnns # toEnum :: Int -> HasAnns # fromEnum :: HasAnns -> Int # enumFrom :: HasAnns -> [HasAnns] # enumFromThen :: HasAnns -> HasAnns -> [HasAnns] # enumFromTo :: HasAnns -> HasAnns -> [HasAnns] # enumFromThenTo :: HasAnns -> HasAnns -> HasAnns -> [HasAnns] #
Enum IsMichelson
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods succ :: IsMichelson -> IsMichelson # pred :: IsMichelson -> IsMichelson # toEnum :: Int -> IsMichelson # fromEnum :: IsMichelson -> Int # enumFrom :: IsMichelson -> [IsMichelson] # enumFromThen :: IsMichelson -> IsMichelson -> [IsMichelson] # enumFromTo :: IsMichelson -> IsMichelson -> [IsMichelson] # enumFromThenTo :: IsMichelson -> IsMichelson -> IsMichelson -> [IsMichelson] #
Enum NumChildren
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods succ :: NumChildren -> NumChildren # pred :: NumChildren -> NumChildren # toEnum :: Int -> NumChildren # fromEnum :: NumChildren -> Int # enumFrom :: NumChildren -> [NumChildren] # enumFromThen :: NumChildren -> NumChildren -> [NumChildren] # enumFromTo :: NumChildren -> NumChildren -> [NumChildren] # enumFromThenTo :: NumChildren -> NumChildren -> NumChildren -> [NumChildren] #
Enum HandleImplicitDefaultEp
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods succ :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp # pred :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp # toEnum :: Int -> HandleImplicitDefaultEp # fromEnum :: HandleImplicitDefaultEp -> Int # enumFrom :: HandleImplicitDefaultEp -> [HandleImplicitDefaultEp] # enumFromThen :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> [HandleImplicitDefaultEp] # enumFromTo :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> [HandleImplicitDefaultEp] # enumFromThenTo :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> [HandleImplicitDefaultEp] #
Enum AddressKind
Instance details Defined in Morley.Tezos.Address.Kinds Methods succ :: AddressKind -> AddressKind # pred :: AddressKind -> AddressKind # toEnum :: Int -> AddressKind # fromEnum :: AddressKind -> Int # enumFrom :: AddressKind -> [AddressKind] # enumFromThen :: AddressKind -> AddressKind -> [AddressKind] # enumFromTo :: AddressKind -> AddressKind -> [AddressKind] # enumFromThenTo :: AddressKind -> AddressKind -> AddressKind -> [AddressKind] #
Enum Mutez
Instance details Defined in Morley.Tezos.Core Methods succ :: Mutez -> Mutez # pred :: Mutez -> Mutez # toEnum :: Int -> Mutez # fromEnum :: Mutez -> Int # enumFrom :: Mutez -> [Mutez] # enumFromThen :: Mutez -> Mutez -> [Mutez] # enumFromTo :: Mutez -> Mutez -> [Mutez] # enumFromThenTo :: Mutez -> Mutez -> Mutez -> [Mutez] #
Enum KeyType
Instance details Defined in Morley.Tezos.Crypto Methods succ :: KeyType -> KeyType # pred :: KeyType -> KeyType # toEnum :: Int -> KeyType # fromEnum :: KeyType -> Int # enumFrom :: KeyType -> [KeyType] # enumFromThen :: KeyType -> KeyType -> [KeyType] # enumFromTo :: KeyType -> KeyType -> [KeyType] # enumFromThenTo :: KeyType -> KeyType -> KeyType -> [KeyType] #
Enum Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods succ :: Bls12381Fr -> Bls12381Fr # pred :: Bls12381Fr -> Bls12381Fr # toEnum :: Int -> Bls12381Fr # fromEnum :: Bls12381Fr -> Int # enumFrom :: Bls12381Fr -> [Bls12381Fr] # enumFromThen :: Bls12381Fr -> Bls12381Fr -> [Bls12381Fr] # enumFromTo :: Bls12381Fr -> Bls12381Fr -> [Bls12381Fr] # enumFromThenTo :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr -> [Bls12381Fr] #
Enum Mod2
Instance details Defined in Data.Semiring Methods succ :: Mod2 -> Mod2 # pred :: Mod2 -> Mod2 # toEnum :: Int -> Mod2 # fromEnum :: Mod2 -> Int # enumFrom :: Mod2 -> [Mod2] # enumFromThen :: Mod2 -> Mod2 -> [Mod2] # enumFromTo :: Mod2 -> Mod2 -> [Mod2] # enumFromThenTo :: Mod2 -> Mod2 -> Mod2 -> [Mod2] #
Enum NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods succ :: NominalDiffTime -> NominalDiffTime # pred :: NominalDiffTime -> NominalDiffTime # toEnum :: Int -> NominalDiffTime # fromEnum :: NominalDiffTime -> Int # enumFrom :: NominalDiffTime -> [NominalDiffTime] # enumFromThen :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromTo :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromThenTo :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] #
Enum Undefined
Instance details Defined in Universum.Debug Methods succ :: Undefined -> Undefined # pred :: Undefined -> Undefined # toEnum :: Int -> Undefined # fromEnum :: Undefined -> Int # enumFrom :: Undefined -> [Undefined] # enumFromThen :: Undefined -> Undefined -> [Undefined] # enumFromTo :: Undefined -> Undefined -> [Undefined] # enumFromThenTo :: Undefined -> Undefined -> Undefined -> [Undefined] #
Enum Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Enum Integer	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Enum Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Enum Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Enum ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: () -> () # pred :: () -> () # toEnum :: Int -> () # fromEnum :: () -> Int # enumFrom :: () -> [()] # enumFromThen :: () -> () -> [()] # enumFromTo :: () -> () -> [()] # enumFromThenTo :: () -> () -> () -> [()] #
Enum Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Bool -> Bool # pred :: Bool -> Bool # toEnum :: Int -> Bool # fromEnum :: Bool -> Int # enumFrom :: Bool -> [Bool] # enumFromThen :: Bool -> Bool -> [Bool] # enumFromTo :: Bool -> Bool -> [Bool] # enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #
Enum Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Char -> Char # pred :: Char -> Char # toEnum :: Int -> Char # fromEnum :: Char -> Int # enumFrom :: Char -> [Char] # enumFromThen :: Char -> Char -> [Char] # enumFromTo :: Char -> Char -> [Char] # enumFromThenTo :: Char -> Char -> Char -> [Char] #
Enum Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Int -> Int # pred :: Int -> Int # toEnum :: Int -> Int # fromEnum :: Int -> Int # enumFrom :: Int -> [Int] # enumFromThen :: Int -> Int -> [Int] # enumFromTo :: Int -> Int -> [Int] # enumFromThenTo :: Int -> Int -> Int -> [Int] #
Enum VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # toEnum :: Int -> VecCount # fromEnum :: VecCount -> Int # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] #
Enum VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecElem -> VecElem # pred :: VecElem -> VecElem # toEnum :: Int -> VecElem # fromEnum :: VecElem -> Int # enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Word -> Word # pred :: Word -> Word # toEnum :: Int -> Word # fromEnum :: Word -> Int # enumFrom :: Word -> [Word] # enumFromThen :: Word -> Word -> [Word] # enumFromTo :: Word -> Word -> [Word] # enumFromThenTo :: Word -> Word -> Word -> [Word] #
() :=> (Enum Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Ordering #
() :=> (Enum Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Integer #
() :=> (Enum Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Natural #
() :=> (Enum ())
Instance details Defined in Data.Constraint Methods ins :: () :- Enum () #
() :=> (Enum Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Bool #
() :=> (Enum Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Char #
() :=> (Enum Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Double #
() :=> (Enum Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Float #
() :=> (Enum Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Int #
() :=> (Enum Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Word #
a :=> (Enum (Dict a))
Instance details Defined in Data.Constraint Methods ins :: a :- Enum (Dict a) #
Class () (Enum a)
Instance details Defined in Data.Constraint Methods cls :: Enum a :- () #
Enum a => Enum (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] #
Enum a => Enum (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: First a -> First a # pred :: First a -> First a # toEnum :: Int -> First a # fromEnum :: First a -> Int # enumFrom :: First a -> [First a] # enumFromThen :: First a -> First a -> [First a] # enumFromTo :: First a -> First a -> [First a] # enumFromThenTo :: First a -> First a -> First a -> [First a] #
Enum a => Enum (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Last a -> Last a # pred :: Last a -> Last a # toEnum :: Int -> Last a # fromEnum :: Last a -> Int # enumFrom :: Last a -> [Last a] # enumFromThen :: Last a -> Last a -> [Last a] # enumFromTo :: Last a -> Last a -> [Last a] # enumFromThenTo :: Last a -> Last a -> Last a -> [Last a] #
Enum a => Enum (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Max a -> Max a # pred :: Max a -> Max a # toEnum :: Int -> Max a # fromEnum :: Max a -> Int # enumFrom :: Max a -> [Max a] # enumFromThen :: Max a -> Max a -> [Max a] # enumFromTo :: Max a -> Max a -> [Max a] # enumFromThenTo :: Max a -> Max a -> Max a -> [Max a] #
Enum a => Enum (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Min a -> Min a # pred :: Min a -> Min a # toEnum :: Int -> Min a # fromEnum :: Min a -> Int # enumFrom :: Min a -> [Min a] # enumFromThen :: Min a -> Min a -> [Min a] # enumFromTo :: Min a -> Min a -> [Min a] # enumFromThenTo :: Min a -> Min a -> Min a -> [Min a] #
Enum a => Enum (WrappedMonoid a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] #
Integral a => Enum (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods succ :: Ratio a -> Ratio a # pred :: Ratio a -> Ratio a # toEnum :: Int -> Ratio a # fromEnum :: Ratio a -> Int # enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] #
SizeValid n => Enum (Bits n)
Instance details Defined in Basement.Bits Methods succ :: Bits n -> Bits n # pred :: Bits n -> Bits n # toEnum :: Int -> Bits n # fromEnum :: Bits n -> Int # enumFrom :: Bits n -> [Bits n] # enumFromThen :: Bits n -> Bits n -> [Bits n] # enumFromTo :: Bits n -> Bits n -> [Bits n] # enumFromThenTo :: Bits n -> Bits n -> Bits n -> [Bits n] #
Enum (CountOf ty)
Instance details Defined in Basement.Types.OffsetSize Methods succ :: CountOf ty -> CountOf ty # pred :: CountOf ty -> CountOf ty # toEnum :: Int -> CountOf ty # fromEnum :: CountOf ty -> Int # enumFrom :: CountOf ty -> [CountOf ty] # enumFromThen :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromTo :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromThenTo :: CountOf ty -> CountOf ty -> CountOf ty -> [CountOf ty] #
Enum (Offset ty)
Instance details Defined in Basement.Types.OffsetSize Methods succ :: Offset ty -> Offset ty # pred :: Offset ty -> Offset ty # toEnum :: Int -> Offset ty # fromEnum :: Offset ty -> Int # enumFrom :: Offset ty -> [Offset ty] # enumFromThen :: Offset ty -> Offset ty -> [Offset ty] # enumFromTo :: Offset ty -> Offset ty -> [Offset ty] # enumFromThenTo :: Offset ty -> Offset ty -> Offset ty -> [Offset ty] #
a => Enum (Dict a)
Instance details 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] #
KnownNat p => Enum (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods succ :: Binary p -> Binary p # pred :: Binary p -> Binary p # toEnum :: Int -> Binary p # fromEnum :: Binary p -> Int # enumFrom :: Binary p -> [Binary p] # enumFromThen :: Binary p -> Binary p -> [Binary p] # enumFromTo :: Binary p -> Binary p -> [Binary p] # enumFromThenTo :: Binary p -> Binary p -> Binary p -> [Binary p] #
KnownNat p => Enum (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods succ :: Prime p -> Prime p # pred :: Prime p -> Prime p # toEnum :: Int -> Prime p # fromEnum :: Prime p -> Int # enumFrom :: Prime p -> [Prime p] # enumFromThen :: Prime p -> Prime p -> [Prime p] # enumFromTo :: Prime p -> Prime p -> [Prime p] # enumFromThenTo :: Prime p -> Prime p -> Prime p -> [Prime p] #
KnownNat m => Enum (Mod m)
Instance details Defined in Data.Mod Methods succ :: Mod m -> Mod m # pred :: Mod m -> Mod m # toEnum :: Int -> Mod m # fromEnum :: Mod m -> Int # enumFrom :: Mod m -> [Mod m] # enumFromThen :: Mod m -> Mod m -> [Mod m] # enumFromTo :: Mod m -> Mod m -> [Mod m] # enumFromThenTo :: Mod m -> Mod m -> Mod m -> [Mod m] #
Enum a => Enum (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods succ :: StringEncode a -> StringEncode a # pred :: StringEncode a -> StringEncode a # toEnum :: Int -> StringEncode a # fromEnum :: StringEncode a -> Int # enumFrom :: StringEncode a -> [StringEncode a] # enumFromThen :: StringEncode a -> StringEncode a -> [StringEncode a] # enumFromTo :: StringEncode a -> StringEncode a -> [StringEncode a] # enumFromThenTo :: StringEncode a -> StringEncode a -> StringEncode a -> [StringEncode a] #
Enum a => Enum (All a)
Instance details Defined in Morley.Prelude.Boolean Methods succ :: All a -> All a # pred :: All a -> All a # toEnum :: Int -> All a # fromEnum :: All a -> Int # enumFrom :: All a -> [All a] # enumFromThen :: All a -> All a -> [All a] # enumFromTo :: All a -> All a -> [All a] # enumFromThenTo :: All a -> All a -> All a -> [All a] #
Enum a => Enum (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods succ :: Any a -> Any a # pred :: Any a -> Any a # toEnum :: Int -> Any a # fromEnum :: Any a -> Int # enumFrom :: Any a -> [Any a] # enumFromThen :: Any a -> Any a -> [Any a] # enumFromTo :: Any a -> Any a -> [Any a] # enumFromThenTo :: Any a -> Any a -> Any a -> [Any a] #
Enum a => Enum (Add a)
Instance details Defined in Data.Semiring Methods succ :: Add a -> Add a # pred :: Add a -> Add a # toEnum :: Int -> Add a # fromEnum :: Add a -> Int # enumFrom :: Add a -> [Add a] # enumFromThen :: Add a -> Add a -> [Add a] # enumFromTo :: Add a -> Add a -> [Add a] # enumFromThenTo :: Add a -> Add a -> Add a -> [Add a] #
Enum a => Enum (Mul a)
Instance details Defined in Data.Semiring Methods succ :: Mul a -> Mul a # pred :: Mul a -> Mul a # toEnum :: Int -> Mul a # fromEnum :: Mul a -> Int # enumFrom :: Mul a -> [Mul a] # enumFromThen :: Mul a -> Mul a -> [Mul a] # enumFromTo :: Mul a -> Mul a -> [Mul a] # enumFromThenTo :: Mul a -> Mul a -> Mul a -> [Mul a] #
Enum a => Enum (WrappedNum a)
Instance details Defined in Data.Semiring Methods succ :: WrappedNum a -> WrappedNum a # pred :: WrappedNum a -> WrappedNum a # toEnum :: Int -> WrappedNum a # fromEnum :: WrappedNum a -> Int # enumFrom :: WrappedNum a -> [WrappedNum a] # enumFromThen :: WrappedNum a -> WrappedNum a -> [WrappedNum a] # enumFromTo :: WrappedNum a -> WrappedNum a -> [WrappedNum a] # enumFromThenTo :: WrappedNum a -> WrappedNum a -> WrappedNum a -> [WrappedNum a] #
(Enum a) :=> (Enum (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Enum a :- Enum (Const a b) #
(Enum a) :=> (Enum (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Enum a :- Enum (Identity a) #
(Integral a) :=> (Enum (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Enum (Ratio a) #
(Enum a, Ord a, Num a, Bits a, TypeNum n) => Enum (OddWord a n)
Instance details Defined in Data.Word.Odd Methods succ :: OddWord a n -> OddWord a n # pred :: OddWord a n -> OddWord a n # toEnum :: Int -> OddWord a n # fromEnum :: OddWord a n -> Int # enumFrom :: OddWord a n -> [OddWord a n] # enumFromThen :: OddWord a n -> OddWord a n -> [OddWord a n] # enumFromTo :: OddWord a n -> OddWord a n -> [OddWord a n] # enumFromThenTo :: OddWord a n -> OddWord a n -> OddWord a n -> [OddWord a n] #
Enum (Fixed a)	Recall that, for numeric types, `succ` and `pred` typically add and subtract `1`, respectively. This is not true in the case of `Fixed`, whose successor and predecessor functions intuitively return the "next" and "previous" values in the enumeration. The results of these functions thus depend on the resolution of the `Fixed` value. For example, when enumerating values of resolution `10^-3` of `type Milli = Fixed E3`, succ (0.000 :: Milli) == 1.001 and likewise pred (0.000 :: Milli) == -0.001 In other words, `succ` and `pred` increment and decrement a fixed-precision value by the least amount such that the value's resolution is unchanged. For example, `10^-12` is the smallest (positive) amount that can be added to a value of `type Pico = Fixed E12` without changing its resolution, and so succ (0.000000000000 :: Pico) == 0.000000000001 and similarly pred (0.000000000000 :: Pico) == -0.000000000001 This is worth bearing in mind when defining `Fixed` arithmetic sequences. In particular, you may be forgiven for thinking the sequence [1..10] :: [Pico] evaluates to `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] :: [Pico]`. However, this is not true. On the contrary, similarly to the above implementations of `succ` and `pred`, `enumFromTo :: Pico -> Pico -> [Pico]` has a "step size" of `10^-12`. Hence, the list `[1..10] :: [Pico]` has the form [1.000000000000, 1.00000000001, 1.00000000002, ..., 10.000000000000] and contains `9 * 10^12 + 1` values. Since: base-2.1
Instance details Defined in Data.Fixed Methods succ :: Fixed a -> Fixed a # pred :: Fixed a -> Fixed a # toEnum :: Int -> Fixed a # fromEnum :: Fixed a -> Int # enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] #
Enum (Proxy s)	Since: base-4.7.0.0
Instance details 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] #
Class (Real a, Enum a) (Integral a)
Instance details Defined in Data.Constraint Methods cls :: Integral a :- (Real a, Enum a) #
Enum a => Enum (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # toEnum :: Int -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] #
Enum (f a) => Enum (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods succ :: Ap f a -> Ap f a # pred :: Ap f a -> Ap f a # toEnum :: Int -> Ap f a # fromEnum :: Ap f a -> Int # enumFrom :: Ap f a -> [Ap f a] # enumFromThen :: Ap f a -> Ap f a -> [Ap f a] # enumFromTo :: Ap f a -> Ap f a -> [Ap f a] # enumFromThenTo :: Ap f a -> Ap f a -> Ap f a -> [Ap f a] #
Enum (f a) => Enum (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods succ :: Alt f a -> Alt f a # pred :: Alt f a -> Alt f a # toEnum :: Int -> Alt f a # fromEnum :: Alt f a -> Int # enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] #
Coercible a b => Enum (Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods succ :: Coercion a b -> Coercion a b # pred :: Coercion a b -> Coercion a b # toEnum :: Int -> Coercion a b # fromEnum :: Coercion a b -> Int # enumFrom :: Coercion a b -> [Coercion a b] # enumFromThen :: Coercion a b -> Coercion a b -> [Coercion a b] # enumFromTo :: Coercion a b -> Coercion a b -> [Coercion a b] # enumFromThenTo :: Coercion a b -> Coercion a b -> Coercion a b -> [Coercion a b] #
a ~ b => Enum (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b # pred :: (a :~: b) -> a :~: b # toEnum :: Int -> a :~: b # fromEnum :: (a :~: b) -> Int # enumFrom :: (a :~: b) -> [a :~: b] # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] #
Enum a => Enum (Tagged s a)
Instance details Defined in Data.Tagged Methods succ :: Tagged s a -> Tagged s a # pred :: Tagged s a -> Tagged s a # toEnum :: Int -> Tagged s a # fromEnum :: Tagged s a -> Int # enumFrom :: Tagged s a -> [Tagged s a] # enumFromThen :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromTo :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromThenTo :: Tagged s a -> Tagged s a -> Tagged s a -> [Tagged s a] #
a ~~ b => Enum (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods succ :: (a :~~: b) -> a :~~: b # pred :: (a :~~: b) -> a :~~: b # toEnum :: Int -> a :~~: b # fromEnum :: (a :~~: b) -> Int # enumFrom :: (a :~~: b) -> [a :~~: b] # enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b] #

class Eq a #

The Eq class defines equality (==) and inequality (/=). All the basic datatypes exported by the Prelude are instances of Eq, and Eq may be derived for any datatype whose constituents are also instances of Eq.

The Haskell Report defines no laws for Eq. However, == is customarily expected to implement an equivalence relationship where two values comparing equal are indistinguishable by "public" functions, with a "public" function being one not allowing to see implementation details. For example, for a type representing non-normalised natural numbers modulo 100, a "public" function doesn't make the difference between 1 and 201. It is expected to have the following properties:

Reflexivity: x == x = True
Symmetry: x == y = y == x
Transitivity: if x == y && y == z = True, then x == z = True
Substitutivity: if x == y = True and f is a "public" function whose return type is an instance of Eq, then f x == f y = True
Negation: x /= y = not (x == y)

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Instances

Instances details

Eq CabalSpecVersion
Instance details Defined in Distribution.CabalSpecVersion Methods (==) :: CabalSpecVersion -> CabalSpecVersion -> Bool # (/=) :: CabalSpecVersion -> CabalSpecVersion -> Bool #
Eq HasCommonStanzas
Instance details Defined in Distribution.CabalSpecVersion Methods (==) :: HasCommonStanzas -> HasCommonStanzas -> Bool # (/=) :: HasCommonStanzas -> HasCommonStanzas -> Bool #
Eq HasElif
Instance details Defined in Distribution.CabalSpecVersion Methods (==) :: HasElif -> HasElif -> Bool # (/=) :: HasElif -> HasElif -> Bool #
Eq Position
Instance details Defined in Distribution.Parsec.Position Methods (==) :: Position -> Position -> Bool # (/=) :: Position -> Position -> Bool #
Eq PWarnType
Instance details Defined in Distribution.Parsec.Warning Methods (==) :: PWarnType -> PWarnType -> Bool # (/=) :: PWarnType -> PWarnType -> Bool #
Eq Structure
Instance details Defined in Distribution.Utils.Structured Methods (==) :: Structure -> Structure -> Bool # (/=) :: Structure -> Structure -> Bool #
Eq Extension
Instance details Defined in Language.Haskell.Extension Methods (==) :: Extension -> Extension -> Bool # (/=) :: Extension -> Extension -> Bool #
Eq KnownExtension
Instance details Defined in Language.Haskell.Extension Methods (==) :: KnownExtension -> KnownExtension -> Bool # (/=) :: KnownExtension -> KnownExtension -> Bool #
Eq Language
Instance details Defined in Language.Haskell.Extension Methods (==) :: Language -> Language -> Bool # (/=) :: Language -> Language -> Bool #
Eq DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: DotNetTime -> DotNetTime -> Bool # (/=) :: DotNetTime -> DotNetTime -> Bool #
Eq JSONPathElement
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: JSONPathElement -> JSONPathElement -> Bool # (/=) :: JSONPathElement -> JSONPathElement -> Bool #
Eq SumEncoding
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: SumEncoding -> SumEncoding -> Bool # (/=) :: SumEncoding -> SumEncoding -> Bool #
Eq Value
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Eq More
Instance details Defined in Data.Attoparsec.Internal.Types Methods (==) :: More -> More -> Bool # (/=) :: More -> More -> Bool #
Eq Pos
Instance details Defined in Data.Attoparsec.Internal.Types Methods (==) :: Pos -> Pos -> Bool # (/=) :: Pos -> Pos -> Bool #
Eq All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Eq Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Any -> Any -> Bool # (/=) :: Any -> Any -> Bool #
Eq SomeTypeRep
Instance details Defined in Data.Typeable.Internal Methods (==) :: SomeTypeRep -> SomeTypeRep -> Bool # (/=) :: SomeTypeRep -> SomeTypeRep -> Bool #
Eq Version	Since: base-2.1
Instance details Defined in Data.Version Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Eq Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Eq BlockReason	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: BlockReason -> BlockReason -> Bool # (/=) :: BlockReason -> BlockReason -> Bool #
Eq ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: ThreadId -> ThreadId -> Bool # (/=) :: ThreadId -> ThreadId -> Bool #
Eq ThreadStatus	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: ThreadStatus -> ThreadStatus -> Bool # (/=) :: ThreadStatus -> ThreadStatus -> Bool #
Eq ErrorCall	Since: base-4.7.0.0
Instance details Defined in GHC.Exception Methods (==) :: ErrorCall -> ErrorCall -> Bool # (/=) :: ErrorCall -> ErrorCall -> Bool #
Eq ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool #
Eq SpecConstrAnnotation	Since: base-4.3.0.0
Instance details Defined in GHC.Exts Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool #
Eq Fingerprint	Since: base-4.4.0.0
Instance details Defined in GHC.Fingerprint.Type Methods (==) :: Fingerprint -> Fingerprint -> Bool # (/=) :: Fingerprint -> Fingerprint -> Bool #
Eq Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool #
Eq DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool #
Eq ArrayException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool #
Eq AsyncException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool #
Eq ExitCode
Instance details Defined in GHC.IO.Exception Methods (==) :: ExitCode -> ExitCode -> Bool # (/=) :: ExitCode -> ExitCode -> Bool #
Eq IOErrorType	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: IOErrorType -> IOErrorType -> Bool # (/=) :: IOErrorType -> IOErrorType -> Bool #
Eq IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #
Eq BufferMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: BufferMode -> BufferMode -> Bool # (/=) :: BufferMode -> BufferMode -> Bool #
Eq Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: Handle -> Handle -> Bool # (/=) :: Handle -> Handle -> Bool #
Eq Newline	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: Newline -> Newline -> Bool # (/=) :: Newline -> Newline -> Bool #
Eq NewlineMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: NewlineMode -> NewlineMode -> Bool # (/=) :: NewlineMode -> NewlineMode -> Bool #
Eq IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods (==) :: IOMode -> IOMode -> Bool # (/=) :: IOMode -> IOMode -> Bool #
Eq Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Eq Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Eq Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Eq Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Eq IoSubSystem
Instance details Defined in GHC.RTS.Flags Methods (==) :: IoSubSystem -> IoSubSystem -> Bool # (/=) :: IoSubSystem -> IoSubSystem -> Bool #
Eq SrcLoc	Since: base-4.9.0.0
Instance details Defined in GHC.Stack.Types Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Eq SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods (==) :: SomeSymbol -> SomeSymbol -> Bool # (/=) :: SomeSymbol -> SomeSymbol -> Bool #
Eq SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods (==) :: SomeNat -> SomeNat -> Bool # (/=) :: SomeNat -> SomeNat -> Bool #
Eq GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Unicode Methods (==) :: GeneralCategory -> GeneralCategory -> Bool # (/=) :: GeneralCategory -> GeneralCategory -> Bool #
Eq Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Eq Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Eq Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Eq Alphabet
Instance details Defined in Data.ByteString.Base58.Internal Methods (==) :: Alphabet -> Alphabet -> Bool # (/=) :: Alphabet -> Alphabet -> Bool #
Eq Encoding
Instance details Defined in Basement.String Methods (==) :: Encoding -> Encoding -> Bool # (/=) :: Encoding -> Encoding -> Bool #
Eq ASCII7_Invalid
Instance details Defined in Basement.String.Encoding.ASCII7 Methods (==) :: ASCII7_Invalid -> ASCII7_Invalid -> Bool # (/=) :: ASCII7_Invalid -> ASCII7_Invalid -> Bool #
Eq ISO_8859_1_Invalid
Instance details Defined in Basement.String.Encoding.ISO_8859_1 Methods (==) :: ISO_8859_1_Invalid -> ISO_8859_1_Invalid -> Bool # (/=) :: ISO_8859_1_Invalid -> ISO_8859_1_Invalid -> Bool #
Eq UTF16_Invalid
Instance details Defined in Basement.String.Encoding.UTF16 Methods (==) :: UTF16_Invalid -> UTF16_Invalid -> Bool # (/=) :: UTF16_Invalid -> UTF16_Invalid -> Bool #
Eq UTF32_Invalid
Instance details Defined in Basement.String.Encoding.UTF32 Methods (==) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (/=) :: UTF32_Invalid -> UTF32_Invalid -> Bool #
Eq AsciiString
Instance details Defined in Basement.Types.AsciiString Methods (==) :: AsciiString -> AsciiString -> Bool # (/=) :: AsciiString -> AsciiString -> Bool #
Eq FileSize
Instance details Defined in Basement.Types.OffsetSize Methods (==) :: FileSize -> FileSize -> Bool # (/=) :: FileSize -> FileSize -> Bool #
Eq String
Instance details Defined in Basement.UTF8.Base Methods (==) :: String -> String -> Bool # (/=) :: String -> String -> Bool #
Eq BimapException
Instance details Defined in Data.Bimap Methods (==) :: BimapException -> BimapException -> Bool # (/=) :: BimapException -> BimapException -> Bool #
Eq F2Poly
Instance details Defined in Data.Bit.F2Poly Methods (==) :: F2Poly -> F2Poly -> Bool # (/=) :: F2Poly -> F2Poly -> Bool #
Eq Bit
Instance details Defined in Data.Bit.Internal Methods (==) :: Bit -> Bit -> Bool # (/=) :: Bit -> Bit -> Bool #
Eq ByteString
Instance details Defined in Data.ByteString.Internal Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods (==) :: ShortByteString -> ShortByteString -> Bool # (/=) :: ShortByteString -> ShortByteString -> Bool #
Eq Clock
Instance details Defined in System.Clock Methods (==) :: Clock -> Clock -> Bool # (/=) :: Clock -> Clock -> Bool #
Eq TimeSpec
Instance details Defined in System.Clock Methods (==) :: TimeSpec -> TimeSpec -> Bool # (/=) :: TimeSpec -> TimeSpec -> Bool #
Eq IntSet
Instance details Defined in Data.IntSet.Internal Methods (==) :: IntSet -> IntSet -> Bool # (/=) :: IntSet -> IntSet -> Bool #
Eq Relation
Instance details Defined in Data.IntSet.Internal Methods (==) :: Relation -> Relation -> Bool # (/=) :: Relation -> Relation -> Bool #
Eq CryptoError
Instance details Defined in Crypto.Error.Types Methods (==) :: CryptoError -> CryptoError -> Bool # (/=) :: CryptoError -> CryptoError -> Bool #
Eq KeyPair
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods (==) :: KeyPair -> KeyPair -> Bool # (/=) :: KeyPair -> KeyPair -> Bool #
Eq PrivateKey
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods (==) :: PrivateKey -> PrivateKey -> Bool # (/=) :: PrivateKey -> PrivateKey -> Bool #
Eq PublicKey
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods (==) :: PublicKey -> PublicKey -> Bool # (/=) :: PublicKey -> PublicKey -> Bool #
Eq Signature
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Eq PublicKey
Instance details Defined in Crypto.PubKey.Ed25519 Methods (==) :: PublicKey -> PublicKey -> Bool # (/=) :: PublicKey -> PublicKey -> Bool #
Eq SecretKey
Instance details Defined in Crypto.PubKey.Ed25519 Methods (==) :: SecretKey -> SecretKey -> Bool # (/=) :: SecretKey -> SecretKey -> Bool #
Eq Signature
Instance details Defined in Crypto.PubKey.Ed25519 Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Eq BigNat
Instance details Defined in GHC.Num.BigNat Methods (==) :: BigNat -> BigNat -> Bool # (/=) :: BigNat -> BigNat -> Bool #
Eq ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool #
Eq Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods (==) :: Extension -> Extension -> Bool # (/=) :: Extension -> Extension -> Bool #
Eq Module
Instance details Defined in GHC.Classes Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq Ordering
Instance details Defined in GHC.Classes Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Eq TrName
Instance details Defined in GHC.Classes Methods (==) :: TrName -> TrName -> Bool # (/=) :: TrName -> TrName -> Bool #
Eq TyCon
Instance details Defined in GHC.Classes Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Eq BlstError
Instance details Defined in Crypto.BLST.Internal.Bindings Methods (==) :: BlstError -> BlstError -> Bool # (/=) :: BlstError -> BlstError -> Bool #
Eq EncodeMethod
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods (==) :: EncodeMethod -> EncodeMethod -> Bool # (/=) :: EncodeMethod -> EncodeMethod -> Bool #
Eq Scalar
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods (==) :: Scalar -> Scalar -> Bool # (/=) :: Scalar -> Scalar -> Bool #
Eq SecretKey
Instance details Defined in Crypto.BLST.Internal.Types Methods (==) :: SecretKey -> SecretKey -> Bool # (/=) :: SecretKey -> SecretKey -> Bool #
Eq RefId Source #
Instance details Defined in Indigo.Common.Var Methods (==) :: RefId -> RefId -> Bool # (/=) :: RefId -> RefId -> Bool #
Eq CommentSettings Source #
Instance details Defined in Indigo.Compilation.Hooks Methods (==) :: CommentSettings -> CommentSettings -> Bool # (/=) :: CommentSettings -> CommentSettings -> Bool #
Eq CommentsVerbosity Source #
Instance details Defined in Indigo.Compilation.Hooks Methods (==) :: CommentsVerbosity -> CommentsVerbosity -> Bool # (/=) :: CommentsVerbosity -> CommentsVerbosity -> Bool #
Eq ParseLorentzError
Instance details Defined in Lorentz.Base Methods (==) :: ParseLorentzError -> ParseLorentzError -> Bool # (/=) :: ParseLorentzError -> ParseLorentzError -> Bool #
Eq DHashAlgorithm
Instance details Defined in Lorentz.Bytes Methods (==) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (/=) :: DHashAlgorithm -> DHashAlgorithm -> Bool #
Eq DViewDesc
Instance details Defined in Lorentz.Doc Methods (==) :: DViewDesc -> DViewDesc -> Bool # (/=) :: DViewDesc -> DViewDesc -> Bool #
Eq EpCallingStep
Instance details Defined in Lorentz.Entrypoints.Core Methods (==) :: EpCallingStep -> EpCallingStep -> Bool # (/=) :: EpCallingStep -> EpCallingStep -> Bool #
Eq ParamBuilder
Instance details Defined in Lorentz.Entrypoints.Doc Methods (==) :: ParamBuilder -> ParamBuilder -> Bool # (/=) :: ParamBuilder -> ParamBuilder -> Bool #
Eq ParamBuildingDesc
Instance details Defined in Lorentz.Entrypoints.Doc Methods (==) :: ParamBuildingDesc -> ParamBuildingDesc -> Bool # (/=) :: ParamBuildingDesc -> ParamBuildingDesc -> Bool #
Eq ParamBuildingStep
Instance details Defined in Lorentz.Entrypoints.Doc Methods (==) :: ParamBuildingStep -> ParamBuildingStep -> Bool # (/=) :: ParamBuildingStep -> ParamBuildingStep -> Bool #
Eq DError
Instance details Defined in Lorentz.Errors Methods (==) :: DError -> DError -> Bool # (/=) :: DError -> DError -> Bool #
Eq DThrows
Instance details Defined in Lorentz.Errors Methods (==) :: DThrows -> DThrows -> Bool # (/=) :: DThrows -> DThrows -> Bool #
Eq SomeError
Instance details Defined in Lorentz.Errors Methods (==) :: SomeError -> SomeError -> Bool # (/=) :: SomeError -> SomeError -> Bool #
Eq DDescribeErrorTagMap
Instance details Defined in Lorentz.Errors.Numeric.Doc Methods (==) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (/=) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool #
Eq EntrypointLookupError
Instance details Defined in Lorentz.UParam Methods (==) :: EntrypointLookupError -> EntrypointLookupError -> Bool # (/=) :: EntrypointLookupError -> EntrypointLookupError -> Bool #
Eq Never
Instance details Defined in Lorentz.Value Methods (==) :: Never -> Never -> Bool # (/=) :: Never -> Never -> Bool #
Eq OpenChest
Instance details Defined in Lorentz.Value Methods (==) :: OpenChest -> OpenChest -> Bool # (/=) :: OpenChest -> OpenChest -> Bool #
Eq ViewInterfaceMatchError
Instance details Defined in Lorentz.ViewBase Methods (==) :: ViewInterfaceMatchError -> ViewInterfaceMatchError -> Bool # (/=) :: ViewInterfaceMatchError -> ViewInterfaceMatchError -> Bool #
Eq ZSNil
Instance details Defined in Lorentz.Zip Methods (==) :: ZSNil -> ZSNil -> Bool # (/=) :: ZSNil -> ZSNil -> Bool #
Eq InvalidPosException
Instance details Defined in Text.Megaparsec.Pos Methods (==) :: InvalidPosException -> InvalidPosException -> Bool # (/=) :: InvalidPosException -> InvalidPosException -> Bool #
Eq Pos
Instance details Defined in Text.Megaparsec.Pos Methods (==) :: Pos -> Pos -> Bool # (/=) :: Pos -> Pos -> Bool #
Eq SourcePos
Instance details Defined in Text.Megaparsec.Pos Methods (==) :: SourcePos -> SourcePos -> Bool # (/=) :: SourcePos -> SourcePos -> Bool #
Eq DefName
Instance details Defined in Lens.Micro.TH Methods (==) :: DefName -> DefName -> Bool # (/=) :: DefName -> DefName -> Bool #
Eq Annotation
Instance details Defined in Morley.Micheline.Expression Methods (==) :: Annotation -> Annotation -> Bool # (/=) :: Annotation -> Annotation -> Bool #
Eq MichelinePrimitive
Instance details Defined in Morley.Micheline.Expression Methods (==) :: MichelinePrimitive -> MichelinePrimitive -> Bool # (/=) :: MichelinePrimitive -> MichelinePrimitive -> Bool #
Eq TezosMutez
Instance details Defined in Morley.Micheline.Json Methods (==) :: TezosMutez -> TezosMutez -> Bool # (/=) :: TezosMutez -> TezosMutez -> Bool #
Eq AnalyzerRes
Instance details Defined in Morley.Michelson.Analyzer Methods (==) :: AnalyzerRes -> AnalyzerRes -> Bool # (/=) :: AnalyzerRes -> AnalyzerRes -> Bool #
Eq DocItemId
Instance details Defined in Morley.Michelson.Doc Methods (==) :: DocItemId -> DocItemId -> Bool # (/=) :: DocItemId -> DocItemId -> Bool #
Eq DocItemPos
Instance details Defined in Morley.Michelson.Doc Methods (==) :: DocItemPos -> DocItemPos -> Bool # (/=) :: DocItemPos -> DocItemPos -> Bool #
Eq SomeDocDefinitionItem
Instance details Defined in Morley.Michelson.Doc Methods (==) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (/=) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool #
Eq ErrorSrcPos
Instance details Defined in Morley.Michelson.ErrorPos Methods (==) :: ErrorSrcPos -> ErrorSrcPos -> Bool # (/=) :: ErrorSrcPos -> ErrorSrcPos -> Bool #
Eq Pos
Instance details Defined in Morley.Michelson.ErrorPos Methods (==) :: Pos -> Pos -> Bool # (/=) :: Pos -> Pos -> Bool #
Eq SrcPos
Instance details Defined in Morley.Michelson.ErrorPos Methods (==) :: SrcPos -> SrcPos -> Bool # (/=) :: SrcPos -> SrcPos -> Bool #
Eq BadViewNameError
Instance details Defined in Morley.Michelson.Internal.ViewName Methods (==) :: BadViewNameError -> BadViewNameError -> Bool # (/=) :: BadViewNameError -> BadViewNameError -> Bool #
Eq ViewName
Instance details Defined in Morley.Michelson.Internal.ViewName Methods (==) :: ViewName -> ViewName -> Bool # (/=) :: ViewName -> ViewName -> Bool #
Eq ViewsSetError
Instance details Defined in Morley.Michelson.Internal.ViewsSet Methods (==) :: ViewsSetError -> ViewsSetError -> Bool # (/=) :: ViewsSetError -> ViewsSetError -> Bool #
Eq MorleyLogs
Instance details Defined in Morley.Michelson.Interpret Methods (==) :: MorleyLogs -> MorleyLogs -> Bool # (/=) :: MorleyLogs -> MorleyLogs -> Bool #
Eq RemainingSteps
Instance details Defined in Morley.Michelson.Interpret Methods (==) :: RemainingSteps -> RemainingSteps -> Bool # (/=) :: RemainingSteps -> RemainingSteps -> Bool #
Eq CadrStruct
Instance details Defined in Morley.Michelson.Macro Methods (==) :: CadrStruct -> CadrStruct -> Bool # (/=) :: CadrStruct -> CadrStruct -> Bool #
Eq Macro
Instance details Defined in Morley.Michelson.Macro Methods (==) :: Macro -> Macro -> Bool # (/=) :: Macro -> Macro -> Bool #
Eq PairStruct
Instance details Defined in Morley.Michelson.Macro Methods (==) :: PairStruct -> PairStruct -> Bool # (/=) :: PairStruct -> PairStruct -> Bool #
Eq ParsedOp
Instance details Defined in Morley.Michelson.Macro Methods (==) :: ParsedOp -> ParsedOp -> Bool # (/=) :: ParsedOp -> ParsedOp -> Bool #
Eq UnpairStruct
Instance details Defined in Morley.Michelson.Macro Methods (==) :: UnpairStruct -> UnpairStruct -> Bool # (/=) :: UnpairStruct -> UnpairStruct -> Bool #
Eq OptimizationStage
Instance details Defined in Morley.Michelson.Optimizer Methods (==) :: OptimizationStage -> OptimizationStage -> Bool # (/=) :: OptimizationStage -> OptimizationStage -> Bool #
Eq CustomParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods (==) :: CustomParserException -> CustomParserException -> Bool # (/=) :: CustomParserException -> CustomParserException -> Bool #
Eq ParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods (==) :: ParserException -> ParserException -> Bool # (/=) :: ParserException -> ParserException -> Bool #
Eq StringLiteralParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods (==) :: StringLiteralParserException -> StringLiteralParserException -> Bool # (/=) :: StringLiteralParserException -> StringLiteralParserException -> Bool #
Eq MichelsonSource
Instance details Defined in Morley.Michelson.Parser.Types Methods (==) :: MichelsonSource -> MichelsonSource -> Bool # (/=) :: MichelsonSource -> MichelsonSource -> Bool #
Eq ParserOptions
Instance details Defined in Morley.Michelson.Parser.Types Methods (==) :: ParserOptions -> ParserOptions -> Bool # (/=) :: ParserOptions -> ParserOptions -> Bool #
Eq BigMapCounter
Instance details Defined in Morley.Michelson.Runtime.GState Methods (==) :: BigMapCounter -> BigMapCounter -> Bool # (/=) :: BigMapCounter -> BigMapCounter -> Bool #
Eq ContractState
Instance details Defined in Morley.Michelson.Runtime.GState Methods (==) :: ContractState -> ContractState -> Bool # (/=) :: ContractState -> ContractState -> Bool #
Eq GState
Instance details Defined in Morley.Michelson.Runtime.GState Methods (==) :: GState -> GState -> Bool # (/=) :: GState -> GState -> Bool #
Eq ImplicitState
Instance details Defined in Morley.Michelson.Runtime.GState Methods (==) :: ImplicitState -> ImplicitState -> Bool # (/=) :: ImplicitState -> ImplicitState -> Bool #
Eq TicketKey
Instance details Defined in Morley.Michelson.Runtime.GState Methods (==) :: TicketKey -> TicketKey -> Bool # (/=) :: TicketKey -> TicketKey -> Bool #
Eq VotingPowers
Instance details Defined in Morley.Michelson.Runtime.GState Methods (==) :: VotingPowers -> VotingPowers -> Bool # (/=) :: VotingPowers -> VotingPowers -> Bool #
Eq MText
Instance details Defined in Morley.Michelson.Text Methods (==) :: MText -> MText -> Bool # (/=) :: MText -> MText -> Bool #
Eq ExtError
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods (==) :: ExtError -> ExtError -> Bool # (/=) :: ExtError -> ExtError -> Bool #
Eq StackSize
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods (==) :: StackSize -> StackSize -> Bool # (/=) :: StackSize -> StackSize -> Bool #
Eq TcTypeError
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods (==) :: TcTypeError -> TcTypeError -> Bool # (/=) :: TcTypeError -> TcTypeError -> Bool #
Eq TopLevelType
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods (==) :: TopLevelType -> TopLevelType -> Bool # (/=) :: TopLevelType -> TopLevelType -> Bool #
Eq TypeContext
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods (==) :: TypeContext -> TypeContext -> Bool # (/=) :: TypeContext -> TypeContext -> Bool #
Eq SomeHST
Instance details Defined in Morley.Michelson.TypeCheck.Types Methods (==) :: SomeHST -> SomeHST -> Bool # (/=) :: SomeHST -> SomeHST -> Bool #
Eq MutezArithErrorType
Instance details Defined in Morley.Michelson.Typed.Arith Methods (==) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (/=) :: MutezArithErrorType -> MutezArithErrorType -> Bool #
Eq ShiftArithErrorType
Instance details Defined in Morley.Michelson.Typed.Arith Methods (==) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (/=) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool #
Eq UntypingOptions
Instance details Defined in Morley.Michelson.Typed.Convert Methods (==) :: UntypingOptions -> UntypingOptions -> Bool # (/=) :: UntypingOptions -> UntypingOptions -> Bool #
Eq ArmCoord
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: ArmCoord -> ArmCoord -> Bool # (/=) :: ArmCoord -> ArmCoord -> Bool #
Eq EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: EpAddress -> EpAddress -> Bool # (/=) :: EpAddress -> EpAddress -> Bool #
Eq ParamEpError
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: ParamEpError -> ParamEpError -> Bool # (/=) :: ParamEpError -> ParamEpError -> Bool #
Eq ParseEpAddressError
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: ParseEpAddressError -> ParseEpAddressError -> Bool # (/=) :: ParseEpAddressError -> ParseEpAddressError -> Bool #
Eq DStorageType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods (==) :: DStorageType -> DStorageType -> Bool # (/=) :: DStorageType -> DStorageType -> Bool #
Eq DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods (==) :: DType -> DType -> Bool # (/=) :: DType -> DType -> Bool #
Eq OperationHash
Instance details Defined in Morley.Michelson.Typed.Operation Methods (==) :: OperationHash -> OperationHash -> Bool # (/=) :: OperationHash -> OperationHash -> Bool #
Eq BadTypeForScope
Instance details Defined in Morley.Michelson.Typed.Scope Methods (==) :: BadTypeForScope -> BadTypeForScope -> Bool # (/=) :: BadTypeForScope -> BadTypeForScope -> Bool #
Eq T
Instance details Defined in Morley.Michelson.Typed.T Methods (==) :: T -> T -> Bool # (/=) :: T -> T -> Bool #
Eq SetDelegate
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: SetDelegate -> SetDelegate -> Bool # (/=) :: SetDelegate -> SetDelegate -> Bool #
Eq AnnotationSet
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods (==) :: AnnotationSet -> AnnotationSet -> Bool # (/=) :: AnnotationSet -> AnnotationSet -> Bool #
Eq AnyAnn
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods (==) :: AnyAnn -> AnyAnn -> Bool # (/=) :: AnyAnn -> AnyAnn -> Bool #
Eq EntriesOrder
Instance details Defined in Morley.Michelson.Untyped.Contract Methods (==) :: EntriesOrder -> EntriesOrder -> Bool # (/=) :: EntriesOrder -> EntriesOrder -> Bool #
Eq Entry
Instance details Defined in Morley.Michelson.Untyped.Contract Methods (==) :: Entry -> Entry -> Bool # (/=) :: Entry -> Entry -> Bool #
Eq EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods (==) :: EpName -> EpName -> Bool # (/=) :: EpName -> EpName -> Bool #
Eq EpNameFromRefAnnError
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods (==) :: EpNameFromRefAnnError -> EpNameFromRefAnnError -> Bool # (/=) :: EpNameFromRefAnnError -> EpNameFromRefAnnError -> Bool #
Eq HandleImplicitDefaultEp
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods (==) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool # (/=) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool #
Eq PrintComment
Instance details Defined in Morley.Michelson.Untyped.Ext Methods (==) :: PrintComment -> PrintComment -> Bool # (/=) :: PrintComment -> PrintComment -> Bool #
Eq StackRef
Instance details Defined in Morley.Michelson.Untyped.Ext Methods (==) :: StackRef -> StackRef -> Bool # (/=) :: StackRef -> StackRef -> Bool #
Eq StackTypePattern
Instance details Defined in Morley.Michelson.Untyped.Ext Methods (==) :: StackTypePattern -> StackTypePattern -> Bool # (/=) :: StackTypePattern -> StackTypePattern -> Bool #
Eq TyVar
Instance details Defined in Morley.Michelson.Untyped.Ext Methods (==) :: TyVar -> TyVar -> Bool # (/=) :: TyVar -> TyVar -> Bool #
Eq Var
Instance details Defined in Morley.Michelson.Untyped.Ext Methods (==) :: Var -> Var -> Bool # (/=) :: Var -> Var -> Bool #
Eq ExpandedOp
Instance details Defined in Morley.Michelson.Untyped.Instr Methods (==) :: ExpandedOp -> ExpandedOp -> Bool # (/=) :: ExpandedOp -> ExpandedOp -> Bool #
Eq ParameterType
Instance details Defined in Morley.Michelson.Untyped.Type Methods (==) :: ParameterType -> ParameterType -> Bool # (/=) :: ParameterType -> ParameterType -> Bool #
Eq T
Instance details Defined in Morley.Michelson.Untyped.Type Methods (==) :: T -> T -> Bool # (/=) :: T -> T -> Bool #
Eq Ty
Instance details Defined in Morley.Michelson.Untyped.Type Methods (==) :: Ty -> Ty -> Bool # (/=) :: Ty -> Ty -> Bool #
Eq InternalByteString
Instance details Defined in Morley.Michelson.Untyped.Value Methods (==) :: InternalByteString -> InternalByteString -> Bool # (/=) :: InternalByteString -> InternalByteString -> Bool #
Eq GlobalCounter
Instance details Defined in Morley.Tezos.Address Methods (==) :: GlobalCounter -> GlobalCounter -> Bool # (/=) :: GlobalCounter -> GlobalCounter -> Bool #
Eq ParseAddressError
Instance details Defined in Morley.Tezos.Address Methods (==) :: ParseAddressError -> ParseAddressError -> Bool # (/=) :: ParseAddressError -> ParseAddressError -> Bool #
Eq ParseAddressRawError
Instance details Defined in Morley.Tezos.Address Methods (==) :: ParseAddressRawError -> ParseAddressRawError -> Bool # (/=) :: ParseAddressRawError -> ParseAddressRawError -> Bool #
Eq AddressKind
Instance details Defined in Morley.Tezos.Address.Kinds Methods (==) :: AddressKind -> AddressKind -> Bool # (/=) :: AddressKind -> AddressKind -> Bool #
Eq ChainId
Instance details Defined in Morley.Tezos.Core Methods (==) :: ChainId -> ChainId -> Bool # (/=) :: ChainId -> ChainId -> Bool #
Eq Mutez
Instance details Defined in Morley.Tezos.Core Methods (==) :: Mutez -> Mutez -> Bool # (/=) :: Mutez -> Mutez -> Bool #
Eq ParseChainIdError
Instance details Defined in Morley.Tezos.Core Methods (==) :: ParseChainIdError -> ParseChainIdError -> Bool # (/=) :: ParseChainIdError -> ParseChainIdError -> Bool #
Eq Timestamp
Instance details Defined in Morley.Tezos.Core Methods (==) :: Timestamp -> Timestamp -> Bool # (/=) :: Timestamp -> Timestamp -> Bool #
Eq KeyType
Instance details Defined in Morley.Tezos.Crypto Methods (==) :: KeyType -> KeyType -> Bool # (/=) :: KeyType -> KeyType -> Bool #
Eq ParseSignatureRawError
Instance details Defined in Morley.Tezos.Crypto Methods (==) :: ParseSignatureRawError -> ParseSignatureRawError -> Bool # (/=) :: ParseSignatureRawError -> ParseSignatureRawError -> Bool #
Eq PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods (==) :: PublicKey -> PublicKey -> Bool # (/=) :: PublicKey -> PublicKey -> Bool #
Eq SecretKey
Instance details Defined in Morley.Tezos.Crypto Methods (==) :: SecretKey -> SecretKey -> Bool # (/=) :: SecretKey -> SecretKey -> Bool #
Eq Signature
Instance details Defined in Morley.Tezos.Crypto Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Eq PublicKey
Instance details Defined in Morley.Tezos.Crypto.BLS Methods (==) :: PublicKey -> PublicKey -> Bool # (/=) :: PublicKey -> PublicKey -> Bool #
Eq SecretKey
Instance details Defined in Morley.Tezos.Crypto.BLS Methods (==) :: SecretKey -> SecretKey -> Bool # (/=) :: SecretKey -> SecretKey -> Bool #
Eq Signature
Instance details Defined in Morley.Tezos.Crypto.BLS Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Eq Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (==) :: Bls12381Fr -> Bls12381Fr -> Bool # (/=) :: Bls12381Fr -> Bls12381Fr -> Bool #
Eq Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (==) :: Bls12381G1 -> Bls12381G1 -> Bool # (/=) :: Bls12381G1 -> Bls12381G1 -> Bool #
Eq Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (==) :: Bls12381G2 -> Bls12381G2 -> Bool # (/=) :: Bls12381G2 -> Bls12381G2 -> Bool #
Eq DeserializationError
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (==) :: DeserializationError -> DeserializationError -> Bool # (/=) :: DeserializationError -> DeserializationError -> Bool #
Eq PublicKey
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Methods (==) :: PublicKey -> PublicKey -> Bool # (/=) :: PublicKey -> PublicKey -> Bool #
Eq SecretKey
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Methods (==) :: SecretKey -> SecretKey -> Bool # (/=) :: SecretKey -> SecretKey -> Bool #
Eq Signature
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Eq PublicKey
Instance details Defined in Morley.Tezos.Crypto.P256 Methods (==) :: PublicKey -> PublicKey -> Bool # (/=) :: PublicKey -> PublicKey -> Bool #
Eq SecretKey
Instance details Defined in Morley.Tezos.Crypto.P256 Methods (==) :: SecretKey -> SecretKey -> Bool # (/=) :: SecretKey -> SecretKey -> Bool #
Eq Signature
Instance details Defined in Morley.Tezos.Crypto.P256 Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Eq PublicKey
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Methods (==) :: PublicKey -> PublicKey -> Bool # (/=) :: PublicKey -> PublicKey -> Bool #
Eq SecretKey
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Methods (==) :: SecretKey -> SecretKey -> Bool # (/=) :: SecretKey -> SecretKey -> Bool #
Eq Signature
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Eq Chest
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: Chest -> Chest -> Bool # (/=) :: Chest -> Chest -> Bool #
Eq ChestKey
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: ChestKey -> ChestKey -> Bool # (/=) :: ChestKey -> ChestKey -> Bool #
Eq Ciphertext
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: Ciphertext -> Ciphertext -> Bool # (/=) :: Ciphertext -> Ciphertext -> Bool #
Eq Locked
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: Locked -> Locked -> Bool # (/=) :: Locked -> Locked -> Bool #
Eq Nonce
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: Nonce -> Nonce -> Bool # (/=) :: Nonce -> Nonce -> Bool #
Eq OpeningResult
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: OpeningResult -> OpeningResult -> Bool # (/=) :: OpeningResult -> OpeningResult -> Bool #
Eq Proof
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: Proof -> Proof -> Bool # (/=) :: Proof -> Proof -> Bool #
Eq PublicModulus
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: PublicModulus -> PublicModulus -> Bool # (/=) :: PublicModulus -> PublicModulus -> Bool #
Eq TLTime
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: TLTime -> TLTime -> Bool # (/=) :: TLTime -> TLTime -> Bool #
Eq Unlocked
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: Unlocked -> Unlocked -> Bool # (/=) :: Unlocked -> Unlocked -> Bool #
Eq CryptoParseError
Instance details Defined in Morley.Tezos.Crypto.Util Methods (==) :: CryptoParseError -> CryptoParseError -> Bool # (/=) :: CryptoParseError -> CryptoParseError -> Bool #
Eq UnpackError
Instance details Defined in Morley.Util.Binary Methods (==) :: UnpackError -> UnpackError -> Bool # (/=) :: UnpackError -> UnpackError -> Bool #
Eq HexJSONByteString
Instance details Defined in Morley.Util.ByteString Methods (==) :: HexJSONByteString -> HexJSONByteString -> Bool # (/=) :: HexJSONByteString -> HexJSONByteString -> Bool #
Eq Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Mode -> Mode -> Bool # (/=) :: Mode -> Mode -> Bool #
Eq Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Style -> Style -> Bool # (/=) :: Style -> Style -> Bool #
Eq TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: TextDetails -> TextDetails -> Bool # (/=) :: TextDetails -> TextDetails -> Bool #
Eq Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods (==) :: Doc -> Doc -> Bool # (/=) :: Doc -> Doc -> Bool #
Eq ByteArray	Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.ByteArray Methods (==) :: ByteArray -> ByteArray -> Bool # (/=) :: ByteArray -> ByteArray -> Bool #
Eq StdGen
Instance details Defined in System.Random.Internal Methods (==) :: StdGen -> StdGen -> Bool # (/=) :: StdGen -> StdGen -> Bool #
Eq Scientific	Scientific numbers can be safely compared for equality. No magnitude `10^e` is calculated so there's no risk of a blowup in space or time when comparing scientific numbers coming from untrusted sources.
Instance details Defined in Data.Scientific Methods (==) :: Scientific -> Scientific -> Bool # (/=) :: Scientific -> Scientific -> Bool #
Eq Mod2
Instance details Defined in Data.Semiring Methods (==) :: Mod2 -> Mod2 -> Bool # (/=) :: Mod2 -> Mod2 -> Bool #
Eq DependencyType
Instance details Defined in Test.Tasty.Core Methods (==) :: DependencyType -> DependencyType -> Bool # (/=) :: DependencyType -> DependencyType -> Bool #
Eq Expr
Instance details Defined in Test.Tasty.Patterns.Types Methods (==) :: Expr -> Expr -> Bool # (/=) :: Expr -> Expr -> Bool #
Eq AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: AnnLookup -> AnnLookup -> Bool # (/=) :: AnnLookup -> AnnLookup -> Bool #
Eq AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: AnnTarget -> AnnTarget -> Bool # (/=) :: AnnTarget -> AnnTarget -> Bool #
Eq Bang
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Bang -> Bang -> Bool # (/=) :: Bang -> Bang -> Bool #
Eq Body
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Body -> Body -> Bool # (/=) :: Body -> Body -> Bool #
Eq Bytes
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Bytes -> Bytes -> Bool # (/=) :: Bytes -> Bytes -> Bool #
Eq Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Callconv -> Callconv -> Bool # (/=) :: Callconv -> Callconv -> Bool #
Eq Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Clause -> Clause -> Bool # (/=) :: Clause -> Clause -> Bool #
Eq Con
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Con -> Con -> Bool # (/=) :: Con -> Con -> Bool #
Eq Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Dec -> Dec -> Bool # (/=) :: Dec -> Dec -> Bool #
Eq DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivClause -> DerivClause -> Bool # (/=) :: DerivClause -> DerivClause -> Bool #
Eq DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: DerivStrategy -> DerivStrategy -> Bool # (/=) :: DerivStrategy -> DerivStrategy -> Bool #
Eq Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Exp -> Exp -> Bool # (/=) :: Exp -> Exp -> Bool #
Eq FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool #
Eq Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool #
Eq Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Foreign -> Foreign -> Bool # (/=) :: Foreign -> Foreign -> Bool #
Eq FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: FunDep -> FunDep -> Bool # (/=) :: FunDep -> FunDep -> Bool #
Eq Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Guard -> Guard -> Bool # (/=) :: Guard -> Guard -> Bool #
Eq Info
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Info -> Info -> Bool # (/=) :: Info -> Info -> Bool #
Eq InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool #
Eq Inline
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Inline -> Inline -> Bool # (/=) :: Inline -> Inline -> Bool #
Eq Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Lit -> Lit -> Bool # (/=) :: Lit -> Lit -> Bool #
Eq Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Loc -> Loc -> Bool # (/=) :: Loc -> Loc -> Bool #
Eq Match
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Match -> Match -> Bool # (/=) :: Match -> Match -> Bool #
Eq ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: ModName -> ModName -> Bool # (/=) :: ModName -> ModName -> Bool #
Eq Module
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: ModuleInfo -> ModuleInfo -> Bool # (/=) :: ModuleInfo -> ModuleInfo -> Bool #
Eq Name
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Eq NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: NameFlavour -> NameFlavour -> Bool # (/=) :: NameFlavour -> NameFlavour -> Bool #
Eq NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: NameSpace -> NameSpace -> Bool # (/=) :: NameSpace -> NameSpace -> Bool #
Eq OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: OccName -> OccName -> Bool # (/=) :: OccName -> OccName -> Bool #
Eq Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Overlap -> Overlap -> Bool # (/=) :: Overlap -> Overlap -> Bool #
Eq Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Pat -> Pat -> Bool # (/=) :: Pat -> Pat -> Bool #
Eq PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PatSynArgs -> PatSynArgs -> Bool # (/=) :: PatSynArgs -> PatSynArgs -> Bool #
Eq PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PatSynDir -> PatSynDir -> Bool # (/=) :: PatSynDir -> PatSynDir -> Bool #
Eq Phases
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Phases -> Phases -> Bool # (/=) :: Phases -> Phases -> Bool #
Eq PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: PkgName -> PkgName -> Bool # (/=) :: PkgName -> PkgName -> Bool #
Eq Pragma
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Pragma -> Pragma -> Bool # (/=) :: Pragma -> Pragma -> Bool #
Eq Range
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Range -> Range -> Bool # (/=) :: Range -> Range -> Bool #
Eq Role
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Eq RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: RuleBndr -> RuleBndr -> Bool # (/=) :: RuleBndr -> RuleBndr -> Bool #
Eq RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: RuleMatch -> RuleMatch -> Bool # (/=) :: RuleMatch -> RuleMatch -> Bool #
Eq Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Safety -> Safety -> Bool # (/=) :: Safety -> Safety -> Bool #
Eq SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq Specificity
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Specificity -> Specificity -> Bool # (/=) :: Specificity -> Specificity -> Bool #
Eq Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Stmt -> Stmt -> Bool # (/=) :: Stmt -> Stmt -> Bool #
Eq TyLit
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TyLit -> TyLit -> Bool # (/=) :: TyLit -> TyLit -> Bool #
Eq TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TySynEqn -> TySynEqn -> Bool # (/=) :: TySynEqn -> TySynEqn -> Bool #
Eq Type
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Eq TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool #
Eq CodePoint
Instance details Defined in Data.Text.Encoding Methods (==) :: CodePoint -> CodePoint -> Bool # (/=) :: CodePoint -> CodePoint -> Bool #
Eq DecoderState
Instance details Defined in Data.Text.Encoding Methods (==) :: DecoderState -> DecoderState -> Bool # (/=) :: DecoderState -> DecoderState -> Bool #
Eq UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods (==) :: UnicodeException -> UnicodeException -> Bool # (/=) :: UnicodeException -> UnicodeException -> Bool #
Eq Builder
Instance details Defined in Data.Text.Internal.Builder Methods (==) :: Builder -> Builder -> Bool # (/=) :: Builder -> Builder -> Bool #
Eq B
Instance details Defined in Data.Text.Short.Internal Methods (==) :: B -> B -> Bool # (/=) :: B -> B -> Bool #
Eq ShortText
Instance details Defined in Data.Text.Short.Internal Methods (==) :: ShortText -> ShortText -> Bool # (/=) :: ShortText -> ShortText -> Bool #
Eq ConstructorInfo
Instance details Defined in Language.Haskell.TH.Datatype Methods (==) :: ConstructorInfo -> ConstructorInfo -> Bool # (/=) :: ConstructorInfo -> ConstructorInfo -> Bool #
Eq ConstructorVariant
Instance details Defined in Language.Haskell.TH.Datatype Methods (==) :: ConstructorVariant -> ConstructorVariant -> Bool # (/=) :: ConstructorVariant -> ConstructorVariant -> Bool #
Eq DatatypeInfo
Instance details Defined in Language.Haskell.TH.Datatype Methods (==) :: DatatypeInfo -> DatatypeInfo -> Bool # (/=) :: DatatypeInfo -> DatatypeInfo -> Bool #
Eq DatatypeVariant
Instance details Defined in Language.Haskell.TH.Datatype Methods (==) :: DatatypeVariant -> DatatypeVariant -> Bool # (/=) :: DatatypeVariant -> DatatypeVariant -> Bool #
Eq FieldStrictness
Instance details Defined in Language.Haskell.TH.Datatype Methods (==) :: FieldStrictness -> FieldStrictness -> Bool # (/=) :: FieldStrictness -> FieldStrictness -> Bool #
Eq Strictness
Instance details Defined in Language.Haskell.TH.Datatype Methods (==) :: Strictness -> Strictness -> Bool # (/=) :: Strictness -> Strictness -> Bool #
Eq Unpackedness
Instance details Defined in Language.Haskell.TH.Datatype Methods (==) :: Unpackedness -> Unpackedness -> Bool # (/=) :: Unpackedness -> Unpackedness -> Bool #
Eq DClause
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DClause -> DClause -> Bool # (/=) :: DClause -> DClause -> Bool #
Eq DCon
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DCon -> DCon -> Bool # (/=) :: DCon -> DCon -> Bool #
Eq DConFields
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DConFields -> DConFields -> Bool # (/=) :: DConFields -> DConFields -> Bool #
Eq DDec
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DDec -> DDec -> Bool # (/=) :: DDec -> DDec -> Bool #
Eq DDerivClause
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DDerivClause -> DDerivClause -> Bool # (/=) :: DDerivClause -> DDerivClause -> Bool #
Eq DDerivStrategy
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DDerivStrategy -> DDerivStrategy -> Bool # (/=) :: DDerivStrategy -> DDerivStrategy -> Bool #
Eq DExp
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DExp -> DExp -> Bool # (/=) :: DExp -> DExp -> Bool #
Eq DFamilyResultSig
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DFamilyResultSig -> DFamilyResultSig -> Bool # (/=) :: DFamilyResultSig -> DFamilyResultSig -> Bool #
Eq DForallTelescope
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DForallTelescope -> DForallTelescope -> Bool # (/=) :: DForallTelescope -> DForallTelescope -> Bool #
Eq DForeign
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DForeign -> DForeign -> Bool # (/=) :: DForeign -> DForeign -> Bool #
Eq DInfo
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DInfo -> DInfo -> Bool # (/=) :: DInfo -> DInfo -> Bool #
Eq DLetDec
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DLetDec -> DLetDec -> Bool # (/=) :: DLetDec -> DLetDec -> Bool #
Eq DMatch
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DMatch -> DMatch -> Bool # (/=) :: DMatch -> DMatch -> Bool #
Eq DPat
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DPat -> DPat -> Bool # (/=) :: DPat -> DPat -> Bool #
Eq DPatSynDir
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DPatSynDir -> DPatSynDir -> Bool # (/=) :: DPatSynDir -> DPatSynDir -> Bool #
Eq DPragma
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DPragma -> DPragma -> Bool # (/=) :: DPragma -> DPragma -> Bool #
Eq DRuleBndr
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DRuleBndr -> DRuleBndr -> Bool # (/=) :: DRuleBndr -> DRuleBndr -> Bool #
Eq DTySynEqn
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DTySynEqn -> DTySynEqn -> Bool # (/=) :: DTySynEqn -> DTySynEqn -> Bool #
Eq DType
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DType -> DType -> Bool # (/=) :: DType -> DType -> Bool #
Eq DTypeFamilyHead
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DTypeFamilyHead -> DTypeFamilyHead -> Bool # (/=) :: DTypeFamilyHead -> DTypeFamilyHead -> Bool #
Eq NewOrData
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: NewOrData -> NewOrData -> Bool # (/=) :: NewOrData -> NewOrData -> Bool #
Eq DFunArgs
Instance details Defined in Language.Haskell.TH.Desugar.Core Methods (==) :: DFunArgs -> DFunArgs -> Bool # (/=) :: DFunArgs -> DFunArgs -> Bool #
Eq DTypeArg
Instance details Defined in Language.Haskell.TH.Desugar.Core Methods (==) :: DTypeArg -> DTypeArg -> Bool # (/=) :: DTypeArg -> DTypeArg -> Bool #
Eq DVisFunArg
Instance details Defined in Language.Haskell.TH.Desugar.Core Methods (==) :: DVisFunArg -> DVisFunArg -> Bool # (/=) :: DVisFunArg -> DVisFunArg -> Bool #
Eq NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (==) :: NominalDiffTime -> NominalDiffTime -> Bool # (/=) :: NominalDiffTime -> NominalDiffTime -> Bool #
Eq UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods (==) :: UTCTime -> UTCTime -> Bool # (/=) :: UTCTime -> UTCTime -> Bool #
Eq LocalTime
Instance details Defined in Data.Time.LocalTime.Internal.LocalTime Methods (==) :: LocalTime -> LocalTime -> Bool # (/=) :: LocalTime -> LocalTime -> Bool #
Eq Undefined
Instance details Defined in Universum.Debug Methods (==) :: Undefined -> Undefined -> Bool # (/=) :: Undefined -> Undefined -> Bool #
Eq UUID
Instance details Defined in Data.UUID.Types.Internal Methods (==) :: UUID -> UUID -> Bool # (/=) :: UUID -> UUID -> Bool #
Eq UnpackedUUID
Instance details Defined in Data.UUID.Types.Internal Methods (==) :: UnpackedUUID -> UnpackedUUID -> Bool # (/=) :: UnpackedUUID -> UnpackedUUID -> Bool #
Eq Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Eq Integer
Instance details Defined in GHC.Num.Integer Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Eq Natural
Instance details Defined in GHC.Num.Natural Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Eq ()
Instance details Defined in GHC.Classes Methods (==) :: () -> () -> Bool # (/=) :: () -> () -> Bool #
Eq Bool
Instance details Defined in GHC.Classes Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Eq Char
Instance details Defined in GHC.Classes Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Eq Double	Note that due to the presence of `NaN`, `Double`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Double)`False Also note that `Double`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Double)`True `>>>` `recip 0 == recip (-0 :: Double)`False
Instance details Defined in GHC.Classes Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Eq Float	Note that due to the presence of `NaN`, `Float`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Float)`False Also note that `Float`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Float)`True `>>>` `recip 0 == recip (-0 :: Float)`False
Instance details Defined in GHC.Classes Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Eq Int
Instance details Defined in GHC.Classes Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Eq Word
Instance details Defined in GHC.Classes Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
() :=> (Eq (a :- b))
Instance details Defined in Data.Constraint Methods ins :: () :- Eq (a :- b) #
() :=> (Eq (Dict a))
Instance details Defined in Data.Constraint Methods ins :: () :- Eq (Dict a) #
() :=> (Eq Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Integer #
() :=> (Eq Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Natural #
() :=> (Eq ())
Instance details Defined in Data.Constraint Methods ins :: () :- Eq () #
() :=> (Eq Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Bool #
() :=> (Eq Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Double #
() :=> (Eq Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Float #
() :=> (Eq Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Int #
() :=> (Eq Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Word #
Class () (Eq a)
Instance details Defined in Data.Constraint Methods cls :: Eq a :- () #
Eq a => Eq (First' a)
Instance details Defined in Distribution.Compat.Semigroup Methods (==) :: First' a -> First' a -> Bool # (/=) :: First' a -> First' a -> Bool #
Eq a => Eq (Last' a)
Instance details Defined in Distribution.Compat.Semigroup Methods (==) :: Last' a -> Last' a -> Bool # (/=) :: Last' a -> Last' a -> Bool #
Eq a => Eq (Option' a)
Instance details Defined in Distribution.Compat.Semigroup Methods (==) :: Option' a -> Option' a -> Bool # (/=) :: Option' a -> Option' a -> Bool #
Eq v => Eq (KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods (==) :: KeyMap v -> KeyMap v -> Bool # (/=) :: KeyMap v -> KeyMap v -> Bool #
Eq a => Eq (IResult a)
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: IResult a -> IResult a -> Bool # (/=) :: IResult a -> IResult a -> Bool #
Eq a => Eq (Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Result a -> Result a -> Bool # (/=) :: Result a -> Result a -> Bool #
Eq a => Eq (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Eq a => Eq (Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods (==) :: Complex a -> Complex a -> Bool # (/=) :: Complex a -> Complex a -> Bool #
Eq a => Eq (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Eq a => Eq (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq a => Eq (Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods (==) :: Down a -> Down a -> Bool # (/=) :: Down a -> Down a -> Bool #
Eq a => Eq (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq a => Eq (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Max a -> Max a -> Bool # (/=) :: Max a -> Max a -> Bool #
Eq a => Eq (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Min a -> Min a -> Bool # (/=) :: Min a -> Min a -> Bool #
Eq a => Eq (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Option a -> Option a -> Bool # (/=) :: Option a -> Option a -> Bool #
Eq m => Eq (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #
Eq a => Eq (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Dual a -> Dual a -> Bool # (/=) :: Dual a -> Dual a -> Bool #
Eq a => Eq (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Product a -> Product a -> Bool # (/=) :: Product a -> Product a -> Bool #
Eq a => Eq (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Sum a -> Sum a -> Bool # (/=) :: Sum a -> Sum a -> Bool #
Eq a => Eq (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Eq (TVar a)	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: TVar a -> TVar a -> Bool # (/=) :: TVar a -> TVar a -> Bool #
Eq (ForeignPtr a)	Since: base-2.1
Instance details Defined in GHC.ForeignPtr Methods (==) :: ForeignPtr a -> ForeignPtr a -> Bool # (/=) :: ForeignPtr a -> ForeignPtr a -> Bool #
Eq p => Eq (Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: Par1 p -> Par1 p -> Bool # (/=) :: Par1 p -> Par1 p -> Bool #
Eq (IORef a)	Pointer equality. Since: base-4.0.0.0
Instance details Defined in GHC.IORef Methods (==) :: IORef a -> IORef a -> Bool # (/=) :: IORef a -> IORef a -> Bool #
Eq (MVar a)	Since: base-4.1.0.0
Instance details Defined in GHC.MVar Methods (==) :: MVar a -> MVar a -> Bool # (/=) :: MVar a -> MVar a -> Bool #
Eq (FunPtr a)
Instance details Defined in GHC.Ptr Methods (==) :: FunPtr a -> FunPtr a -> Bool # (/=) :: FunPtr a -> FunPtr a -> Bool #
Eq (Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods (==) :: Ptr a -> Ptr a -> Bool # (/=) :: Ptr a -> Ptr a -> Bool #
Eq a => Eq (Ratio a)	Since: base-2.1
Instance details Defined in GHC.Real Methods (==) :: Ratio a -> Ratio a -> Bool # (/=) :: Ratio a -> Ratio a -> Bool #
Eq (Bits n)
Instance details Defined in Basement.Bits Methods (==) :: Bits n -> Bits n -> Bool # (/=) :: Bits n -> Bits n -> Bool #
(PrimType ty, Eq ty) => Eq (Block ty)
Instance details Defined in Basement.Block.Base Methods (==) :: Block ty -> Block ty -> Bool # (/=) :: Block ty -> Block ty -> Bool #
Eq (Zn n)
Instance details Defined in Basement.Bounded Methods (==) :: Zn n -> Zn n -> Bool # (/=) :: Zn n -> Zn n -> Bool #
Eq (Zn64 n)
Instance details Defined in Basement.Bounded Methods (==) :: Zn64 n -> Zn64 n -> Bool # (/=) :: Zn64 n -> Zn64 n -> Bool #
Eq a => Eq (Array a)
Instance details Defined in Basement.BoxedArray Methods (==) :: Array a -> Array a -> Bool # (/=) :: Array a -> Array a -> Bool #
Eq a => Eq (NonEmpty a)
Instance details Defined in Basement.NonEmpty Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Eq (CountOf ty)
Instance details Defined in Basement.Types.OffsetSize Methods (==) :: CountOf ty -> CountOf ty -> Bool # (/=) :: CountOf ty -> CountOf ty -> Bool #
Eq (Offset ty)
Instance details Defined in Basement.Types.OffsetSize Methods (==) :: Offset ty -> Offset ty -> Bool # (/=) :: Offset ty -> Offset ty -> Bool #
(PrimType ty, Eq ty) => Eq (UArray ty)
Instance details Defined in Basement.UArray.Base Methods (==) :: UArray ty -> UArray ty -> Bool # (/=) :: UArray ty -> UArray ty -> Bool #
Eq a => Eq (Identifier a)
Instance details Defined in Text.Casing Methods (==) :: Identifier a -> Identifier a -> Bool # (/=) :: Identifier a -> Identifier a -> Bool #
Eq (Dict a)
Instance details Defined in Data.Constraint Methods (==) :: Dict a -> Dict a -> Bool # (/=) :: Dict a -> Dict a -> Bool #
Eq vertex => Eq (SCC vertex)	Since: containers-0.5.9
Instance details Defined in Data.Graph Methods (==) :: SCC vertex -> SCC vertex -> Bool # (/=) :: SCC vertex -> SCC vertex -> Bool #
Eq a => Eq (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods (==) :: IntMap a -> IntMap a -> Bool # (/=) :: IntMap a -> IntMap a -> Bool #
Eq a => Eq (Seq a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: Seq a -> Seq a -> Bool # (/=) :: Seq a -> Seq a -> Bool #
Eq a => Eq (ViewL a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: ViewL a -> ViewL a -> Bool # (/=) :: ViewL a -> ViewL a -> Bool #
Eq a => Eq (ViewR a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: ViewR a -> ViewR a -> Bool # (/=) :: ViewR a -> ViewR a -> Bool #
Eq a => Eq (Set a)
Instance details Defined in Data.Set.Internal Methods (==) :: Set a -> Set a -> Bool # (/=) :: Set a -> Set a -> Bool #
Eq a => Eq (Tree a)
Instance details Defined in Data.Tree Methods (==) :: Tree a -> Tree a -> Bool # (/=) :: Tree a -> Tree a -> Bool #
Eq a => Eq (CryptoFailable a)
Instance details Defined in Crypto.Error.Types Methods (==) :: CryptoFailable a -> CryptoFailable a -> Bool # (/=) :: CryptoFailable a -> CryptoFailable a -> Bool #
Eq1 f => Eq (Fix f)
Instance details Defined in Data.Fix Methods (==) :: Fix f -> Fix f -> Bool # (/=) :: Fix f -> Fix f -> Bool #
(Functor f, Eq1 f) => Eq (Mu f)
Instance details Defined in Data.Fix Methods (==) :: Mu f -> Mu f -> Bool # (/=) :: Mu f -> Mu f -> Bool #
(Functor f, Eq1 f) => Eq (Nu f)
Instance details Defined in Data.Fix Methods (==) :: Nu f -> Nu f -> Bool # (/=) :: Nu f -> Nu f -> Bool #
Eq a => Eq (DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods (==) :: DNonEmpty a -> DNonEmpty a -> Bool # (/=) :: DNonEmpty a -> DNonEmpty a -> Bool #
Eq a => Eq (DList a)
Instance details Defined in Data.DList.Internal Methods (==) :: DList a -> DList a -> Bool # (/=) :: DList a -> DList a -> Bool #
Eq (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods (==) :: Binary p -> Binary p -> Bool # (/=) :: Binary p -> Binary p -> Bool #
Eq (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods (==) :: Prime p -> Prime p -> Bool # (/=) :: Prime p -> Prime p -> Bool #
Eq a => Eq (Hashed a)	Uses precomputed hash to detect inequality faster
Instance details Defined in Data.Hashable.Class Methods (==) :: Hashed a -> Hashed a -> Bool # (/=) :: Hashed a -> Hashed a -> Bool #
Eq (Affine a)
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods (==) :: Affine a -> Affine a -> Bool # (/=) :: Affine a -> Affine a -> Bool #
Eq (Point a)
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods (==) :: Point a -> Point a -> Bool # (/=) :: Point a -> Point a -> Bool #
Eq (PublicKey c)
Instance details Defined in Crypto.BLST.Internal.Types Methods (==) :: PublicKey c -> PublicKey c -> Bool # (/=) :: PublicKey c -> PublicKey c -> Bool #
Eq a => Eq (OpenChestT a)
Instance details Defined in Lorentz.Bytes Methods (==) :: OpenChestT a -> OpenChestT a -> Bool # (/=) :: OpenChestT a -> OpenChestT a -> Bool #
Eq (Packed a)
Instance details Defined in Lorentz.Bytes Methods (==) :: Packed a -> Packed a -> Bool # (/=) :: Packed a -> Packed a -> Bool #
Eq (CustomErrorRep tag) => Eq (CustomError tag)
Instance details Defined in Lorentz.Errors Methods (==) :: CustomError tag -> CustomError tag -> Bool # (/=) :: CustomError tag -> CustomError tag -> Bool #
Eq r => Eq (VoidResult r)
Instance details Defined in Lorentz.Macro Methods (==) :: VoidResult r -> VoidResult r -> Bool # (/=) :: VoidResult r -> VoidResult r -> Bool #
Eq (UParam entries)
Instance details Defined in Lorentz.UParam Methods (==) :: UParam entries -> UParam entries -> Bool # (/=) :: UParam entries -> UParam entries -> Bool #
Eq a => Eq (ReadTicket a)
Instance details Defined in Lorentz.Value Methods (==) :: ReadTicket a -> ReadTicket a -> Bool # (/=) :: ReadTicket a -> ReadTicket a -> Bool #
Eq e => Eq (ErrorFancy e)
Instance details Defined in Text.Megaparsec.Error Methods (==) :: ErrorFancy e -> ErrorFancy e -> Bool # (/=) :: ErrorFancy e -> ErrorFancy e -> Bool #
Eq t => Eq (ErrorItem t)
Instance details Defined in Text.Megaparsec.Error Methods (==) :: ErrorItem t -> ErrorItem t -> Bool # (/=) :: ErrorItem t -> ErrorItem t -> Bool #
Eq s => Eq (PosState s)
Instance details Defined in Text.Megaparsec.State Methods (==) :: PosState s -> PosState s -> Bool # (/=) :: PosState s -> PosState s -> Bool #
Eq (Mod m)
Instance details Defined in Data.Mod Methods (==) :: Mod m -> Mod m -> Bool # (/=) :: Mod m -> Mod m -> Bool #
ExpAllExtrasConstrainted Eq x => Eq (Exp x)
Instance details Defined in Morley.Micheline.Expression Methods (==) :: Exp x -> Exp x -> Bool # (/=) :: Exp x -> Exp x -> Bool #
Eq (Exp x) => Eq (MichelinePrimAp x)
Instance details Defined in Morley.Micheline.Expression Methods (==) :: MichelinePrimAp x -> MichelinePrimAp x -> Bool # (/=) :: MichelinePrimAp x -> MichelinePrimAp x -> Bool #
Eq a => Eq (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods (==) :: StringEncode a -> StringEncode a -> Bool # (/=) :: StringEncode a -> StringEncode a -> Bool #
Eq a => Eq (ViewsSetF a)
Instance details Defined in Morley.Michelson.Internal.ViewsSet Methods (==) :: ViewsSetF a -> ViewsSetF a -> Bool # (/=) :: ViewsSetF a -> ViewsSetF a -> Bool #
Eq ext => Eq (MichelsonFailed ext)
Instance details Defined in Morley.Michelson.Interpret Methods (==) :: MichelsonFailed ext -> MichelsonFailed ext -> Bool # (/=) :: MichelsonFailed ext -> MichelsonFailed ext -> Bool #
Eq ext => Eq (MichelsonFailureWithStack ext)
Instance details Defined in Morley.Michelson.Interpret Methods (==) :: MichelsonFailureWithStack ext -> MichelsonFailureWithStack ext -> Bool # (/=) :: MichelsonFailureWithStack ext -> MichelsonFailureWithStack ext -> Bool #
Eq (StkEl t)
Instance details Defined in Morley.Michelson.Interpret Methods (==) :: StkEl t -> StkEl t -> Bool # (/=) :: StkEl t -> StkEl t -> Bool #
Eq op => Eq (TcError' op)
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods (==) :: TcError' op -> TcError' op -> Bool # (/=) :: TcError' op -> TcError' op -> Bool #
Eq op => Eq (IllTypedInstr op)
Instance details Defined in Morley.Michelson.TypeCheck.TypeCheckedOp Methods (==) :: IllTypedInstr op -> IllTypedInstr op -> Bool # (/=) :: IllTypedInstr op -> IllTypedInstr op -> Bool #
Eq op => Eq (TypeCheckedOp op)
Instance details Defined in Morley.Michelson.TypeCheck.TypeCheckedOp Methods (==) :: TypeCheckedOp op -> TypeCheckedOp op -> Bool # (/=) :: TypeCheckedOp op -> TypeCheckedOp op -> Bool #
Eq (HST ts)
Instance details Defined in Morley.Michelson.TypeCheck.Types Methods (==) :: HST ts -> HST ts -> Bool # (/=) :: HST ts -> HST ts -> Bool #
(Eq r, Eq (Anns rs)) => Eq (Anns (r ': rs))
Instance details Defined in Morley.Michelson.Typed.Annotation Methods (==) :: Anns (r ': rs) -> Anns (r ': rs) -> Bool # (/=) :: Anns (r ': rs) -> Anns (r ': rs) -> Bool #
Eq (Anns ('[] :: [Type]))
Instance details Defined in Morley.Michelson.Typed.Annotation Methods (==) :: Anns '[] -> Anns '[] -> Bool # (/=) :: Anns '[] -> Anns '[] -> Bool #
Eq (Notes t)
Instance details Defined in Morley.Michelson.Typed.Annotation Methods (==) :: Notes t -> Notes t -> Bool # (/=) :: Notes t -> Notes t -> Bool #
Eq (ParamNotes t)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: ParamNotes t -> ParamNotes t -> Bool # (/=) :: ParamNotes t -> ParamNotes t -> Bool #
Eq (SomeEntrypointCallT arg)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: SomeEntrypointCallT arg -> SomeEntrypointCallT arg -> Bool # (/=) :: SomeEntrypointCallT arg -> SomeEntrypointCallT arg -> Bool #
Eq (ContractRef arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (==) :: ContractRef arg -> ContractRef arg -> Bool # (/=) :: ContractRef arg -> ContractRef arg -> Bool #
Eq arg => Eq (Ticket arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (==) :: Ticket arg -> Ticket arg -> Bool # (/=) :: Ticket arg -> Ticket arg -> Bool #
Eq (PrintComment st)
Instance details Defined in Morley.Michelson.Typed.Instr Methods (==) :: PrintComment st -> PrintComment st -> Bool # (/=) :: PrintComment st -> PrintComment st -> Bool #
Eq (StackRef st)
Instance details Defined in Morley.Michelson.Typed.Instr Methods (==) :: StackRef st -> StackRef st -> Bool # (/=) :: StackRef st -> StackRef st -> Bool #
Eq (SingT x)
Instance details Defined in Morley.Michelson.Typed.Sing Methods (==) :: SingT x -> SingT x -> Bool # (/=) :: SingT x -> SingT x -> Bool #
Eq (Operation' instr)
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: Operation' instr -> Operation' instr -> Bool # (/=) :: Operation' instr -> Operation' instr -> Bool #
(forall (i :: [T]) (o :: [T]). Eq (instr i o)) => Eq (SomeViewsSet' instr)
Instance details Defined in Morley.Michelson.Typed.View Methods (==) :: SomeViewsSet' instr -> SomeViewsSet' instr -> Bool # (/=) :: SomeViewsSet' instr -> SomeViewsSet' instr -> Bool #
Eq op => Eq (Contract' op)
Instance details Defined in Morley.Michelson.Untyped.Contract Methods (==) :: Contract' op -> Contract' op -> Bool # (/=) :: Contract' op -> Contract' op -> Bool #
Eq op => Eq (ContractBlock op)
Instance details Defined in Morley.Michelson.Untyped.Contract Methods (==) :: ContractBlock op -> ContractBlock op -> Bool # (/=) :: ContractBlock op -> ContractBlock op -> Bool #
Eq op => Eq (ExtInstrAbstract op)
Instance details Defined in Morley.Michelson.Untyped.Ext Methods (==) :: ExtInstrAbstract op -> ExtInstrAbstract op -> Bool # (/=) :: ExtInstrAbstract op -> ExtInstrAbstract op -> Bool #
Eq op => Eq (TestAssert op)
Instance details Defined in Morley.Michelson.Untyped.Ext Methods (==) :: TestAssert op -> TestAssert op -> Bool # (/=) :: TestAssert op -> TestAssert op -> Bool #
Eq op => Eq (InstrAbstract op)
Instance details Defined in Morley.Michelson.Untyped.Instr Methods (==) :: InstrAbstract op -> InstrAbstract op -> Bool # (/=) :: InstrAbstract op -> InstrAbstract op -> Bool #
Eq op => Eq (Elt op)
Instance details Defined in Morley.Michelson.Untyped.Value Methods (==) :: Elt op -> Elt op -> Bool # (/=) :: Elt op -> Elt op -> Bool #
Eq op => Eq (Value' op)
Instance details Defined in Morley.Michelson.Untyped.Value Methods (==) :: Value' op -> Value' op -> Bool # (/=) :: Value' op -> Value' op -> Bool #
Eq op => Eq (View' op)
Instance details Defined in Morley.Michelson.Untyped.View Methods (==) :: View' op -> View' op -> Bool # (/=) :: View' op -> View' op -> Bool #
Eq instr => Eq (ViewsSet instr)
Instance details Defined in Morley.Michelson.Untyped.View Methods (==) :: ViewsSet instr -> ViewsSet instr -> Bool # (/=) :: ViewsSet instr -> ViewsSet instr -> Bool #
Eq (KindedAddress kind)
Instance details Defined in Morley.Tezos.Address Methods (==) :: KindedAddress kind -> KindedAddress kind -> Bool # (/=) :: KindedAddress kind -> KindedAddress kind -> Bool #
Eq (AddressOrAlias kind)
Instance details Defined in Morley.Tezos.Address.Alias Methods (==) :: AddressOrAlias kind -> AddressOrAlias kind -> Bool # (/=) :: AddressOrAlias kind -> AddressOrAlias kind -> Bool #
Eq (Alias kind)
Instance details Defined in Morley.Tezos.Address.Alias Methods (==) :: Alias kind -> Alias kind -> Bool # (/=) :: Alias kind -> Alias kind -> Bool #
Eq (Hash kind)
Instance details Defined in Morley.Tezos.Crypto Methods (==) :: Hash kind -> Hash kind -> Bool # (/=) :: Hash kind -> Hash kind -> Bool #
Eq (HashTag kind)
Instance details Defined in Morley.Tezos.Crypto Methods (==) :: HashTag kind -> HashTag kind -> Bool # (/=) :: HashTag kind -> HashTag kind -> Bool #
Eq (Label name)
Instance details Defined in Morley.Util.Label Methods (==) :: Label name -> Label name -> Bool # (/=) :: Label name -> Label name -> Bool #
Eq a => Eq (MismatchError a)
Instance details Defined in Morley.Util.MismatchError Methods (==) :: MismatchError a -> MismatchError a -> Bool # (/=) :: MismatchError a -> MismatchError a -> Bool #
Eq (SingNat n)
Instance details Defined in Morley.Util.Peano Methods (==) :: SingNat n -> SingNat n -> Bool # (/=) :: SingNat n -> SingNat n -> Bool #
Eq (PeanoNatural n)
Instance details Defined in Morley.Util.PeanoNatural Methods (==) :: PeanoNatural n -> PeanoNatural n -> Bool # (/=) :: PeanoNatural n -> PeanoNatural n -> Bool #
Eq a => Eq (All a)
Instance details Defined in Morley.Prelude.Boolean Methods (==) :: All a -> All a -> Bool # (/=) :: All a -> All a -> Bool #
Eq a => Eq (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods (==) :: Any a -> Any a -> Bool # (/=) :: Any a -> Any a -> Bool #
Eq a => Eq (AnnotDetails a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: AnnotDetails a -> AnnotDetails a -> Bool # (/=) :: AnnotDetails a -> AnnotDetails a -> Bool #
Eq (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Doc a -> Doc a -> Bool # (/=) :: Doc a -> Doc a -> Bool #
Eq a => Eq (Span a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (==) :: Span a -> Span a -> Bool # (/=) :: Span a -> Span a -> Bool #
Eq a => Eq (Array a)
Instance details Defined in Data.Primitive.Array Methods (==) :: Array a -> Array a -> Bool # (/=) :: Array a -> Array a -> Bool #
Eq (MutableByteArray s)
Instance details Defined in Data.Primitive.ByteArray Methods (==) :: MutableByteArray s -> MutableByteArray s -> Bool # (/=) :: MutableByteArray s -> MutableByteArray s -> Bool #
(Eq a, Prim a) => Eq (PrimArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods (==) :: PrimArray a -> PrimArray a -> Bool # (/=) :: PrimArray a -> PrimArray a -> Bool #
Eq a => Eq (SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods (==) :: SmallArray a -> SmallArray a -> Bool # (/=) :: SmallArray a -> SmallArray a -> Bool #
Eq g => Eq (StateGen g)
Instance details Defined in System.Random.Internal Methods (==) :: StateGen g -> StateGen g -> Bool # (/=) :: StateGen g -> StateGen g -> Bool #
Eq g => Eq (AtomicGen g)
Instance details Defined in System.Random.Stateful Methods (==) :: AtomicGen g -> AtomicGen g -> Bool # (/=) :: AtomicGen g -> AtomicGen g -> Bool #
Eq g => Eq (IOGen g)
Instance details Defined in System.Random.Stateful Methods (==) :: IOGen g -> IOGen g -> Bool # (/=) :: IOGen g -> IOGen g -> Bool #
Eq g => Eq (STGen g)
Instance details Defined in System.Random.Stateful Methods (==) :: STGen g -> STGen g -> Bool # (/=) :: STGen g -> STGen g -> Bool #
Eq g => Eq (TGen g)
Instance details Defined in System.Random.Stateful Methods (==) :: TGen g -> TGen g -> Bool # (/=) :: TGen g -> TGen g -> Bool #
Eq a => Eq (Add a)
Instance details Defined in Data.Semiring Methods (==) :: Add a -> Add a -> Bool # (/=) :: Add a -> Add a -> Bool #
Eq (IntSetOf a)
Instance details Defined in Data.Semiring Methods (==) :: IntSetOf a -> IntSetOf a -> Bool # (/=) :: IntSetOf a -> IntSetOf a -> Bool #
Eq a => Eq (Mul a)
Instance details Defined in Data.Semiring Methods (==) :: Mul a -> Mul a -> Bool # (/=) :: Mul a -> Mul a -> Bool #
Eq a => Eq (WrappedNum a)
Instance details Defined in Data.Semiring Methods (==) :: WrappedNum a -> WrappedNum a -> Bool # (/=) :: WrappedNum a -> WrappedNum a -> Bool #
Eq a => Eq (Maybe a)
Instance details Defined in Data.Strict.Maybe Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Eq flag => Eq (TyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Syntax Methods (==) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (/=) :: TyVarBndr flag -> TyVarBndr flag -> Bool #
Eq flag => Eq (DTyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods (==) :: DTyVarBndr flag -> DTyVarBndr flag -> Bool # (/=) :: DTyVarBndr flag -> DTyVarBndr flag -> Bool #
Eq a => Eq (HashSet a)	Note that, in the presence of hash collisions, equal `HashSet`s may behave differently, i.e. substitutivity may be violated: `>>>` `data D = A \| B deriving (Eq, Show)``>>>` `instance Hashable D where hashWithSalt salt _d = salt` `>>>` `x = fromList [A, B]``>>>` `y = fromList [B, A]` `>>>` `x == y`True `>>>` `toList x`[A,B] `>>>` `toList y`[B,A] In general, the lack of substitutivity can be observed with any function that depends on the key ordering, such as folds and traversals.
Instance details Defined in Data.HashSet.Internal Methods (==) :: HashSet a -> HashSet a -> Bool # (/=) :: HashSet a -> HashSet a -> Bool #
Eq a => Eq (Vector a)
Instance details Defined in Data.Vector Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
(Prim a, Eq a) => Eq (Vector a)
Instance details Defined in Data.Vector.Primitive Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
(Storable a, Eq a) => Eq (Vector a)
Instance details Defined in Data.Vector.Storable Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
Eq t => Eq (ElField '(s, t))
Instance details Defined in Data.Vinyl.Functor Methods (==) :: ElField '(s, t) -> ElField '(s, t) -> Bool # (/=) :: ElField '(s, t) -> ElField '(s, t) -> Bool #
Eq a => Eq (Identity a)
Instance details Defined in Data.Vinyl.Functor Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Eq a => Eq (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Eq a => Eq [a]
Instance details Defined in GHC.Classes Methods (==) :: [a] -> [a] -> Bool # (/=) :: [a] -> [a] -> Bool #
(Eq a) :=> (Eq (Complex a))
Instance details Defined in Data.Constraint Methods ins :: Eq a :- Eq (Complex a) #
(Eq a) :=> (Eq (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Eq a :- Eq (Const a b) #
(Eq a) :=> (Eq (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Eq a :- Eq (Identity a) #
(Eq a) :=> (Eq (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Eq a :- Eq (Ratio a) #
(Eq a) :=> (Eq (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Eq a :- Eq (Maybe a) #
(Eq a) :=> (Eq [a])
Instance details Defined in Data.Constraint Methods ins :: Eq a :- Eq [a] #
Class (Eq a) (Bits a)
Instance details Defined in Data.Constraint Methods cls :: Bits a :- Eq a #
Class (Eq a) (Ord a)
Instance details Defined in Data.Constraint Methods cls :: Ord a :- Eq a #
Eq a => Eq (OddWord a n)
Instance details Defined in Data.Word.Odd Methods (==) :: OddWord a n -> OddWord a n -> Bool # (/=) :: OddWord a n -> OddWord a n -> Bool #
(Eq a, Eq b) => Eq (Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
Eq (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods (==) :: Fixed a -> Fixed a -> Bool # (/=) :: Fixed a -> Fixed a -> Bool #
Eq (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (==) :: Proxy s -> Proxy s -> Bool # (/=) :: Proxy s -> Proxy s -> Bool #
Eq a => Eq (Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Arg a b -> Arg a b -> Bool # (/=) :: Arg a b -> Arg a b -> Bool #
Eq (TypeRep a)	Since: base-2.1
Instance details Defined in Data.Typeable.Internal Methods (==) :: TypeRep a -> TypeRep a -> Bool # (/=) :: TypeRep a -> TypeRep a -> Bool #
Eq (U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: U1 p -> U1 p -> Bool # (/=) :: U1 p -> U1 p -> Bool #
Eq (V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: V1 p -> V1 p -> Bool # (/=) :: V1 p -> V1 p -> Bool #
Eq a => Eq (ListN n a)
Instance details Defined in Basement.Sized.List Methods (==) :: ListN n a -> ListN n a -> Bool # (/=) :: ListN n a -> ListN n a -> Bool #
(Eq a, Eq b) => Eq (Bimap a b)
Instance details Defined in Data.Bimap Methods (==) :: Bimap a b -> Bimap a b -> Bool # (/=) :: Bimap a b -> Bimap a b -> Bool #
Eq (a :- b)	Assumes `IncoherentInstances` doesn't exist.
Instance details Defined in Data.Constraint Methods (==) :: (a :- b) -> (a :- b) -> Bool # (/=) :: (a :- b) -> (a :- b) -> Bool #
(Eq k, Eq a) => Eq (Map k a)
Instance details Defined in Data.Map.Internal Methods (==) :: Map k a -> Map k a -> Bool # (/=) :: Map k a -> Map k a -> Bool #
(Eq1 f, Eq a) => Eq (Cofree f a)
Instance details Defined in Control.Comonad.Cofree Methods (==) :: Cofree f a -> Cofree f a -> Bool # (/=) :: Cofree f a -> Cofree f a -> Bool #
(Eq1 f, Eq a) => Eq (Free f a)
Instance details Defined in Control.Monad.Free Methods (==) :: Free f a -> Free f a -> Bool # (/=) :: Free f a -> Free f a -> Bool #
Eq k => Eq (Extension p k)
Instance details Defined in Data.Field.Galois.Extension Methods (==) :: Extension p k -> Extension p k -> Bool # (/=) :: Extension p k -> Extension p k -> Bool #
Eq k => Eq (RootsOfUnity n k)
Instance details Defined in Data.Field.Galois.Unity Methods (==) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # (/=) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool #
Eq (Signature c m)
Instance details Defined in Crypto.BLST.Internal.Types Methods (==) :: Signature c m -> Signature c m -> Bool # (/=) :: Signature c m -> Signature c m -> Bool #
(Eq1 f, Eq a) => Eq (Yoneda f a)
Instance details Defined in Data.Functor.Yoneda Methods (==) :: Yoneda f a -> Yoneda f a -> Bool # (/=) :: Yoneda f a -> Yoneda f a -> Bool #
Eq (TAddress p vd)
Instance details Defined in Lorentz.Address Methods (==) :: TAddress p vd -> TAddress p vd -> Bool # (/=) :: TAddress p vd -> TAddress p vd -> Bool #
Eq (inp :-> out)
Instance details Defined in Lorentz.Base Methods (==) :: (inp :-> out) -> (inp :-> out) -> Bool # (/=) :: (inp :-> out) -> (inp :-> out) -> Bool #
Eq (ContractCode cp st)
Instance details Defined in Lorentz.Base Methods (==) :: ContractCode cp st -> ContractCode cp st -> Bool # (/=) :: ContractCode cp st -> ContractCode cp st -> Bool #
Eq (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods (==) :: Hash alg a -> Hash alg a -> Bool # (/=) :: Hash alg a -> Hash alg a -> Bool #
Eq (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Methods (==) :: WrappedLambda i o -> WrappedLambda i o -> Bool # (/=) :: WrappedLambda i o -> WrappedLambda i o -> Bool #
Eq a => Eq (View_ a r)
Instance details Defined in Lorentz.Macro Methods (==) :: View_ a r -> View_ a r -> Bool # (/=) :: View_ a r -> View_ a r -> Bool #
(Eq a, Eq b) => Eq (ZippedStackRepr a b)
Instance details Defined in Lorentz.Zip Methods (==) :: ZippedStackRepr a b -> ZippedStackRepr a b -> Bool # (/=) :: ZippedStackRepr a b -> ZippedStackRepr a b -> Bool #
(Eq (Token s), Eq e) => Eq (ParseError s e)
Instance details Defined in Text.Megaparsec.Error Methods (==) :: ParseError s e -> ParseError s e -> Bool # (/=) :: ParseError s e -> ParseError s e -> Bool #
(Eq s, Eq (Token s), Eq e) => Eq (ParseErrorBundle s e)
Instance details Defined in Text.Megaparsec.Error Methods (==) :: ParseErrorBundle s e -> ParseErrorBundle s e -> Bool # (/=) :: ParseErrorBundle s e -> ParseErrorBundle s e -> Bool #
(Eq (ParseError s e), Eq s) => Eq (State s e)
Instance details Defined in Text.Megaparsec.State Methods (==) :: State s e -> State s e -> Bool # (/=) :: State s e -> State s e -> Bool #
(Eq n, Eq m) => Eq (ArithError n m)
Instance details Defined in Morley.Michelson.Typed.Arith Methods (==) :: ArithError n m -> ArithError n m -> Bool # (/=) :: ArithError n m -> ArithError n m -> Bool #
Eq (EntrypointCallT param arg)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: EntrypointCallT param arg -> EntrypointCallT param arg -> Bool # (/=) :: EntrypointCallT param arg -> EntrypointCallT param arg -> Bool #
Eq (EpLiftSequence arg param)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: EpLiftSequence arg param -> EpLiftSequence arg param -> Bool # (/=) :: EpLiftSequence arg param -> EpLiftSequence arg param -> Bool #
Eq (Emit instr t)
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: Emit instr t -> Emit instr t -> Bool # (/=) :: Emit instr t -> Emit instr t -> Bool #
Eq (TransferTokens instr p)
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: TransferTokens instr p -> TransferTokens instr p -> Bool # (/=) :: TransferTokens instr p -> TransferTokens instr p -> Bool #
Eq (Value' instr t)
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: Value' instr t -> Value' instr t -> Bool # (/=) :: Value' instr t -> Value' instr t -> Bool #
(forall (arg :: T) (ret :: T). Eq (ViewCode' instr arg st ret)) => Eq (SomeView' instr st)
Instance details Defined in Morley.Michelson.Typed.View Methods (==) :: SomeView' instr st -> SomeView' instr st -> Bool # (/=) :: SomeView' instr st -> SomeView' instr st -> Bool #
(forall (i :: [T]) (o :: [T]). Eq (instr i o)) => Eq (ViewsSet' instr st)
Instance details Defined in Morley.Michelson.Typed.View Methods (==) :: ViewsSet' instr st -> ViewsSet' instr st -> Bool # (/=) :: ViewsSet' instr st -> ViewsSet' instr st -> Bool #
Eq (Annotation tag)
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods (==) :: Annotation tag -> Annotation tag -> Bool # (/=) :: Annotation tag -> Annotation tag -> Bool #
(Eq a, Eq b) => Eq (Bimap a b)
Instance details Defined in Morley.Util.Bimap Methods (==) :: Bimap a b -> Bimap a b -> Bool # (/=) :: Bimap a b -> Bimap a b -> Bool #
Eq a => Eq (SizedList' n a)
Instance details Defined in Morley.Util.SizedList Methods (==) :: SizedList' n a -> SizedList' n a -> Bool # (/=) :: SizedList' n a -> SizedList' n a -> Bool #
Eq (v a) => Eq (Poly v a)
Instance details Defined in Data.Poly.Internal.Dense Methods (==) :: Poly v a -> Poly v a -> Bool # (/=) :: Poly v a -> Poly v a -> Bool #
Eq (MutableArray s a)
Instance details Defined in Data.Primitive.Array Methods (==) :: MutableArray s a -> MutableArray s a -> Bool # (/=) :: MutableArray s a -> MutableArray s a -> Bool #
Eq (MutablePrimArray s a)
Instance details Defined in Data.Primitive.PrimArray Methods (==) :: MutablePrimArray s a -> MutablePrimArray s a -> Bool # (/=) :: MutablePrimArray s a -> MutablePrimArray s a -> Bool #
Eq (SmallMutableArray s a)
Instance details Defined in Data.Primitive.SmallArray Methods (==) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool # (/=) :: SmallMutableArray s a -> SmallMutableArray s a -> Bool #
Eq v => Eq (IntMapOf k v)
Instance details Defined in Data.Semiring Methods (==) :: IntMapOf k v -> IntMapOf k v -> Bool # (/=) :: IntMapOf k v -> IntMapOf k v -> Bool #
(Eq a, Eq b) => Eq (Either a b)
Instance details Defined in Data.Strict.Either Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
(Eq a, Eq b) => Eq (These a b)
Instance details Defined in Data.Strict.These Methods (==) :: These a b -> These a b -> Bool # (/=) :: These a b -> These a b -> Bool #
(Eq a, Eq b) => Eq (Pair a b)
Instance details Defined in Data.Strict.Tuple Methods (==) :: Pair a b -> Pair a b -> Bool # (/=) :: Pair a b -> Pair a b -> Bool #
(Eq a, Eq b) => Eq (These a b)
Instance details Defined in Data.These Methods (==) :: These a b -> These a b -> Bool # (/=) :: These a b -> These a b -> Bool #
(Eq1 m, Eq a) => Eq (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods (==) :: MaybeT m a -> MaybeT m a -> Bool # (/=) :: MaybeT m a -> MaybeT m a -> Bool #
(Eq k, Eq v) => Eq (HashMap k v)	Note that, in the presence of hash collisions, equal `HashMap`s may behave differently, i.e. substitutivity may be violated: `>>>` `data D = A \| B deriving (Eq, Show)``>>>` `instance Hashable D where hashWithSalt salt _d = salt` `>>>` `x = fromList [(A,1), (B,2)]``>>>` `y = fromList [(B,2), (A,1)]` `>>>` `x == y`True `>>>` `toList x`[(A,1),(B,2)] `>>>` `toList y`[(B,2),(A,1)] In general, the lack of substitutivity can be observed with any function that depends on the key ordering, such as folds and traversals.
Instance details Defined in Data.HashMap.Internal Methods (==) :: HashMap k v -> HashMap k v -> Bool # (/=) :: HashMap k v -> HashMap k v -> Bool #
(Eq k, Eq v) => Eq (Leaf k v)
Instance details Defined in Data.HashMap.Internal Methods (==) :: Leaf k v -> Leaf k v -> Bool # (/=) :: Leaf k v -> Leaf k v -> Bool #
(Eq a, Eq b) => Eq (a, b)
Instance details Defined in GHC.Classes Methods (==) :: (a, b) -> (a, b) -> Bool # (/=) :: (a, b) -> (a, b) -> Bool #
(Eq a, Eq b) :=> (Eq (Either a b))
Instance details Defined in Data.Constraint Methods ins :: (Eq a, Eq b) :- Eq (Either a b) #
(Eq a, Eq b) :=> (Eq (a, b))
Instance details Defined in Data.Constraint Methods ins :: (Eq a, Eq b) :- Eq (a, b) #
Eq a => Eq (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (==) :: Const a b -> Const a b -> Bool # (/=) :: Const a b -> Const a b -> Bool #
Eq (f a) => Eq (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (==) :: Ap f a -> Ap f a -> Bool # (/=) :: Ap f a -> Ap f a -> Bool #
Eq (f a) => Eq (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Alt f a -> Alt f a -> Bool # (/=) :: Alt f a -> Alt f a -> Bool #
Eq (Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods (==) :: Coercion a b -> Coercion a b -> Bool # (/=) :: Coercion a b -> Coercion a b -> Bool #
Eq (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods (==) :: (a :~: b) -> (a :~: b) -> Bool # (/=) :: (a :~: b) -> (a :~: b) -> Bool #
Eq (f p) => Eq (Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: Rec1 f p -> Rec1 f p -> Bool # (/=) :: Rec1 f p -> Rec1 f p -> Bool #
Eq (URec (Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #
Eq (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Eq (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Eq (URec Float p)
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Eq (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Eq (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Eq (p (Fix p a) a) => Eq (Fix p a)
Instance details Defined in Data.Bifunctor.Fix Methods (==) :: Fix p a -> Fix p a -> Bool # (/=) :: Fix p a -> Fix p a -> Bool #
Eq (p a a) => Eq (Join p a)
Instance details Defined in Data.Bifunctor.Join Methods (==) :: Join p a -> Join p a -> Bool # (/=) :: Join p a -> Join p a -> Bool #
(Eq a, Eq (f b)) => Eq (CofreeF f a b)
Instance details Defined in Control.Comonad.Trans.Cofree Methods (==) :: CofreeF f a b -> CofreeF f a b -> Bool # (/=) :: CofreeF f a b -> CofreeF f a b -> Bool #
Eq (w (CofreeF f a (CofreeT f w a))) => Eq (CofreeT f w a)
Instance details Defined in Control.Comonad.Trans.Cofree Methods (==) :: CofreeT f w a -> CofreeT f w a -> Bool # (/=) :: CofreeT f w a -> CofreeT f w a -> Bool #
(Eq a, Eq (f b)) => Eq (FreeF f a b)
Instance details Defined in Control.Monad.Trans.Free Methods (==) :: FreeF f a b -> FreeF f a b -> Bool # (/=) :: FreeF f a b -> FreeF f a b -> Bool #
(Eq1 f, Eq1 m, Eq a) => Eq (FreeT f m a)
Instance details Defined in Control.Monad.Trans.Free Methods (==) :: FreeT f m a -> FreeT f m a -> Bool # (/=) :: FreeT f m a -> FreeT f m a -> Bool #
Eq (Contract cp st vd)
Instance details Defined in Lorentz.Base Methods (==) :: Contract cp st vd -> Contract cp st vd -> Bool # (/=) :: Contract cp st vd -> Contract cp st vd -> Bool #
(forall (i :: [T]) (o :: [T]). Eq (instr i o)) => Eq (Contract' instr cp st)
Instance details Defined in Morley.Michelson.Typed.Contract Methods (==) :: Contract' instr cp st -> Contract' instr cp st -> Bool # (/=) :: Contract' instr cp st -> Contract' instr cp st -> Bool #
Eq (instr (ContractInp cp st) (ContractOut st)) => Eq (ContractCode' instr cp st)
Instance details Defined in Morley.Michelson.Typed.Contract Methods (==) :: ContractCode' instr cp st -> ContractCode' instr cp st -> Bool # (/=) :: ContractCode' instr cp st -> ContractCode' instr cp st -> Bool #
Eq (CreateContract instr cp st)
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: CreateContract instr cp st -> CreateContract instr cp st -> Bool # (/=) :: CreateContract instr cp st -> CreateContract instr cp st -> Bool #
Eq (LambdaCode' instr inp out)
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: LambdaCode' instr inp out -> LambdaCode' instr inp out -> Bool # (/=) :: LambdaCode' instr inp out -> LambdaCode' instr inp out -> Bool #
GEq f => Eq (Constrained c f)
Instance details Defined in Morley.Util.Constrained Methods (==) :: Constrained c f -> Constrained c f -> Bool # (/=) :: Constrained c f -> Constrained c f -> Bool #
Eq b => Eq (Tagged s b)
Instance details Defined in Data.Tagged Methods (==) :: Tagged s b -> Tagged s b -> Bool # (/=) :: Tagged s b -> Tagged s b -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (These1 f g a)
Instance details Defined in Data.Functor.These Methods (==) :: These1 f g a -> These1 f g a -> Bool # (/=) :: These1 f g a -> These1 f g a -> Bool #
(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a)
Instance details Defined in Control.Monad.Trans.Error Methods (==) :: ErrorT e m a -> ErrorT e m a -> Bool # (/=) :: ErrorT e m a -> ErrorT e m a -> Bool #
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods (==) :: ExceptT e m a -> ExceptT e m a -> Bool # (/=) :: ExceptT e m a -> ExceptT e m a -> Bool #
(Eq1 f, Eq a) => Eq (IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods (==) :: IdentityT f a -> IdentityT f a -> Bool # (/=) :: IdentityT f a -> IdentityT f a -> Bool #
(RPureConstrained (IndexableField rs) rs, RecApplicative rs, Eq (Rec f rs)) => Eq (ARec f rs)
Instance details Defined in Data.Vinyl.ARec.Internal Methods (==) :: ARec f rs -> ARec f rs -> Bool # (/=) :: ARec f rs -> ARec f rs -> Bool #
(Eq (f r), Eq (Rec f rs)) => Eq (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Methods (==) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (/=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool #
Eq (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Methods (==) :: Rec f '[] -> Rec f '[] -> Bool # (/=) :: Rec f '[] -> Rec f '[] -> Bool #
Eq a => Eq (Const a b)
Instance details Defined in Data.Vinyl.Functor Methods (==) :: Const a b -> Const a b -> Bool # (/=) :: Const a b -> Const a b -> Bool #
(Eq a, Eq b, Eq c) => Eq (a, b, c)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c) -> (a, b, c) -> Bool # (/=) :: (a, b, c) -> (a, b, c) -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods (==) :: Product f g a -> Product f g a -> Bool # (/=) :: Product f g a -> Product f g a -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods (==) :: Sum f g a -> Sum f g a -> Bool # (/=) :: Sum f g a -> Sum f g a -> Bool #
Eq (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods (==) :: (a :~~: b) -> (a :~~: b) -> Bool # (/=) :: (a :~~: b) -> (a :~~: b) -> Bool #
(Eq (f p), Eq (g p)) => Eq ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :: g) p -> (f :: g) p -> Bool # (/=) :: (f :: g) p -> (f :: g) p -> Bool #
(Eq (f p), Eq (g p)) => Eq ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :+: g) p -> (f :+: g) p -> Bool # (/=) :: (f :+: g) p -> (f :+: g) p -> Bool #
Eq c => Eq (K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: K1 i c p -> K1 i c p -> Bool # (/=) :: K1 i c p -> K1 i c p -> Bool #
Eq (instr i o) => Eq (RemFail instr i o)	Ignoring distinction between constructors here, comparing only semantics.
Instance details Defined in Morley.Michelson.Typed.Value Methods (==) :: RemFail instr i o -> RemFail instr i o -> Bool # (/=) :: RemFail instr i o -> RemFail instr i o -> Bool #
Eq (ViewCode' instr arg st ret) => Eq (View' instr arg st ret)
Instance details Defined in Morley.Michelson.Typed.View Methods (==) :: View' instr arg st ret -> View' instr arg st ret -> Bool # (/=) :: View' instr arg st ret -> View' instr arg st ret -> Bool #
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (/=) :: (a, b, c, d) -> (a, b, c, d) -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods (==) :: Compose f g a -> Compose f g a -> Bool # (/=) :: Compose f g a -> Compose f g a -> Bool #
Eq (f (g p)) => Eq ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :.: g) p -> (f :.: g) p -> Bool # (/=) :: (f :.: g) p -> (f :.: g) p -> Bool #
Eq (f p) => Eq (M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: M1 i c f p -> M1 i c f p -> Bool # (/=) :: M1 i c f p -> M1 i c f p -> Bool #
Eq (f a) => Eq (Clown f a b)
Instance details Defined in Data.Bifunctor.Clown Methods (==) :: Clown f a b -> Clown f a b -> Bool # (/=) :: Clown f a b -> Clown f a b -> Bool #
Eq (p b a) => Eq (Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Methods (==) :: Flip p a b -> Flip p a b -> Bool # (/=) :: Flip p a b -> Flip p a b -> Bool #
Eq (g b) => Eq (Joker g a b)
Instance details Defined in Data.Bifunctor.Joker Methods (==) :: Joker g a b -> Joker g a b -> Bool # (/=) :: Joker g a b -> Joker g a b -> Bool #
Eq (p a b) => Eq (WrappedBifunctor p a b)
Instance details Defined in Data.Bifunctor.Wrapped Methods (==) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # (/=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (/=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #
(Eq (f a b), Eq (g a b)) => Eq (Product f g a b)
Instance details Defined in Data.Bifunctor.Product Methods (==) :: Product f g a b -> Product f g a b -> Bool # (/=) :: Product f g a b -> Product f g a b -> Bool #
(Eq (p a b), Eq (q a b)) => Eq (Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Methods (==) :: Sum p q a b -> Sum p q a b -> Bool # (/=) :: Sum p q a b -> Sum p q a b -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (/=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool #
Eq (f (p a b)) => Eq (Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Methods (==) :: Tannen f p a b -> Tannen f p a b -> Bool # (/=) :: Tannen f p a b -> Tannen f p a b -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (/=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (/=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool #
Eq (p (f a) (g b)) => Eq (Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Methods (==) :: Biff p f g a b -> Biff p f g a b -> Bool # (/=) :: Biff p f g a b -> Biff p f g a b -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
Instance details Defined in GHC.Classes Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool #

class Fractional a => Floating a where #

Trigonometric and hyperbolic functions and related functions.

The Haskell Report defines no laws for Floating. However, (+), (*) and exp are customarily expected to define an exponential field and have the following properties:

exp (a + b) = exp a * exp b
exp (fromInteger 0) = fromInteger 1

Minimal complete definition

pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh

Methods

pi :: a #

exp :: a -> a #

sqrt :: a -> a #

(**) :: a -> a -> a infixr 8 #

logBase :: a -> a -> a #

sin :: a -> a #

cos :: a -> a #

tan :: a -> a #

asin :: a -> a #

acos :: a -> a #

atan :: a -> a #

sinh :: a -> a #

cosh :: a -> a #

tanh :: a -> a #

asinh :: a -> a #

acosh :: a -> a #

atanh :: a -> a #

Instances

Instances details

Floating Double	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Double # exp :: Double -> Double # log :: Double -> Double # sqrt :: Double -> Double # (**) :: Double -> Double -> Double # logBase :: Double -> Double -> Double # sin :: Double -> Double # cos :: Double -> Double # tan :: Double -> Double # asin :: Double -> Double # acos :: Double -> Double # atan :: Double -> Double # sinh :: Double -> Double # cosh :: Double -> Double # tanh :: Double -> Double # asinh :: Double -> Double # acosh :: Double -> Double # atanh :: Double -> Double # log1p :: Double -> Double # expm1 :: Double -> Double # log1pexp :: Double -> Double # log1mexp :: Double -> Double #
Floating Float	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Float # exp :: Float -> Float # log :: Float -> Float # sqrt :: Float -> Float # (**) :: Float -> Float -> Float # logBase :: Float -> Float -> Float # sin :: Float -> Float # cos :: Float -> Float # tan :: Float -> Float # asin :: Float -> Float # acos :: Float -> Float # atan :: Float -> Float # sinh :: Float -> Float # cosh :: Float -> Float # tanh :: Float -> Float # asinh :: Float -> Float # acosh :: Float -> Float # atanh :: Float -> Float # log1p :: Float -> Float # expm1 :: Float -> Float # log1pexp :: Float -> Float # log1mexp :: Float -> Float #
() :=> (Floating Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Floating Double #
() :=> (Floating Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Floating Float #
RealFloat a => Floating (Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods pi :: Complex a # exp :: Complex a -> Complex a # log :: Complex a -> Complex a # sqrt :: Complex a -> Complex a # (**) :: Complex a -> Complex a -> Complex a # logBase :: Complex a -> Complex a -> Complex a # sin :: Complex a -> Complex a # cos :: Complex a -> Complex a # tan :: Complex a -> Complex a # asin :: Complex a -> Complex a # acos :: Complex a -> Complex a # atan :: Complex a -> Complex a # sinh :: Complex a -> Complex a # cosh :: Complex a -> Complex a # tanh :: Complex a -> Complex a # asinh :: Complex a -> Complex a # acosh :: Complex a -> Complex a # atanh :: Complex a -> Complex a # log1p :: Complex a -> Complex a # expm1 :: Complex a -> Complex a # log1pexp :: Complex a -> Complex a # log1mexp :: Complex a -> Complex a #
Floating a => Floating (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods pi :: Identity a # exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a # expm1 :: Identity a -> Identity a # log1pexp :: Identity a -> Identity a # log1mexp :: Identity a -> Identity a #
Floating a => Floating (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods pi :: Down a # exp :: Down a -> Down a # log :: Down a -> Down a # sqrt :: Down a -> Down a # (**) :: Down a -> Down a -> Down a # logBase :: Down a -> Down a -> Down a # sin :: Down a -> Down a # cos :: Down a -> Down a # tan :: Down a -> Down a # asin :: Down a -> Down a # acos :: Down a -> Down a # atan :: Down a -> Down a # sinh :: Down a -> Down a # cosh :: Down a -> Down a # tanh :: Down a -> Down a # asinh :: Down a -> Down a # acosh :: Down a -> Down a # atanh :: Down a -> Down a # log1p :: Down a -> Down a # expm1 :: Down a -> Down a # log1pexp :: Down a -> Down a # log1mexp :: Down a -> Down a #
(Floating t, KnownSymbol s) => Floating (ElField '(s, t))
Instance details Defined in Data.Vinyl.Functor Methods pi :: ElField '(s, t) # exp :: ElField '(s, t) -> ElField '(s, t) # log :: ElField '(s, t) -> ElField '(s, t) # sqrt :: ElField '(s, t) -> ElField '(s, t) # (**) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # logBase :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # sin :: ElField '(s, t) -> ElField '(s, t) # cos :: ElField '(s, t) -> ElField '(s, t) # tan :: ElField '(s, t) -> ElField '(s, t) # asin :: ElField '(s, t) -> ElField '(s, t) # acos :: ElField '(s, t) -> ElField '(s, t) # atan :: ElField '(s, t) -> ElField '(s, t) # sinh :: ElField '(s, t) -> ElField '(s, t) # cosh :: ElField '(s, t) -> ElField '(s, t) # tanh :: ElField '(s, t) -> ElField '(s, t) # asinh :: ElField '(s, t) -> ElField '(s, t) # acosh :: ElField '(s, t) -> ElField '(s, t) # atanh :: ElField '(s, t) -> ElField '(s, t) # log1p :: ElField '(s, t) -> ElField '(s, t) # expm1 :: ElField '(s, t) -> ElField '(s, t) # log1pexp :: ElField '(s, t) -> ElField '(s, t) # log1mexp :: ElField '(s, t) -> ElField '(s, t) #
(Floating a) :=> (Floating (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Floating a :- Floating (Const a b) #
(Floating a) :=> (Floating (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Floating a :- Floating (Identity a) #
(RealFloat a) :=> (Floating (Complex a))
Instance details Defined in Data.Constraint Methods ins :: RealFloat a :- Floating (Complex a) #
Class (Fractional a) (Floating a)
Instance details Defined in Data.Constraint Methods cls :: Floating a :- Fractional a #
Class (RealFrac a, Floating a) (RealFloat a)
Instance details Defined in Data.Constraint Methods cls :: RealFloat a :- (RealFrac a, Floating a) #
Floating a => Floating (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods pi :: Const a b # exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b # expm1 :: Const a b -> Const a b # log1pexp :: Const a b -> Const a b # log1mexp :: Const a b -> Const a b #
Floating a => Floating (Tagged s a)
Instance details Defined in Data.Tagged Methods pi :: Tagged s a # exp :: Tagged s a -> Tagged s a # log :: Tagged s a -> Tagged s a # sqrt :: Tagged s a -> Tagged s a # (**) :: Tagged s a -> Tagged s a -> Tagged s a # logBase :: Tagged s a -> Tagged s a -> Tagged s a # sin :: Tagged s a -> Tagged s a # cos :: Tagged s a -> Tagged s a # tan :: Tagged s a -> Tagged s a # asin :: Tagged s a -> Tagged s a # acos :: Tagged s a -> Tagged s a # atan :: Tagged s a -> Tagged s a # sinh :: Tagged s a -> Tagged s a # cosh :: Tagged s a -> Tagged s a # tanh :: Tagged s a -> Tagged s a # asinh :: Tagged s a -> Tagged s a # acosh :: Tagged s a -> Tagged s a # atanh :: Tagged s a -> Tagged s a # log1p :: Tagged s a -> Tagged s a # expm1 :: Tagged s a -> Tagged s a # log1pexp :: Tagged s a -> Tagged s a # log1mexp :: Tagged s a -> Tagged s a #

class Num a => Fractional a where #

Fractional numbers, supporting real division.

The Haskell Report defines no laws for Fractional. However, (+) and (*) are customarily expected to define a division ring and have the following properties:

recip gives the multiplicative inverse: x * recip x = recip x * x = fromInteger 1

Note that it isn't customarily expected that a type instance of Fractional implement a field. However, all instances in base do.

Minimal complete definition

fromRational, (recip | (/))

Methods

recip :: a -> a #

Reciprocal fraction.

fromRational :: Rational -> a #

Conversion from a Rational (that is Ratio Integer). A floating literal stands for an application of fromRational to a value of type Rational, so such literals have type (Fractional a) => a.

Instances

Instances details

Fractional Bit
Instance details Defined in Data.Bit.Internal Methods (/) :: Bit -> Bit -> Bit # recip :: Bit -> Bit # fromRational :: Rational -> Bit #
Fractional Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (/) :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # recip :: Bls12381Fr -> Bls12381Fr # fromRational :: Rational -> Bls12381Fr #
Fractional Scientific	WARNING: `recip` and `/` will throw an error when their outputs are repeating decimals. These methods also compute `Integer` magnitudes (`10^e`). If these methods are applied to arguments which have huge exponents this could fill up all space and crash your program! So don't apply these methods to scientific numbers coming from untrusted sources. `fromRational` will throw an error when the input `Rational` is a repeating decimal. Consider using `fromRationalRepetend` for these rationals which will detect the repetition and indicate where it starts.
Instance details Defined in Data.Scientific Methods (/) :: Scientific -> Scientific -> Scientific # recip :: Scientific -> Scientific # fromRational :: Rational -> Scientific #
Fractional NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (/) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # recip :: NominalDiffTime -> NominalDiffTime # fromRational :: Rational -> NominalDiffTime #
() :=> (Fractional Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Fractional Double #
() :=> (Fractional Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Fractional Float #
RealFloat a => Fractional (Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods (/) :: Complex a -> Complex a -> Complex a # recip :: Complex a -> Complex a # fromRational :: Rational -> Complex a #
Fractional a => Fractional (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a # recip :: Identity a -> Identity a # fromRational :: Rational -> Identity a #
Fractional a => Fractional (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods (/) :: Down a -> Down a -> Down a # recip :: Down a -> Down a # fromRational :: Rational -> Down a #
Integral a => Fractional (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (/) :: Ratio a -> Ratio a -> Ratio a # recip :: Ratio a -> Ratio a # fromRational :: Rational -> Ratio a #
KnownNat p => Fractional (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods (/) :: Binary p -> Binary p -> Binary p # recip :: Binary p -> Binary p # fromRational :: Rational -> Binary p #
KnownNat p => Fractional (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods (/) :: Prime p -> Prime p -> Prime p # recip :: Prime p -> Prime p # fromRational :: Rational -> Prime p #
KnownNat m => Fractional (Mod m)	See the warning about division above.
Instance details Defined in Data.Mod Methods (/) :: Mod m -> Mod m -> Mod m # recip :: Mod m -> Mod m # fromRational :: Rational -> Mod m #
Fractional a => Fractional (Add a)
Instance details Defined in Data.Semiring Methods (/) :: Add a -> Add a -> Add a # recip :: Add a -> Add a # fromRational :: Rational -> Add a #
Fractional a => Fractional (Mul a)
Instance details Defined in Data.Semiring Methods (/) :: Mul a -> Mul a -> Mul a # recip :: Mul a -> Mul a # fromRational :: Rational -> Mul a #
Fractional a => Fractional (WrappedNum a)
Instance details Defined in Data.Semiring Methods (/) :: WrappedNum a -> WrappedNum a -> WrappedNum a # recip :: WrappedNum a -> WrappedNum a # fromRational :: Rational -> WrappedNum a #
(Fractional t, KnownSymbol s) => Fractional (ElField '(s, t))
Instance details Defined in Data.Vinyl.Functor Methods (/) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # recip :: ElField '(s, t) -> ElField '(s, t) # fromRational :: Rational -> ElField '(s, t) #
(RealFloat a) :=> (Fractional (Complex a))
Instance details Defined in Data.Constraint Methods ins :: RealFloat a :- Fractional (Complex a) #
(Fractional a) :=> (Fractional (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Fractional a :- Fractional (Const a b) #
(Fractional a) :=> (Fractional (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Fractional a :- Fractional (Identity a) #
(Integral a) :=> (Fractional (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Fractional (Ratio a) #
Class (Num a) (Fractional a)
Instance details Defined in Data.Constraint Methods cls :: Fractional a :- Num a #
Class (Fractional a) (Floating a)
Instance details Defined in Data.Constraint Methods cls :: Floating a :- Fractional a #
HasResolution a => Fractional (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods (/) :: Fixed a -> Fixed a -> Fixed a # recip :: Fixed a -> Fixed a # fromRational :: Rational -> Fixed a #
IrreducibleMonic p k => Fractional (Extension p k)
Instance details Defined in Data.Field.Galois.Extension Methods (/) :: Extension p k -> Extension p k -> Extension p k # recip :: Extension p k -> Extension p k # fromRational :: Rational -> Extension p k #
Class (Real a, Fractional a) (RealFrac a)
Instance details Defined in Data.Constraint Methods cls :: RealFrac a :- (Real a, Fractional a) #
Fractional a => Fractional (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (/) :: Const a b -> Const a b -> Const a b # recip :: Const a b -> Const a b # fromRational :: Rational -> Const a b #
Fractional a => Fractional (Tagged s a)
Instance details Defined in Data.Tagged Methods (/) :: Tagged s a -> Tagged s a -> Tagged s a # recip :: Tagged s a -> Tagged s a # fromRational :: Rational -> Tagged s a #

class (Real a, Enum a) => Integral a where #

Integral numbers, supporting integer division.

The Haskell Report defines no laws for Integral. However, Integral instances are customarily expected to define a Euclidean domain and have the following properties for the div/mod and quot/rem pairs, given suitable Euclidean functions f and g:

x = y * quot x y + rem x y with rem x y = fromInteger 0 or g (rem x y) < g y
x = y * div x y + mod x y with mod x y = fromInteger 0 or f (mod x y) < f y

An example of a suitable Euclidean function, for Integer's instance, is abs.

Minimal complete definition

quotRem, toInteger

Methods

quot :: a -> a -> a infixl 7 #

integer division truncated toward zero

rem :: a -> a -> a infixl 7 #

integer remainder, satisfying

(x `quot` y)*y + (x `rem` y) == x

quotRem :: a -> a -> (a, a) #

simultaneous quot and rem

divMod :: a -> a -> (a, a) #

simultaneous div and mod

toInteger :: a -> Integer #

conversion to Integer

Instances

Instances details

Integral Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int16 -> Int16 -> Int16 # rem :: Int16 -> Int16 -> Int16 # div :: Int16 -> Int16 -> Int16 # mod :: Int16 -> Int16 -> Int16 # quotRem :: Int16 -> Int16 -> (Int16, Int16) # divMod :: Int16 -> Int16 -> (Int16, Int16) # toInteger :: Int16 -> Integer #
Integral Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int32 -> Int32 -> Int32 # rem :: Int32 -> Int32 -> Int32 # div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # quotRem :: Int32 -> Int32 -> (Int32, Int32) # divMod :: Int32 -> Int32 -> (Int32, Int32) # toInteger :: Int32 -> Integer #
Integral Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int64 -> Int64 -> Int64 # rem :: Int64 -> Int64 -> Int64 # div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # quotRem :: Int64 -> Int64 -> (Int64, Int64) # divMod :: Int64 -> Int64 -> (Int64, Int64) # toInteger :: Int64 -> Integer #
Integral Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int8 -> Int8 -> Int8 # rem :: Int8 -> Int8 -> Int8 # div :: Int8 -> Int8 -> Int8 # mod :: Int8 -> Int8 -> Int8 # quotRem :: Int8 -> Int8 -> (Int8, Int8) # divMod :: Int8 -> Int8 -> (Int8, Int8) # toInteger :: Int8 -> Integer #
Integral Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word16 -> Word16 -> Word16 # rem :: Word16 -> Word16 -> Word16 # div :: Word16 -> Word16 -> Word16 # mod :: Word16 -> Word16 -> Word16 # quotRem :: Word16 -> Word16 -> (Word16, Word16) # divMod :: Word16 -> Word16 -> (Word16, Word16) # toInteger :: Word16 -> Integer #
Integral Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word32 -> Word32 -> Word32 # rem :: Word32 -> Word32 -> Word32 # div :: Word32 -> Word32 -> Word32 # mod :: Word32 -> Word32 -> Word32 # quotRem :: Word32 -> Word32 -> (Word32, Word32) # divMod :: Word32 -> Word32 -> (Word32, Word32) # toInteger :: Word32 -> Integer #
Integral Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word64 -> Word64 -> Word64 # rem :: Word64 -> Word64 -> Word64 # div :: Word64 -> Word64 -> Word64 # mod :: Word64 -> Word64 -> Word64 # quotRem :: Word64 -> Word64 -> (Word64, Word64) # divMod :: Word64 -> Word64 -> (Word64, Word64) # toInteger :: Word64 -> Integer #
Integral F2Poly	`toInteger` converts a binary polynomial, encoded as `F2Poly`, to `Integer` encoding.
Instance details Defined in Data.Bit.F2Poly Methods quot :: F2Poly -> F2Poly -> F2Poly # rem :: F2Poly -> F2Poly -> F2Poly # div :: F2Poly -> F2Poly -> F2Poly # mod :: F2Poly -> F2Poly -> F2Poly # quotRem :: F2Poly -> F2Poly -> (F2Poly, F2Poly) # divMod :: F2Poly -> F2Poly -> (F2Poly, F2Poly) # toInteger :: F2Poly -> Integer #
Integral Bit
Instance details Defined in Data.Bit.Internal Methods quot :: Bit -> Bit -> Bit # rem :: Bit -> Bit -> Bit # div :: Bit -> Bit -> Bit # mod :: Bit -> Bit -> Bit # quotRem :: Bit -> Bit -> (Bit, Bit) # divMod :: Bit -> Bit -> (Bit, Bit) # toInteger :: Bit -> Integer #
Integral TimeSpec
Instance details Defined in System.Clock Methods quot :: TimeSpec -> TimeSpec -> TimeSpec # rem :: TimeSpec -> TimeSpec -> TimeSpec # div :: TimeSpec -> TimeSpec -> TimeSpec # mod :: TimeSpec -> TimeSpec -> TimeSpec # quotRem :: TimeSpec -> TimeSpec -> (TimeSpec, TimeSpec) # divMod :: TimeSpec -> TimeSpec -> (TimeSpec, TimeSpec) # toInteger :: TimeSpec -> Integer #
Integral RefId Source #
Instance details Defined in Indigo.Common.Var Methods quot :: RefId -> RefId -> RefId # rem :: RefId -> RefId -> RefId # div :: RefId -> RefId -> RefId # mod :: RefId -> RefId -> RefId # quotRem :: RefId -> RefId -> (RefId, RefId) # divMod :: RefId -> RefId -> (RefId, RefId) # toInteger :: RefId -> Integer #
Integral Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods quot :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # rem :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # div :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # mod :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # quotRem :: Bls12381Fr -> Bls12381Fr -> (Bls12381Fr, Bls12381Fr) # divMod :: Bls12381Fr -> Bls12381Fr -> (Bls12381Fr, Bls12381Fr) # toInteger :: Bls12381Fr -> Integer #
Integral Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word8 -> Word8 -> Word8 # rem :: Word8 -> Word8 -> Word8 # div :: Word8 -> Word8 -> Word8 # mod :: Word8 -> Word8 -> Word8 # quotRem :: Word8 -> Word8 -> (Word8, Word8) # divMod :: Word8 -> Word8 -> (Word8, Word8) # toInteger :: Word8 -> Integer #
Integral Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Integer -> Integer -> Integer # rem :: Integer -> Integer -> Integer # div :: Integer -> Integer -> Integer # mod :: Integer -> Integer -> Integer # quotRem :: Integer -> Integer -> (Integer, Integer) # divMod :: Integer -> Integer -> (Integer, Integer) # toInteger :: Integer -> Integer #
Integral Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods quot :: Natural -> Natural -> Natural # rem :: Natural -> Natural -> Natural # div :: Natural -> Natural -> Natural # mod :: Natural -> Natural -> Natural # quotRem :: Natural -> Natural -> (Natural, Natural) # divMod :: Natural -> Natural -> (Natural, Natural) # toInteger :: Natural -> Integer #
Integral Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Int -> Int -> Int # rem :: Int -> Int -> Int # div :: Int -> Int -> Int # mod :: Int -> Int -> Int # quotRem :: Int -> Int -> (Int, Int) # divMod :: Int -> Int -> (Int, Int) # toInteger :: Int -> Integer #
Integral Word	Since: base-2.1
Instance details Defined in GHC.Real Methods quot :: Word -> Word -> Word # rem :: Word -> Word -> Word # div :: Word -> Word -> Word # mod :: Word -> Word -> Word # quotRem :: Word -> Word -> (Word, Word) # divMod :: Word -> Word -> (Word, Word) # toInteger :: Word -> Integer #
() :=> (Integral Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Integral Integer #
() :=> (Integral Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Integral Natural #
() :=> (Integral Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Integral Int #
() :=> (Integral Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Integral Word #
Integral a => Integral (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # toInteger :: Identity a -> Integer #
KnownNat p => Integral (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods quot :: Binary p -> Binary p -> Binary p # rem :: Binary p -> Binary p -> Binary p # div :: Binary p -> Binary p -> Binary p # mod :: Binary p -> Binary p -> Binary p # quotRem :: Binary p -> Binary p -> (Binary p, Binary p) # divMod :: Binary p -> Binary p -> (Binary p, Binary p) # toInteger :: Binary p -> Integer #
KnownNat p => Integral (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods quot :: Prime p -> Prime p -> Prime p # rem :: Prime p -> Prime p -> Prime p # div :: Prime p -> Prime p -> Prime p # mod :: Prime p -> Prime p -> Prime p # quotRem :: Prime p -> Prime p -> (Prime p, Prime p) # divMod :: Prime p -> Prime p -> (Prime p, Prime p) # toInteger :: Prime p -> Integer #
Integral a => Integral (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods quot :: StringEncode a -> StringEncode a -> StringEncode a # rem :: StringEncode a -> StringEncode a -> StringEncode a # div :: StringEncode a -> StringEncode a -> StringEncode a # mod :: StringEncode a -> StringEncode a -> StringEncode a # quotRem :: StringEncode a -> StringEncode a -> (StringEncode a, StringEncode a) # divMod :: StringEncode a -> StringEncode a -> (StringEncode a, StringEncode a) # toInteger :: StringEncode a -> Integer #
(Integral a) :=> (Enum (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Enum (Ratio a) #
(Integral a) :=> (Num (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Num (Ratio a) #
(Integral a) :=> (Fractional (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Fractional (Ratio a) #
(Integral a) :=> (Integral (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Integral (Const a b) #
(Integral a) :=> (Integral (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Integral (Identity a) #
(Integral a) :=> (Real (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Real (Ratio a) #
(Integral a) :=> (RealFrac (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- RealFrac (Ratio a) #
(Integral a) :=> (Ord (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Ord (Ratio a) #
(Integral a, Bits a, TypeNum n) => Integral (OddWord a n)
Instance details Defined in Data.Word.Odd Methods quot :: OddWord a n -> OddWord a n -> OddWord a n # rem :: OddWord a n -> OddWord a n -> OddWord a n # div :: OddWord a n -> OddWord a n -> OddWord a n # mod :: OddWord a n -> OddWord a n -> OddWord a n # quotRem :: OddWord a n -> OddWord a n -> (OddWord a n, OddWord a n) # divMod :: OddWord a n -> OddWord a n -> (OddWord a n, OddWord a n) # toInteger :: OddWord a n -> Integer #
(Integral a, Read a) :=> (Read (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: (Integral a, Read a) :- Read (Ratio a) #
(Integral a, Show a) :=> (Show (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: (Integral a, Show a) :- Show (Ratio a) #
Class (Real a, Enum a) (Integral a)
Instance details Defined in Data.Constraint Methods cls :: Integral a :- (Real a, Enum a) #
Integral a => Integral (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b # rem :: Const a b -> Const a b -> Const a b # div :: Const a b -> Const a b -> Const a b # mod :: Const a b -> Const a b -> Const a b # quotRem :: Const a b -> Const a b -> (Const a b, Const a b) # divMod :: Const a b -> Const a b -> (Const a b, Const a b) # toInteger :: Const a b -> Integer #
Integral a => Integral (Tagged s a)
Instance details Defined in Data.Tagged Methods quot :: Tagged s a -> Tagged s a -> Tagged s a # rem :: Tagged s a -> Tagged s a -> Tagged s a # div :: Tagged s a -> Tagged s a -> Tagged s a # mod :: Tagged s a -> Tagged s a -> Tagged s a # quotRem :: Tagged s a -> Tagged s a -> (Tagged s a, Tagged s a) # divMod :: Tagged s a -> Tagged s a -> (Tagged s a, Tagged s a) # toInteger :: Tagged s a -> Integer #

class Applicative m => Monad (m :: Type -> Type) where #

The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following:

Left identity: return a >>= k = k a
Right identity: m >>= return = m
Associativity: m >>= (\x -> k x >>= h) = (m >>= k) >>= h

Furthermore, the Monad and Applicative operations should relate as follows:

```
pure = return
```

m1 <*> m2 = m1 >>= (x1 -> m2 >>= (x2 -> return (x1 x2)))

The above laws imply:

```
fmap f xs  =  xs >>= return . f
```
```
(>>) = (*>)
```

and that pure and (<*>) satisfy the applicative functor laws.

The instances of Monad for lists, Maybe and IO defined in the Prelude satisfy these laws.

Minimal complete definition

(>>=)

Methods

(>>=) :: m a -> (a -> m b) -> m b infixl 1 #

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

'as >>= bs' can be understood as the do expression

do a <- as
   bs a

(>>) :: m a -> m b -> m b infixl 1 #

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

'as >> bs' can be understood as the do expression

do as
   bs

return :: a -> m a #

Inject a value into the monadic type.

Instances

Instances details

Monad IResult
Instance details Defined in Data.Aeson.Types.Internal Methods (>>=) :: IResult a -> (a -> IResult b) -> IResult b # (>>) :: IResult a -> IResult b -> IResult b # return :: a -> IResult a #
Monad Parser
Instance details Defined in Data.Aeson.Types.Internal Methods (>>=) :: Parser a -> (a -> Parser b) -> Parser b # (>>) :: Parser a -> Parser b -> Parser b # return :: a -> Parser a #
Monad Result
Instance details Defined in Data.Aeson.Types.Internal Methods (>>=) :: Result a -> (a -> Result b) -> Result b # (>>) :: Result a -> Result b -> Result b # return :: a -> Result a #
Monad Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods (>>=) :: Complex a -> (a -> Complex b) -> Complex b # (>>) :: Complex a -> Complex b -> Complex b # return :: a -> Complex a #
Monad Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a #
Monad First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a #
Monad Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a #
Monad Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (>>=) :: Down a -> (a -> Down b) -> Down b # (>>) :: Down a -> Down b -> Down b # return :: a -> Down a #
Monad First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a #
Monad Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a #
Monad Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Max a -> (a -> Max b) -> Max b # (>>) :: Max a -> Max b -> Max b # return :: a -> Max a #
Monad Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Min a -> (a -> Min b) -> Min b # (>>) :: Min a -> Min b -> Min b # return :: a -> Min a #
Monad Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Option a -> (a -> Option b) -> Option b # (>>) :: Option a -> Option b -> Option b # return :: a -> Option a #
Monad Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Dual a -> (a -> Dual b) -> Dual b # (>>) :: Dual a -> Dual b -> Dual b # return :: a -> Dual a #
Monad Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Product a -> (a -> Product b) -> Product b # (>>) :: Product a -> Product b -> Product b # return :: a -> Product a #
Monad Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Sum a -> (a -> Sum b) -> Sum b # (>>) :: Sum a -> Sum b -> Sum b # return :: a -> Sum a #
Monad NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a #
Monad STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods (>>=) :: STM a -> (a -> STM b) -> STM b # (>>) :: STM a -> STM b -> STM b # return :: a -> STM a #
Monad Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b # (>>) :: Par1 a -> Par1 b -> Par1 b # return :: a -> Par1 a #
Monad P	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods (>>=) :: P a -> (a -> P b) -> P b # (>>) :: P a -> P b -> P b # return :: a -> P a #
Monad ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods (>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b # (>>) :: ReadP a -> ReadP b -> ReadP b # return :: a -> ReadP a #
Monad Put
Instance details Defined in Data.ByteString.Builder.Internal Methods (>>=) :: Put a -> (a -> Put b) -> Put b # (>>) :: Put a -> Put b -> Put b # return :: a -> Put a #
Monad Identifier
Instance details Defined in Text.Casing Methods (>>=) :: Identifier a -> (a -> Identifier b) -> Identifier b # (>>) :: Identifier a -> Identifier b -> Identifier b # return :: a -> Identifier a #
Monad Seq
Instance details Defined in Data.Sequence.Internal Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b # (>>) :: Seq a -> Seq b -> Seq b # return :: a -> Seq a #
Monad Tree
Instance details Defined in Data.Tree Methods (>>=) :: Tree a -> (a -> Tree b) -> Tree b # (>>) :: Tree a -> Tree b -> Tree b # return :: a -> Tree a #
Monad CryptoFailable
Instance details Defined in Crypto.Error.Types Methods (>>=) :: CryptoFailable a -> (a -> CryptoFailable b) -> CryptoFailable b # (>>) :: CryptoFailable a -> CryptoFailable b -> CryptoFailable b # return :: a -> CryptoFailable a #
Monad DNonEmpty
Instance details Defined in Data.DList.DNonEmpty.Internal Methods (>>=) :: DNonEmpty a -> (a -> DNonEmpty b) -> DNonEmpty b # (>>) :: DNonEmpty a -> DNonEmpty b -> DNonEmpty b # return :: a -> DNonEmpty a #
Monad DList
Instance details Defined in Data.DList.Internal Methods (>>=) :: DList a -> (a -> DList b) -> DList b # (>>) :: DList a -> DList b -> DList b # return :: a -> DList a #
Monad IO	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a #
Monad IndigoM Source #
Instance details Defined in Indigo.Frontend.Program Methods (>>=) :: IndigoM a -> (a -> IndigoM b) -> IndigoM b # (>>) :: IndigoM a -> IndigoM b -> IndigoM b # return :: a -> IndigoM a #
Monad WithFinalizedDoc
Instance details Defined in Morley.Michelson.Doc Methods (>>=) :: WithFinalizedDoc a -> (a -> WithFinalizedDoc b) -> WithFinalizedDoc b # (>>) :: WithFinalizedDoc a -> WithFinalizedDoc b -> WithFinalizedDoc b # return :: a -> WithFinalizedDoc a #
Monad EvalOp
Instance details Defined in Morley.Michelson.Interpret Methods (>>=) :: EvalOp a -> (a -> EvalOp b) -> EvalOp b # (>>) :: EvalOp a -> EvalOp b -> EvalOp b # return :: a -> EvalOp a #
Monad Array
Instance details Defined in Data.Primitive.Array Methods (>>=) :: Array a -> (a -> Array b) -> Array b # (>>) :: Array a -> Array b -> Array b # return :: a -> Array a #
Monad SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods (>>=) :: SmallArray a -> (a -> SmallArray b) -> SmallArray b # (>>) :: SmallArray a -> SmallArray b -> SmallArray b # return :: a -> SmallArray a #
Monad PprM
Instance details Defined in Language.Haskell.TH.PprLib Methods (>>=) :: PprM a -> (a -> PprM b) -> PprM b # (>>) :: PprM a -> PprM b -> PprM b # return :: a -> PprM a #
Monad Q
Instance details Defined in Language.Haskell.TH.Syntax Methods (>>=) :: Q a -> (a -> Q b) -> Q b # (>>) :: Q a -> Q b -> Q b # return :: a -> Q a #
Monad Vector
Instance details Defined in Data.Vector Methods (>>=) :: Vector a -> (a -> Vector b) -> Vector b # (>>) :: Vector a -> Vector b -> Vector b # return :: a -> Vector a #
Monad Identity
Instance details Defined in Data.Vinyl.Functor Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a #
Monad Thunk
Instance details Defined in Data.Vinyl.Functor Methods (>>=) :: Thunk a -> (a -> Thunk b) -> Thunk b # (>>) :: Thunk a -> Thunk b -> Thunk b # return :: a -> Thunk a #
Monad Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a #
Monad Solo	Since: base-4.15
Instance details Defined in GHC.Base Methods (>>=) :: Solo a -> (a -> Solo b) -> Solo b # (>>) :: Solo a -> Solo b -> Solo b # return :: a -> Solo a #
Monad []	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: [a] -> (a -> [b]) -> [b] # (>>) :: [a] -> [b] -> [b] # return :: a -> [a] #
() :=> (Monad (Either a))
Instance details Defined in Data.Constraint Methods ins :: () :- Monad (Either a) #
() :=> (Monad Identity)
Instance details Defined in Data.Constraint Methods ins :: () :- Monad Identity #
() :=> (Monad IO)
Instance details Defined in Data.Constraint Methods ins :: () :- Monad IO #
() :=> (Monad ((->) a))
Instance details Defined in Data.Constraint Methods ins :: () :- Monad ((->) a) #
() :=> (Monad [])
Instance details Defined in Data.Constraint Methods ins :: () :- Monad [] #
Representable f => Monad (Co f)
Instance details Defined in Data.Functor.Rep Methods (>>=) :: Co f a -> (a -> Co f b) -> Co f b # (>>) :: Co f a -> Co f b -> Co f b # return :: a -> Co f a #
Monad (Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods (>>=) :: Parser i a -> (a -> Parser i b) -> Parser i b # (>>) :: Parser i a -> Parser i b -> Parser i b # return :: a -> Parser i a #
Monad m => Monad (WrappedMonad m)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a #
ArrowApply a => Monad (ArrowMonad a)	Since: base-2.1
Instance details Defined in Control.Arrow Methods (>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b # (>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # return :: a0 -> ArrowMonad a a0 #
Monad (Either e)	Since: base-4.4.0.0
Instance details Defined in Data.Either Methods (>>=) :: Either e a -> (a -> Either e b) -> Either e b # (>>) :: Either e a -> Either e b -> Either e b # return :: a -> Either e a #
Monad (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b # (>>) :: Proxy a -> Proxy b -> Proxy b # return :: a -> Proxy a #
Monad (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: U1 a -> (a -> U1 b) -> U1 b # (>>) :: U1 a -> U1 b -> U1 b # return :: a -> U1 a #
Monad (ST s)	Since: base-2.1
Instance details Defined in GHC.ST Methods (>>=) :: ST s a -> (a -> ST s b) -> ST s b # (>>) :: ST s a -> ST s b -> ST s b # return :: a -> ST s a #
Monad (SetM s)
Instance details Defined in Data.Graph Methods (>>=) :: SetM s a -> (a -> SetM s b) -> SetM s b # (>>) :: SetM s a -> SetM s b -> SetM s b # return :: a -> SetM s a #
DRG gen => Monad (MonadPseudoRandom gen)
Instance details Defined in Crypto.Random.Types Methods (>>=) :: MonadPseudoRandom gen a -> (a -> MonadPseudoRandom gen b) -> MonadPseudoRandom gen b # (>>) :: MonadPseudoRandom gen a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen b # return :: a -> MonadPseudoRandom gen a #
Alternative f => Monad (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods (>>=) :: Cofree f a -> (a -> Cofree f b) -> Cofree f b # (>>) :: Cofree f a -> Cofree f b -> Cofree f b # return :: a -> Cofree f a #
Functor f => Monad (Free f)
Instance details Defined in Control.Monad.Free Methods (>>=) :: Free f a -> (a -> Free f b) -> Free f b # (>>) :: Free f a -> Free f b -> Free f b # return :: a -> Free f a #
Monad (Program instr) Source #
Instance details Defined in Indigo.Frontend.Program Methods (>>=) :: Program instr a -> (a -> Program instr b) -> Program instr b # (>>) :: Program instr a -> Program instr b -> Program instr b # return :: a -> Program instr a #
Monad m => Monad (Yoneda m)
Instance details Defined in Data.Functor.Yoneda Methods (>>=) :: Yoneda m a -> (a -> Yoneda m b) -> Yoneda m b # (>>) :: Yoneda m a -> Yoneda m b -> Yoneda m b # return :: a -> Yoneda m a #
Monad (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods (>>=) :: ReifiedFold s a -> (a -> ReifiedFold s b) -> ReifiedFold s b # (>>) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b # return :: a -> ReifiedFold s a #
Monad (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods (>>=) :: ReifiedGetter s a -> (a -> ReifiedGetter s b) -> ReifiedGetter s b # (>>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b # return :: a -> ReifiedGetter s a #
SingI n => Monad (SizedList' n)
Instance details Defined in Morley.Util.SizedList Methods (>>=) :: SizedList' n a -> (a -> SizedList' n b) -> SizedList' n b # (>>) :: SizedList' n a -> SizedList' n b -> SizedList' n b # return :: a -> SizedList' n a #
Semigroup a => Monad (These a)
Instance details Defined in Data.Strict.These Methods (>>=) :: These a a0 -> (a0 -> These a b) -> These a b # (>>) :: These a a0 -> These a b -> These a b # return :: a0 -> These a a0 #
Semigroup a => Monad (These a)
Instance details Defined in Data.These Methods (>>=) :: These a a0 -> (a0 -> These a b) -> These a b # (>>) :: These a a0 -> These a b -> These a b # return :: a0 -> These a a0 #
Monad m => Monad (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods (>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b # (>>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # return :: a -> MaybeT m a #
Monoid a => Monad ((,) a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b) # (>>) :: (a, a0) -> (a, b) -> (a, b) # return :: a0 -> (a, a0) #
(Monad m) :=> (Applicative (WrappedMonad m))
Instance details Defined in Data.Constraint Methods ins :: Monad m :- Applicative (WrappedMonad m) #
(Monad m) :=> (Functor (WrappedMonad m))
Instance details Defined in Data.Constraint Methods ins :: Monad m :- Functor (WrappedMonad m) #
Class (Applicative f) (Monad f)
Instance details Defined in Data.Constraint Methods cls :: Monad f :- Applicative f #
Monad m => Monad (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods (>>=) :: RandT g m a -> (a -> RandT g m b) -> RandT g m b # (>>) :: RandT g m a -> RandT g m b -> RandT g m b # return :: a -> RandT g m a #
Monad m => Monad (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Strict Methods (>>=) :: RandT g m a -> (a -> RandT g m b) -> RandT g m b # (>>) :: RandT g m a -> RandT g m b -> RandT g m b # return :: a -> RandT g m a #
Monad m => Monad (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods (>>=) :: Kleisli m a a0 -> (a0 -> Kleisli m a b) -> Kleisli m a b # (>>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b # return :: a0 -> Kleisli m a a0 #
Monad f => Monad (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: Ap f a -> (a -> Ap f b) -> Ap f b # (>>) :: Ap f a -> Ap f b -> Ap f b # return :: a -> Ap f a #
Monad f => Monad (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Alt f a -> (a -> Alt f b) -> Alt f b # (>>) :: Alt f a -> Alt f b -> Alt f b # return :: a -> Alt f a #
Monad f => Monad (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b # (>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # return :: a -> Rec1 f a #
(Applicative f, Monad f) => Monad (WhenMissing f x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))`. Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods (>>=) :: WhenMissing f x a -> (a -> WhenMissing f x b) -> WhenMissing f x b # (>>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # return :: a -> WhenMissing f x a #
(Alternative f, Monad w) => Monad (CofreeT f w)
Instance details Defined in Control.Comonad.Trans.Cofree Methods (>>=) :: CofreeT f w a -> (a -> CofreeT f w b) -> CofreeT f w b # (>>) :: CofreeT f w a -> CofreeT f w b -> CofreeT f w b # return :: a -> CofreeT f w a #
(Functor f, Monad m) => Monad (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods (>>=) :: FreeT f m a -> (a -> FreeT f m b) -> FreeT f m b # (>>) :: FreeT f m a -> FreeT f m b -> FreeT f m b # return :: a -> FreeT f m a #
Monad (Indexed i a)
Instance details Defined in Control.Lens.Internal.Indexed Methods (>>=) :: Indexed i a a0 -> (a0 -> Indexed i a b) -> Indexed i a b # (>>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b # return :: a0 -> Indexed i a a0 #
(Monad (Rep p), Representable p) => Monad (Prep p)
Instance details Defined in Data.Profunctor.Rep Methods (>>=) :: Prep p a -> (a -> Prep p b) -> Prep p b # (>>) :: Prep p a -> Prep p b -> Prep p b # return :: a -> Prep p a #
Monad (Tagged s)
Instance details Defined in Data.Tagged Methods (>>=) :: Tagged s a -> (a -> Tagged s b) -> Tagged s b # (>>) :: Tagged s a -> Tagged s b -> Tagged s b # return :: a -> Tagged s a #
(Monad m, Error e) => Monad (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods (>>=) :: ErrorT e m a -> (a -> ErrorT e m b) -> ErrorT e m b # (>>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b # return :: a -> ErrorT e m a #
Monad m => Monad (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # return :: a -> ExceptT e m a #
Monad m => Monad (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods (>>=) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b # (>>) :: IdentityT m a -> IdentityT m b -> IdentityT m b # return :: a -> IdentityT m a #
Monad m => Monad (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods (>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b # (>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # return :: a -> ReaderT r m a #
Monad m => Monad (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a #
Monad m => Monad (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a #
(Monoid a, Monoid b) => Monad ((,,) a b)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods (>>=) :: (a, b, a0) -> (a0 -> (a, b, b0)) -> (a, b, b0) # (>>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) # return :: a0 -> (a, b, a0) #
Class (Monad f, Alternative f) (MonadPlus f)
Instance details Defined in Data.Constraint Methods cls :: MonadPlus f :- (Monad f, Alternative f) #
(Monad f, Monad g) => Monad (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods (>>=) :: Product f g a -> (a -> Product f g b) -> Product f g b # (>>) :: Product f g a -> Product f g b -> Product f g b # return :: a -> Product f g a #
(Monad f, Monad g) => Monad (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: (f :: g) a -> (a -> (f :: g) b) -> (f :: g) b # (>>) :: (f :: g) a -> (f :: g) b -> (f :: g) b # return :: a -> (f :*: g) a #
(Monad f, Applicative f) => Monad (WhenMatched f x y)	Equivalent to `ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods (>>=) :: WhenMatched f x y a -> (a -> WhenMatched f x y b) -> WhenMatched f x y b # (>>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # return :: a -> WhenMatched f x y a #
(Applicative f, Monad f) => Monad (WhenMissing f k x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))` . Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods (>>=) :: WhenMissing f k x a -> (a -> WhenMissing f k x b) -> WhenMissing f k x b # (>>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # return :: a -> WhenMissing f k x a #
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods (>>=) :: (a, b, c, a0) -> (a0 -> (a, b, c, b0)) -> (a, b, c, b0) # (>>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) # return :: a0 -> (a, b, c, a0) #
Monad ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b # (>>) :: (r -> a) -> (r -> b) -> r -> b # return :: a -> r -> a #
Monad f => Monad (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b # (>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b # return :: a -> M1 i c f a #
(Monad f, Applicative f) => Monad (WhenMatched f k x y)	Equivalent to `ReaderT k (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods (>>=) :: WhenMatched f k x y a -> (a -> WhenMatched f k x y b) -> WhenMatched f k x y b # (>>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # return :: a -> WhenMatched f k x y a #
Monad state => Monad (Builder collection mutCollection step state err)
Instance details Defined in Basement.MutableBuilder Methods (>>=) :: Builder collection mutCollection step state err a -> (a -> Builder collection mutCollection step state err b) -> Builder collection mutCollection step state err b # (>>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b # return :: a -> Builder collection mutCollection step state err a #

class Functor (f :: Type -> Type) where #

A type f is a Functor if it provides a function fmap which, given any types a and b lets you apply any function from (a -> b) to turn an f a into an f b, preserving the structure of f. Furthermore f needs to adhere to the following:

Identity: fmap id == id
Composition: fmap (f . g) == fmap f . fmap g

Note, that the second law follows from the free theorem of the type fmap and the first law, so you need only check that the former condition holds.

Minimal complete definition

fmap

Methods

fmap :: (a -> b) -> f a -> f b #

fmap is used to apply a function of type (a -> b) to a value of type f a, where f is a functor, to produce a value of type f b. Note that for any type constructor with more than one parameter (e.g., Either), only the last type parameter can be modified with fmap (e.g., b in `Either a b`).

Some type constructors with two parameters or more have a Bifunctor instance that allows both the last and the penultimate parameters to be mapped over. ==== Examples

Convert from a Maybe Int to a Maybe String using show:

>>> fmap show Nothing
Nothing
>>> fmap show (Just 3)
Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> fmap show (Left 17)
Left 17
>>> fmap show (Right 17)
Right "17"

Double each element of a list:

>>> fmap (*2) [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> fmap even (2,2)
(2,True)

It may seem surprising that the function is only applied to the last element of the tuple compared to the list example above which applies it to every element in the list. To understand, remember that tuples are type constructors with multiple type parameters: a tuple of 3 elements `(a,b,c)` can also be written `(,,) a b c` and its Functor instance is defined for `Functor ((,,) a b)` (i.e., only the third parameter is free to be mapped over with fmap).

It explains why fmap can be used with tuples containing values of different types as in the following example:

>>> fmap even ("hello", 1.0, 4)
("hello",1.0,True)

(<$) :: a -> f b -> f a infixl 4 #

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Instances

Instances details

Functor Last'
Instance details Defined in Distribution.Compat.Semigroup Methods fmap :: (a -> b) -> Last' a -> Last' b # (<$) :: a -> Last' b -> Last' a #
Functor Option'
Instance details Defined in Distribution.Compat.Semigroup Methods fmap :: (a -> b) -> Option' a -> Option' b # (<$) :: a -> Option' b -> Option' a #
Functor KeyMap
Instance details Defined in Data.Aeson.KeyMap Methods fmap :: (a -> b) -> KeyMap a -> KeyMap b # (<$) :: a -> KeyMap b -> KeyMap a #
Functor IResult
Instance details Defined in Data.Aeson.Types.Internal Methods fmap :: (a -> b) -> IResult a -> IResult b # (<$) :: a -> IResult b -> IResult a #
Functor Parser
Instance details Defined in Data.Aeson.Types.Internal Methods fmap :: (a -> b) -> Parser a -> Parser b # (<$) :: a -> Parser b -> Parser a #
Functor Result
Instance details Defined in Data.Aeson.Types.Internal Methods fmap :: (a -> b) -> Result a -> Result b # (<$) :: a -> Result b -> Result a #
Functor ZipList	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
Functor Handler	Since: base-4.6.0.0
Instance details Defined in Control.Exception Methods fmap :: (a -> b) -> Handler a -> Handler b # (<$) :: a -> Handler b -> Handler a #
Functor Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods fmap :: (a -> b) -> Complex a -> Complex b # (<$) :: a -> Complex b -> Complex a #
Functor Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
Functor First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods fmap :: (a -> b) -> Down a -> Down b # (<$) :: a -> Down b -> Down a #
Functor First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Max a -> Max b # (<$) :: a -> Max b -> Max a #
Functor Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Min a -> Min b # (<$) :: a -> Min b -> Min a #
Functor Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Option a -> Option b # (<$) :: a -> Option b -> Option a #
Functor Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Dual a -> Dual b # (<$) :: a -> Dual b -> Dual a #
Functor Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Product a -> Product b # (<$) :: a -> Product b -> Product a #
Functor Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Sum a -> Sum b # (<$) :: a -> Sum b -> Sum a #
Functor NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Functor STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods fmap :: (a -> b) -> STM a -> STM b # (<$) :: a -> STM b -> STM a #
Functor Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Par1 a -> Par1 b # (<$) :: a -> Par1 b -> Par1 a #
Functor P	Since: base-4.8.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> P a -> P b # (<$) :: a -> P b -> P a #
Functor ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> ReadP a -> ReadP b # (<$) :: a -> ReadP b -> ReadP a #
Functor Array
Instance details Defined in Basement.BoxedArray Methods fmap :: (a -> b) -> Array a -> Array b # (<$) :: a -> Array b -> Array a #
Functor Put
Instance details Defined in Data.ByteString.Builder.Internal Methods fmap :: (a -> b) -> Put a -> Put b # (<$) :: a -> Put b -> Put a #
Functor Identifier
Instance details Defined in Text.Casing Methods fmap :: (a -> b) -> Identifier a -> Identifier b # (<$) :: a -> Identifier b -> Identifier a #
Functor SCC	Since: containers-0.5.4
Instance details Defined in Data.Graph Methods fmap :: (a -> b) -> SCC a -> SCC b # (<$) :: a -> SCC b -> SCC a #
Functor IntMap
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> IntMap a -> IntMap b # (<$) :: a -> IntMap b -> IntMap a #
Functor Digit
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Digit a -> Digit b # (<$) :: a -> Digit b -> Digit a #
Functor Elem
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Elem a -> Elem b # (<$) :: a -> Elem b -> Elem a #
Functor FingerTree
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> FingerTree a -> FingerTree b # (<$) :: a -> FingerTree b -> FingerTree a #
Functor Node
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Node a -> Node b # (<$) :: a -> Node b -> Node a #
Functor Seq
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Seq a -> Seq b # (<$) :: a -> Seq b -> Seq a #
Functor ViewL
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> ViewL a -> ViewL b # (<$) :: a -> ViewL b -> ViewL a #
Functor ViewR
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> ViewR a -> ViewR b # (<$) :: a -> ViewR b -> ViewR a #
Functor Tree
Instance details Defined in Data.Tree Methods fmap :: (a -> b) -> Tree a -> Tree b # (<$) :: a -> Tree b -> Tree a #
Functor CryptoFailable
Instance details Defined in Crypto.Error.Types Methods fmap :: (a -> b) -> CryptoFailable a -> CryptoFailable b # (<$) :: a -> CryptoFailable b -> CryptoFailable a #
Functor DNonEmpty
Instance details Defined in Data.DList.DNonEmpty.Internal Methods fmap :: (a -> b) -> DNonEmpty a -> DNonEmpty b # (<$) :: a -> DNonEmpty b -> DNonEmpty a #
Functor DList
Instance details Defined in Data.DList.Internal Methods fmap :: (a -> b) -> DList a -> DList b # (<$) :: a -> DList b -> DList a #
Functor IO	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Functor IndigoM Source #
Instance details Defined in Indigo.Frontend.Program Methods fmap :: (a -> b) -> IndigoM a -> IndigoM b # (<$) :: a -> IndigoM b -> IndigoM a #
Functor ErrorFancy
Instance details Defined in Text.Megaparsec.Error Methods fmap :: (a -> b) -> ErrorFancy a -> ErrorFancy b # (<$) :: a -> ErrorFancy b -> ErrorFancy a #
Functor ErrorItem
Instance details Defined in Text.Megaparsec.Error Methods fmap :: (a -> b) -> ErrorItem a -> ErrorItem b # (<$) :: a -> ErrorItem b -> ErrorItem a #
Functor WithFinalizedDoc
Instance details Defined in Morley.Michelson.Doc Methods fmap :: (a -> b) -> WithFinalizedDoc a -> WithFinalizedDoc b # (<$) :: a -> WithFinalizedDoc b -> WithFinalizedDoc a #
Functor ViewsSetF
Instance details Defined in Morley.Michelson.Internal.ViewsSet Methods fmap :: (a -> b) -> ViewsSetF a -> ViewsSetF b # (<$) :: a -> ViewsSetF b -> ViewsSetF a #
Functor EvalOp
Instance details Defined in Morley.Michelson.Interpret Methods fmap :: (a -> b) -> EvalOp a -> EvalOp b # (<$) :: a -> EvalOp b -> EvalOp a #
Functor ResultStateLogs
Instance details Defined in Morley.Michelson.Interpret Methods fmap :: (a -> b) -> ResultStateLogs a -> ResultStateLogs b # (<$) :: a -> ResultStateLogs b -> ResultStateLogs a #
Functor IllTypedInstr
Instance details Defined in Morley.Michelson.TypeCheck.TypeCheckedOp Methods fmap :: (a -> b) -> IllTypedInstr a -> IllTypedInstr b # (<$) :: a -> IllTypedInstr b -> IllTypedInstr a #
Functor TypeCheckedOp
Instance details Defined in Morley.Michelson.TypeCheck.TypeCheckedOp Methods fmap :: (a -> b) -> TypeCheckedOp a -> TypeCheckedOp b # (<$) :: a -> TypeCheckedOp b -> TypeCheckedOp a #
Functor Contract'
Instance details Defined in Morley.Michelson.Untyped.Contract Methods fmap :: (a -> b) -> Contract' a -> Contract' b # (<$) :: a -> Contract' b -> Contract' a #
Functor ContractBlock
Instance details Defined in Morley.Michelson.Untyped.Contract Methods fmap :: (a -> b) -> ContractBlock a -> ContractBlock b # (<$) :: a -> ContractBlock b -> ContractBlock a #
Functor ExtInstrAbstract
Instance details Defined in Morley.Michelson.Untyped.Ext Methods fmap :: (a -> b) -> ExtInstrAbstract a -> ExtInstrAbstract b # (<$) :: a -> ExtInstrAbstract b -> ExtInstrAbstract a #
Functor TestAssert
Instance details Defined in Morley.Michelson.Untyped.Ext Methods fmap :: (a -> b) -> TestAssert a -> TestAssert b # (<$) :: a -> TestAssert b -> TestAssert a #
Functor InstrAbstract
Instance details Defined in Morley.Michelson.Untyped.Instr Methods fmap :: (a -> b) -> InstrAbstract a -> InstrAbstract b # (<$) :: a -> InstrAbstract b -> InstrAbstract a #
Functor Elt
Instance details Defined in Morley.Michelson.Untyped.Value Methods fmap :: (a -> b) -> Elt a -> Elt b # (<$) :: a -> Elt b -> Elt a #
Functor Value'
Instance details Defined in Morley.Michelson.Untyped.Value Methods fmap :: (a -> b) -> Value' a -> Value' b # (<$) :: a -> Value' b -> Value' a #
Functor View'
Instance details Defined in Morley.Michelson.Untyped.View Methods fmap :: (a -> b) -> View' a -> View' b # (<$) :: a -> View' b -> View' a #
Functor ViewsSet
Instance details Defined in Morley.Michelson.Untyped.View Methods fmap :: (a -> b) -> ViewsSet a -> ViewsSet b # (<$) :: a -> ViewsSet b -> ViewsSet a #
Functor MismatchError
Instance details Defined in Morley.Util.MismatchError Methods fmap :: (a -> b) -> MismatchError a -> MismatchError b # (<$) :: a -> MismatchError b -> MismatchError a #
Functor SomeSizedList
Instance details Defined in Morley.Util.SizedList Methods fmap :: (a -> b) -> SomeSizedList a -> SomeSizedList b # (<$) :: a -> SomeSizedList b -> SomeSizedList a #
Functor AnnotDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> AnnotDetails a -> AnnotDetails b # (<$) :: a -> AnnotDetails b -> AnnotDetails a #
Functor Doc
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> Doc a -> Doc b # (<$) :: a -> Doc b -> Doc a #
Functor Span
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> Span a -> Span b # (<$) :: a -> Span b -> Span a #
Functor Array
Instance details Defined in Data.Primitive.Array Methods fmap :: (a -> b) -> Array a -> Array b # (<$) :: a -> Array b -> Array a #
Functor SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods fmap :: (a -> b) -> SmallArray a -> SmallArray b # (<$) :: a -> SmallArray b -> SmallArray a #
Functor Add
Instance details Defined in Data.Semiring Methods fmap :: (a -> b) -> Add a -> Add b # (<$) :: a -> Add b -> Add a #
Functor Mul
Instance details Defined in Data.Semiring Methods fmap :: (a -> b) -> Mul a -> Mul b # (<$) :: a -> Mul b -> Mul a #
Functor WrappedNum
Instance details Defined in Data.Semiring Methods fmap :: (a -> b) -> WrappedNum a -> WrappedNum b # (<$) :: a -> WrappedNum b -> WrappedNum a #
Functor Maybe
Instance details Defined in Data.Strict.Maybe Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Functor PprM
Instance details Defined in Language.Haskell.TH.PprLib Methods fmap :: (a -> b) -> PprM a -> PprM b # (<$) :: a -> PprM b -> PprM a #
Functor Q
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
Functor TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> TyVarBndr a -> TyVarBndr b # (<$) :: a -> TyVarBndr b -> TyVarBndr a #
Functor DTyVarBndr
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods fmap :: (a -> b) -> DTyVarBndr a -> DTyVarBndr b # (<$) :: a -> DTyVarBndr b -> DTyVarBndr a #
Functor Vector
Instance details Defined in Data.Vector Methods fmap :: (a -> b) -> Vector a -> Vector b # (<$) :: a -> Vector b -> Vector a #
Functor Identity
Instance details Defined in Data.Vinyl.Functor Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
Functor Thunk
Instance details Defined in Data.Vinyl.Functor Methods fmap :: (a -> b) -> Thunk a -> Thunk b # (<$) :: a -> Thunk b -> Thunk a #
Functor Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Functor Solo	Since: base-4.15
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Solo a -> Solo b # (<$) :: a -> Solo b -> Solo a #
Functor []	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> [a] -> [b] # (<$) :: a -> [b] -> [a] #
() :=> (Functor (Either a))
Instance details Defined in Data.Constraint Methods ins :: () :- Functor (Either a) #
() :=> (Functor (Const a :: Type -> Type))
Instance details Defined in Data.Constraint Methods ins :: () :- Functor (Const a) #
() :=> (Functor Identity)
Instance details Defined in Data.Constraint Methods ins :: () :- Functor Identity #
() :=> (Functor IO)
Instance details Defined in Data.Constraint Methods ins :: () :- Functor IO #
() :=> (Functor Maybe)
Instance details Defined in Data.Constraint Methods ins :: () :- Functor Maybe #
() :=> (Functor ((,) a))
Instance details Defined in Data.Constraint Methods ins :: () :- Functor ((,) a) #
() :=> (Functor ((->) a))
Instance details Defined in Data.Constraint Methods ins :: () :- Functor ((->) a) #
() :=> (Functor [])
Instance details Defined in Data.Constraint Methods ins :: () :- Functor [] #
Class () (Functor f)
Instance details Defined in Data.Constraint Methods cls :: Functor f :- () #
Functor f => Functor (Co f)
Instance details Defined in Data.Functor.Rep Methods fmap :: (a -> b) -> Co f a -> Co f b # (<$) :: a -> Co f b -> Co f a #
Functor (IResult i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods fmap :: (a -> b) -> IResult i a -> IResult i b # (<$) :: a -> IResult i b -> IResult i a #
Functor (Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods fmap :: (a -> b) -> Parser i a -> Parser i b # (<$) :: a -> Parser i b -> Parser i a #
Monad m => Functor (WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a #
Arrow a => Functor (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 #
Functor (Either a)	Since: base-3.0
Instance details Defined in Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Functor (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods fmap :: (a -> b) -> Proxy a -> Proxy b # (<$) :: a -> Proxy b -> Proxy a #
Functor (Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a0 -> b) -> Arg a a0 -> Arg a b # (<$) :: a0 -> Arg a b -> Arg a a0 #
Functor (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> U1 a -> U1 b # (<$) :: a -> U1 b -> U1 a #
Functor (V1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> V1 a -> V1 b # (<$) :: a -> V1 b -> V1 a #
Functor (ST s)	Since: base-2.1
Instance details Defined in GHC.ST Methods fmap :: (a -> b) -> ST s a -> ST s b # (<$) :: a -> ST s b -> ST s a #
Functor (SetM s)
Instance details Defined in Data.Graph Methods fmap :: (a -> b) -> SetM s a -> SetM s b # (<$) :: a -> SetM s b -> SetM s a #
Functor (Map k)
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> Map k a -> Map k b # (<$) :: a -> Map k b -> Map k a #
DRG gen => Functor (MonadPseudoRandom gen)
Instance details Defined in Crypto.Random.Types Methods fmap :: (a -> b) -> MonadPseudoRandom gen a -> MonadPseudoRandom gen b # (<$) :: a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen a #
Monad m => Functor (Handler m)
Instance details Defined in Control.Monad.Catch Methods fmap :: (a -> b) -> Handler m a -> Handler m b # (<$) :: a -> Handler m b -> Handler m a #
Functor f => Functor (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods fmap :: (a -> b) -> Cofree f a -> Cofree f b # (<$) :: a -> Cofree f b -> Cofree f a #
Functor f => Functor (Free f)
Instance details Defined in Control.Monad.Free Methods fmap :: (a -> b) -> Free f a -> Free f b # (<$) :: a -> Free f b -> Free f a #
Functor (RootsOfUnity n)
Instance details Defined in Data.Field.Galois.Unity Methods fmap :: (a -> b) -> RootsOfUnity n a -> RootsOfUnity n b # (<$) :: a -> RootsOfUnity n b -> RootsOfUnity n a #
Functor (Program instr) Source #
Instance details Defined in Indigo.Frontend.Program Methods fmap :: (a -> b) -> Program instr a -> Program instr b # (<$) :: a -> Program instr b -> Program instr a #
Functor (Yoneda f)
Instance details Defined in Data.Functor.Yoneda Methods fmap :: (a -> b) -> Yoneda f a -> Yoneda f b # (<$) :: a -> Yoneda f b -> Yoneda f a #
Functor f => Functor (Indexing f)
Instance details Defined in Control.Lens.Internal.Indexed Methods fmap :: (a -> b) -> Indexing f a -> Indexing f b # (<$) :: a -> Indexing f b -> Indexing f a #
Functor f => Functor (Indexing64 f)
Instance details Defined in Control.Lens.Internal.Indexed Methods fmap :: (a -> b) -> Indexing64 f a -> Indexing64 f b # (<$) :: a -> Indexing64 f b -> Indexing64 f a #
Functor (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods fmap :: (a -> b) -> ReifiedFold s a -> ReifiedFold s b # (<$) :: a -> ReifiedFold s b -> ReifiedFold s a #
Functor (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods fmap :: (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b # (<$) :: a -> ReifiedGetter s b -> ReifiedGetter s a #
Functor (Annotation :: Type -> Type)
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods fmap :: (a -> b) -> Annotation a -> Annotation b # (<$) :: a -> Annotation b -> Annotation a #
Functor (SizedList' n)
Instance details Defined in Morley.Util.SizedList Methods fmap :: (a -> b) -> SizedList' n a -> SizedList' n b # (<$) :: a -> SizedList' n b -> SizedList' n a #
Functor (Either a)
Instance details Defined in Data.Strict.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Functor (These a)
Instance details Defined in Data.Strict.These Methods fmap :: (a0 -> b) -> These a a0 -> These a b # (<$) :: a0 -> These a b -> These a a0 #
Functor (Pair e)
Instance details Defined in Data.Strict.Tuple Methods fmap :: (a -> b) -> Pair e a -> Pair e b # (<$) :: a -> Pair e b -> Pair e a #
Functor (These a)
Instance details Defined in Data.These Methods fmap :: (a0 -> b) -> These a a0 -> These a b # (<$) :: a0 -> These a b -> These a a0 #
Functor m => Functor (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fmap :: (a -> b) -> MaybeT m a -> MaybeT m b # (<$) :: a -> MaybeT m b -> MaybeT m a #
Functor (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods fmap :: (a -> b) -> HashMap k a -> HashMap k b # (<$) :: a -> HashMap k b -> HashMap k a #
Functor ((,) a)	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b) -> (a, a0) -> (a, b) # (<$) :: a0 -> (a, b) -> (a, a0) #
(Monad m) :=> (Functor (WrappedMonad m))
Instance details Defined in Data.Constraint Methods ins :: Monad m :- Functor (WrappedMonad m) #
Class (Functor f) (Applicative f)
Instance details Defined in Data.Constraint Methods cls :: Applicative f :- Functor f #
Functor m => Functor (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods fmap :: (a -> b) -> RandT g m a -> RandT g m b # (<$) :: a -> RandT g m b -> RandT g m a #
Functor m => Functor (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Strict Methods fmap :: (a -> b) -> RandT g m a -> RandT g m b # (<$) :: a -> RandT g m b -> RandT g m a #
Arrow a => Functor (WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 #
Functor m => Functor (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods fmap :: (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b # (<$) :: a0 -> Kleisli m a b -> Kleisli m a a0 #
Functor (Const m :: Type -> Type)	Since: base-2.1
Instance details Defined in Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b # (<$) :: a -> Const m b -> Const m a #
Functor f => Functor (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Ap f a -> Ap f b # (<$) :: a -> Ap f b -> Ap f a #
Functor f => Functor (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Alt f a -> Alt f b # (<$) :: a -> Alt f b -> Alt f a #
Functor f => Functor (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b # (<$) :: a -> Rec1 f b -> Rec1 f a #
Functor (URec (Ptr ()) :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a #
Functor (URec Char :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Functor (URec Double :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Functor (URec Float :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Functor (URec Int :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Functor (URec Word :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Bifunctor p => Functor (Fix p)
Instance details Defined in Data.Bifunctor.Fix Methods fmap :: (a -> b) -> Fix p a -> Fix p b # (<$) :: a -> Fix p b -> Fix p a #
Bifunctor p => Functor (Join p)
Instance details Defined in Data.Bifunctor.Join Methods fmap :: (a -> b) -> Join p a -> Join p b # (<$) :: a -> Join p b -> Join p a #
(Applicative f, Monad f) => Functor (WhenMissing f x)	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> WhenMissing f x a -> WhenMissing f x b # (<$) :: a -> WhenMissing f x b -> WhenMissing f x a #
Functor f => Functor (CofreeF f a)
Instance details Defined in Control.Comonad.Trans.Cofree Methods fmap :: (a0 -> b) -> CofreeF f a a0 -> CofreeF f a b # (<$) :: a0 -> CofreeF f a b -> CofreeF f a a0 #
(Functor f, Functor w) => Functor (CofreeT f w)
Instance details Defined in Control.Comonad.Trans.Cofree Methods fmap :: (a -> b) -> CofreeT f w a -> CofreeT f w b # (<$) :: a -> CofreeT f w b -> CofreeT f w a #
Functor f => Functor (FreeF f a)
Instance details Defined in Control.Monad.Trans.Free Methods fmap :: (a0 -> b) -> FreeF f a a0 -> FreeF f a b # (<$) :: a0 -> FreeF f a b -> FreeF f a a0 #
(Functor f, Monad m) => Functor (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods fmap :: (a -> b) -> FreeT f m a -> FreeT f m b # (<$) :: a -> FreeT f m b -> FreeT f m a #
Functor (Day f g)
Instance details Defined in Data.Functor.Day Methods fmap :: (a -> b) -> Day f g a -> Day f g b # (<$) :: a -> Day f g b -> Day f g a #
Functor (Indexed i a)
Instance details Defined in Control.Lens.Internal.Indexed Methods fmap :: (a0 -> b) -> Indexed i a a0 -> Indexed i a b # (<$) :: a0 -> Indexed i a b -> Indexed i a a0 #
Functor (ReifiedIndexedFold i s)
Instance details Defined in Control.Lens.Reified Methods fmap :: (a -> b) -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s b # (<$) :: a -> ReifiedIndexedFold i s b -> ReifiedIndexedFold i s a #
Functor (ReifiedIndexedGetter i s)
Instance details Defined in Control.Lens.Reified Methods fmap :: (a -> b) -> ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b # (<$) :: a -> ReifiedIndexedGetter i s b -> ReifiedIndexedGetter i s a #
Functor (Effect m r)
Instance details Defined in Lens.Micro.Mtl.Internal Methods fmap :: (a -> b) -> Effect m r a -> Effect m r b # (<$) :: a -> Effect m r b -> Effect m r a #
Monad m => Functor (Focusing m s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods fmap :: (a -> b) -> Focusing m s a -> Focusing m s b # (<$) :: a -> Focusing m s b -> Focusing m s a #
Functor (k (May s)) => Functor (FocusingMay k s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods fmap :: (a -> b) -> FocusingMay k s a -> FocusingMay k s b # (<$) :: a -> FocusingMay k s b -> FocusingMay k s a #
Functor f => Functor (ApplicativeBoolean f)
Instance details Defined in Morley.Prelude.Boolean Methods fmap :: (a -> b) -> ApplicativeBoolean f a -> ApplicativeBoolean f b # (<$) :: a -> ApplicativeBoolean f b -> ApplicativeBoolean f a #
Profunctor p => Functor (Coprep p)
Instance details Defined in Data.Profunctor.Rep Methods fmap :: (a -> b) -> Coprep p a -> Coprep p b # (<$) :: a -> Coprep p b -> Coprep p a #
Profunctor p => Functor (Prep p)
Instance details Defined in Data.Profunctor.Rep Methods fmap :: (a -> b) -> Prep p a -> Prep p b # (<$) :: a -> Prep p b -> Prep p a #
Functor (Tagged s)
Instance details Defined in Data.Tagged Methods fmap :: (a -> b) -> Tagged s a -> Tagged s b # (<$) :: a -> Tagged s b -> Tagged s a #
(Functor f, Functor g) => Functor (These1 f g)
Instance details Defined in Data.Functor.These Methods fmap :: (a -> b) -> These1 f g a -> These1 f g b # (<$) :: a -> These1 f g b -> These1 f g a #
Functor m => Functor (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods fmap :: (a -> b) -> ErrorT e m a -> ErrorT e m b # (<$) :: a -> ErrorT e m b -> ErrorT e m a #
Functor m => Functor (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b # (<$) :: a -> ExceptT e m b -> ExceptT e m a #
Functor m => Functor (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods fmap :: (a -> b) -> IdentityT m a -> IdentityT m b # (<$) :: a -> IdentityT m b -> IdentityT m a #
Functor m => Functor (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b # (<$) :: a -> ReaderT r m b -> ReaderT r m a #
Functor m => Functor (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Functor m => Functor (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Functor (Const a :: Type -> Type)
Instance details Defined in Data.Vinyl.Functor Methods fmap :: (a0 -> b) -> Const a a0 -> Const a b # (<$) :: a0 -> Const a b -> Const a a0 #
Functor ((,,) a b)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, a0) -> (a, b, b0) # (<$) :: a0 -> (a, b, b0) -> (a, b, a0) #
(Functor f, Functor g) => Functor (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods fmap :: (a -> b) -> Product f g a -> Product f g b # (<$) :: a -> Product f g b -> Product f g a #
(Functor f, Functor g) => Functor (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods fmap :: (a -> b) -> Sum f g a -> Sum f g b # (<$) :: a -> Sum f g b -> Sum f g a #
(Functor f, Functor g) => Functor (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :: g) a -> (f :: g) b # (<$) :: a -> (f :: g) b -> (f :: g) a #
(Functor f, Functor g) => Functor (f :+: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b # (<$) :: a -> (f :+: g) b -> (f :+: g) a #
Functor (K1 i c :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> K1 i c a -> K1 i c b # (<$) :: a -> K1 i c b -> K1 i c a #
Functor f => Functor (WhenMatched f x y)	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # (<$) :: a -> WhenMatched f x y b -> WhenMatched f x y a #
(Applicative f, Monad f) => Functor (WhenMissing f k x)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # (<$) :: a -> WhenMissing f k x b -> WhenMissing f k x a #
Functor (k (Err e s)) => Functor (FocusingErr e k s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods fmap :: (a -> b) -> FocusingErr e k s a -> FocusingErr e k s b # (<$) :: a -> FocusingErr e k s b -> FocusingErr e k s a #
Functor (k (f s)) => Functor (FocusingOn f k s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods fmap :: (a -> b) -> FocusingOn f k s a -> FocusingOn f k s b # (<$) :: a -> FocusingOn f k s b -> FocusingOn f k s a #
Functor (k (s, w)) => Functor (FocusingPlus w k s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods fmap :: (a -> b) -> FocusingPlus w k s a -> FocusingPlus w k s b # (<$) :: a -> FocusingPlus w k s b -> FocusingPlus w k s a #
Monad m => Functor (FocusingWith w m s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods fmap :: (a -> b) -> FocusingWith w m s a -> FocusingWith w m s b # (<$) :: a -> FocusingWith w m s b -> FocusingWith w m s a #
Functor ((,,,) a b c)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) # (<$) :: a0 -> (a, b, c, b0) -> (a, b, c, a0) #
Functor ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> (r -> a) -> r -> b # (<$) :: a -> (r -> b) -> r -> a #
(Functor f, Functor g) => Functor (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fmap :: (a -> b) -> Compose f g a -> Compose f g b # (<$) :: a -> Compose f g b -> Compose f g a #
(Functor f, Functor g) => Functor (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b # (<$) :: a -> (f :.: g) b -> (f :.: g) a #
Functor f => Functor (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> M1 i c f a -> M1 i c f b # (<$) :: a -> M1 i c f b -> M1 i c f a #
Functor (Clown f a :: Type -> Type)
Instance details Defined in Data.Bifunctor.Clown Methods fmap :: (a0 -> b) -> Clown f a a0 -> Clown f a b # (<$) :: a0 -> Clown f a b -> Clown f a a0 #
Bifunctor p => Functor (Flip p a)
Instance details Defined in Data.Bifunctor.Flip Methods fmap :: (a0 -> b) -> Flip p a a0 -> Flip p a b # (<$) :: a0 -> Flip p a b -> Flip p a a0 #
Functor g => Functor (Joker g a)
Instance details Defined in Data.Bifunctor.Joker Methods fmap :: (a0 -> b) -> Joker g a a0 -> Joker g a b # (<$) :: a0 -> Joker g a b -> Joker g a a0 #
Bifunctor p => Functor (WrappedBifunctor p a)
Instance details Defined in Data.Bifunctor.Wrapped Methods fmap :: (a0 -> b) -> WrappedBifunctor p a a0 -> WrappedBifunctor p a b # (<$) :: a0 -> WrappedBifunctor p a b -> WrappedBifunctor p a a0 #
Functor f => Functor (WhenMatched f k x y)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # (<$) :: a -> WhenMatched f k x y b -> WhenMatched f k x y a #
Functor (EffectRWS w st m s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods fmap :: (a -> b) -> EffectRWS w st m s a -> EffectRWS w st m s b # (<$) :: a -> EffectRWS w st m s b -> EffectRWS w st m s a #
Reifies s (ReifiedApplicative f) => Functor (ReflectedApplicative f s)
Instance details Defined in Data.Reflection Methods fmap :: (a -> b) -> ReflectedApplicative f s a -> ReflectedApplicative f s b # (<$) :: a -> ReflectedApplicative f s b -> ReflectedApplicative f s a #
(Functor f, Functor g) => Functor (Compose f g)
Instance details Defined in Data.Vinyl.Functor Methods fmap :: (a -> b) -> Compose f g a -> Compose f g b # (<$) :: a -> Compose f g b -> Compose f g a #
Monad state => Functor (Builder collection mutCollection step state err)
Instance details Defined in Basement.MutableBuilder Methods fmap :: (a -> b) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b # (<$) :: a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err a #
(Functor f, Bifunctor p) => Functor (Tannen f p a)
Instance details Defined in Data.Bifunctor.Tannen Methods fmap :: (a0 -> b) -> Tannen f p a a0 -> Tannen f p a b # (<$) :: a0 -> Tannen f p a b -> Tannen f p a a0 #
Profunctor p => Functor (Procompose p q a)
Instance details Defined in Data.Profunctor.Composition Methods fmap :: (a0 -> b) -> Procompose p q a a0 -> Procompose p q a b # (<$) :: a0 -> Procompose p q a b -> Procompose p q a a0 #
Profunctor p => Functor (Rift p q a)
Instance details Defined in Data.Profunctor.Composition Methods fmap :: (a0 -> b) -> Rift p q a a0 -> Rift p q a b # (<$) :: a0 -> Rift p q a b -> Rift p q a a0 #
(Functor f, Functor g) => Functor (Lift Either f g)
Instance details Defined in Data.Vinyl.Functor Methods fmap :: (a -> b) -> Lift Either f g a -> Lift Either f g b # (<$) :: a -> Lift Either f g b -> Lift Either f g a #
(Functor f, Functor g) => Functor (Lift (,) f g)
Instance details Defined in Data.Vinyl.Functor Methods fmap :: (a -> b) -> Lift (,) f g a -> Lift (,) f g b # (<$) :: a -> Lift (,) f g b -> Lift (,) f g a #
(Bifunctor p, Functor g) => Functor (Biff p f g a)
Instance details Defined in Data.Bifunctor.Biff Methods fmap :: (a0 -> b) -> Biff p f g a a0 -> Biff p f g a b # (<$) :: a0 -> Biff p f g a b -> Biff p f g a a0 #

class Num a where #

Basic numeric class.

The Haskell Report defines no laws for Num. However, (+) and (*) are customarily expected to define a ring and have the following properties:

Associativity of (+): (x + y) + z = x + (y + z)
Commutativity of (+): x + y = y + x
fromInteger 0 is the additive identity: x + fromInteger 0 = x
negate gives the additive inverse: x + negate x = fromInteger 0
Associativity of (*): (x * y) * z = x * (y * z)
fromInteger 1 is the multiplicative identity: x * fromInteger 1 = x and fromInteger 1 * x = x
Distributivity of (*) with respect to (+): a * (b + c) = (a * b) + (a * c) and (b + c) * a = (b * a) + (c * a)

Note that it isn't customarily expected that a type instance of both Num and Ord implement an ordered ring. Indeed, in base only Integer and Rational do.

Minimal complete definition

(+), (*), abs, signum, fromInteger, (negate | (-))

Methods

negate :: a -> a #

Unary negation.

signum :: a -> a #

Sign of a number. The functions abs and signum should satisfy the law:

abs x * signum x == x

For real numbers, the signum is either -1 (negative), 0 (zero) or 1 (positive).

Instances

Instances details

Num Pos
Instance details Defined in Data.Attoparsec.Internal.Types Methods (+) :: Pos -> Pos -> Pos # (-) :: Pos -> Pos -> Pos # (*) :: Pos -> Pos -> Pos # negate :: Pos -> Pos # abs :: Pos -> Pos # signum :: Pos -> Pos # fromInteger :: Integer -> Pos #
Num Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int16 -> Int16 -> Int16 # (-) :: Int16 -> Int16 -> Int16 # (*) :: Int16 -> Int16 -> Int16 # negate :: Int16 -> Int16 # abs :: Int16 -> Int16 # signum :: Int16 -> Int16 # fromInteger :: Integer -> Int16 #
Num Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int32 -> Int32 -> Int32 # (-) :: Int32 -> Int32 -> Int32 # (*) :: Int32 -> Int32 -> Int32 # negate :: Int32 -> Int32 # abs :: Int32 -> Int32 # signum :: Int32 -> Int32 # fromInteger :: Integer -> Int32 #
Num Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int64 -> Int64 -> Int64 # (-) :: Int64 -> Int64 -> Int64 # (*) :: Int64 -> Int64 -> Int64 # negate :: Int64 -> Int64 # abs :: Int64 -> Int64 # signum :: Int64 -> Int64 # fromInteger :: Integer -> Int64 #
Num Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int8 -> Int8 -> Int8 # (-) :: Int8 -> Int8 -> Int8 # (*) :: Int8 -> Int8 -> Int8 # negate :: Int8 -> Int8 # abs :: Int8 -> Int8 # signum :: Int8 -> Int8 # fromInteger :: Integer -> Int8 #
Num Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word16 -> Word16 -> Word16 # (-) :: Word16 -> Word16 -> Word16 # (*) :: Word16 -> Word16 -> Word16 # negate :: Word16 -> Word16 # abs :: Word16 -> Word16 # signum :: Word16 -> Word16 # fromInteger :: Integer -> Word16 #
Num Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word32 -> Word32 -> Word32 # (-) :: Word32 -> Word32 -> Word32 # (*) :: Word32 -> Word32 -> Word32 # negate :: Word32 -> Word32 # abs :: Word32 -> Word32 # signum :: Word32 -> Word32 # fromInteger :: Integer -> Word32 #
Num Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Num F2Poly	Addition and multiplication are evaluated modulo 2. `abs` = `id` and `signum` = `const` 1. `fromInteger` converts a binary polynomial, encoded as `Integer`, to `F2Poly` encoding.
Instance details Defined in Data.Bit.F2Poly Methods (+) :: F2Poly -> F2Poly -> F2Poly # (-) :: F2Poly -> F2Poly -> F2Poly # (*) :: F2Poly -> F2Poly -> F2Poly # negate :: F2Poly -> F2Poly # abs :: F2Poly -> F2Poly # signum :: F2Poly -> F2Poly # fromInteger :: Integer -> F2Poly #
Num Bit	There is only one lawful `Num` instance possible with `+` = `xor` and `fromInteger` = `Bit` . `odd`.
Instance details Defined in Data.Bit.Internal Methods (+) :: Bit -> Bit -> Bit # (-) :: Bit -> Bit -> Bit # (*) :: Bit -> Bit -> Bit # negate :: Bit -> Bit # abs :: Bit -> Bit # signum :: Bit -> Bit # fromInteger :: Integer -> Bit #
Num TimeSpec
Instance details Defined in System.Clock Methods (+) :: TimeSpec -> TimeSpec -> TimeSpec # (-) :: TimeSpec -> TimeSpec -> TimeSpec # (*) :: TimeSpec -> TimeSpec -> TimeSpec # negate :: TimeSpec -> TimeSpec # abs :: TimeSpec -> TimeSpec # signum :: TimeSpec -> TimeSpec # fromInteger :: Integer -> TimeSpec #
Num RefId Source #
Instance details Defined in Indigo.Common.Var Methods (+) :: RefId -> RefId -> RefId # (-) :: RefId -> RefId -> RefId # (*) :: RefId -> RefId -> RefId # negate :: RefId -> RefId # abs :: RefId -> RefId # signum :: RefId -> RefId # fromInteger :: Integer -> RefId #
Num RemainingSteps
Instance details Defined in Morley.Michelson.Interpret Methods (+) :: RemainingSteps -> RemainingSteps -> RemainingSteps # (-) :: RemainingSteps -> RemainingSteps -> RemainingSteps # (*) :: RemainingSteps -> RemainingSteps -> RemainingSteps # negate :: RemainingSteps -> RemainingSteps # abs :: RemainingSteps -> RemainingSteps # signum :: RemainingSteps -> RemainingSteps # fromInteger :: Integer -> RemainingSteps #
Num BigMapCounter
Instance details Defined in Morley.Michelson.Runtime.GState Methods (+) :: BigMapCounter -> BigMapCounter -> BigMapCounter # (-) :: BigMapCounter -> BigMapCounter -> BigMapCounter # (*) :: BigMapCounter -> BigMapCounter -> BigMapCounter # negate :: BigMapCounter -> BigMapCounter # abs :: BigMapCounter -> BigMapCounter # signum :: BigMapCounter -> BigMapCounter # fromInteger :: Integer -> BigMapCounter #
Num GlobalCounter
Instance details Defined in Morley.Tezos.Address Methods (+) :: GlobalCounter -> GlobalCounter -> GlobalCounter # (-) :: GlobalCounter -> GlobalCounter -> GlobalCounter # (*) :: GlobalCounter -> GlobalCounter -> GlobalCounter # negate :: GlobalCounter -> GlobalCounter # abs :: GlobalCounter -> GlobalCounter # signum :: GlobalCounter -> GlobalCounter # fromInteger :: Integer -> GlobalCounter #
Num Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (+) :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # (-) :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # (*) :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # negate :: Bls12381Fr -> Bls12381Fr # abs :: Bls12381Fr -> Bls12381Fr # signum :: Bls12381Fr -> Bls12381Fr # fromInteger :: Integer -> Bls12381Fr #
Num Scientific	WARNING: `+` and `-` compute the `Integer` magnitude: `10^e` where `e` is the difference between the `base10Exponents` of the arguments. If these methods are applied to arguments which have huge exponents this could fill up all space and crash your program! So don't apply these methods to scientific numbers coming from untrusted sources. The other methods can be used safely.
Instance details Defined in Data.Scientific Methods (+) :: Scientific -> Scientific -> Scientific # (-) :: Scientific -> Scientific -> Scientific # (*) :: Scientific -> Scientific -> Scientific # negate :: Scientific -> Scientific # abs :: Scientific -> Scientific # signum :: Scientific -> Scientific # fromInteger :: Integer -> Scientific #
Num CodePoint
Instance details Defined in Data.Text.Encoding Methods (+) :: CodePoint -> CodePoint -> CodePoint # (-) :: CodePoint -> CodePoint -> CodePoint # (*) :: CodePoint -> CodePoint -> CodePoint # negate :: CodePoint -> CodePoint # abs :: CodePoint -> CodePoint # signum :: CodePoint -> CodePoint # fromInteger :: Integer -> CodePoint #
Num DecoderState
Instance details Defined in Data.Text.Encoding Methods (+) :: DecoderState -> DecoderState -> DecoderState # (-) :: DecoderState -> DecoderState -> DecoderState # (*) :: DecoderState -> DecoderState -> DecoderState # negate :: DecoderState -> DecoderState # abs :: DecoderState -> DecoderState # signum :: DecoderState -> DecoderState # fromInteger :: Integer -> DecoderState #
Num B
Instance details Defined in Data.Text.Short.Internal Methods (+) :: B -> B -> B # (-) :: B -> B -> B # (*) :: B -> B -> B # negate :: B -> B # abs :: B -> B # signum :: B -> B # fromInteger :: Integer -> B #
Num NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (+) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # (-) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # (*) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # negate :: NominalDiffTime -> NominalDiffTime # abs :: NominalDiffTime -> NominalDiffTime # signum :: NominalDiffTime -> NominalDiffTime # fromInteger :: Integer -> NominalDiffTime #
Num Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word8 -> Word8 -> Word8 # (-) :: Word8 -> Word8 -> Word8 # (*) :: Word8 -> Word8 -> Word8 # negate :: Word8 -> Word8 # abs :: Word8 -> Word8 # signum :: Word8 -> Word8 # fromInteger :: Integer -> Word8 #
Num Integer	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Integer -> Integer -> Integer # (-) :: Integer -> Integer -> Integer # (*) :: Integer -> Integer -> Integer # negate :: Integer -> Integer # abs :: Integer -> Integer # signum :: Integer -> Integer # fromInteger :: Integer -> Integer #
Num Natural	Note that `Natural`'s `Num` instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though. Since: base-4.8.0.0
Instance details Defined in GHC.Num Methods (+) :: Natural -> Natural -> Natural # (-) :: Natural -> Natural -> Natural # (*) :: Natural -> Natural -> Natural # negate :: Natural -> Natural # abs :: Natural -> Natural # signum :: Natural -> Natural # fromInteger :: Integer -> Natural #
Num Int	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Int -> Int -> Int # (-) :: Int -> Int -> Int # (*) :: Int -> Int -> Int # negate :: Int -> Int # abs :: Int -> Int # signum :: Int -> Int # fromInteger :: Integer -> Int #
Num Word	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Word -> Word -> Word # (-) :: Word -> Word -> Word # (*) :: Word -> Word -> Word # negate :: Word -> Word # abs :: Word -> Word # signum :: Word -> Word # fromInteger :: Integer -> Word #
() :=> (Num Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Integer #
() :=> (Num Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Natural #
() :=> (Num Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Double #
() :=> (Num Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Float #
() :=> (Num Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Int #
() :=> (Num Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Word #
Class () (Num a)
Instance details Defined in Data.Constraint Methods cls :: Num a :- () #
RealFloat a => Num (Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods (+) :: Complex a -> Complex a -> Complex a # (-) :: Complex a -> Complex a -> Complex a # (*) :: Complex a -> Complex a -> Complex a # negate :: Complex a -> Complex a # abs :: Complex a -> Complex a # signum :: Complex a -> Complex a # fromInteger :: Integer -> Complex a #
Num a => Num (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (+) :: Identity a -> Identity a -> Identity a # (-) :: Identity a -> Identity a -> Identity a # (*) :: Identity a -> Identity a -> Identity a # negate :: Identity a -> Identity a # abs :: Identity a -> Identity a # signum :: Identity a -> Identity a # fromInteger :: Integer -> Identity a #
Num a => Num (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (+) :: Down a -> Down a -> Down a # (-) :: Down a -> Down a -> Down a # (*) :: Down a -> Down a -> Down a # negate :: Down a -> Down a # abs :: Down a -> Down a # signum :: Down a -> Down a # fromInteger :: Integer -> Down a #
Num a => Num (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (+) :: Max a -> Max a -> Max a # (-) :: Max a -> Max a -> Max a # (*) :: Max a -> Max a -> Max a # negate :: Max a -> Max a # abs :: Max a -> Max a # signum :: Max a -> Max a # fromInteger :: Integer -> Max a #
Num a => Num (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (+) :: Min a -> Min a -> Min a # (-) :: Min a -> Min a -> Min a # (*) :: Min a -> Min a -> Min a # negate :: Min a -> Min a # abs :: Min a -> Min a # signum :: Min a -> Min a # fromInteger :: Integer -> Min a #
Num a => Num (Product a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Product a -> Product a -> Product a # (-) :: Product a -> Product a -> Product a # (*) :: Product a -> Product a -> Product a # negate :: Product a -> Product a # abs :: Product a -> Product a # signum :: Product a -> Product a # fromInteger :: Integer -> Product a #
Num a => Num (Sum a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Sum a -> Sum a -> Sum a # (-) :: Sum a -> Sum a -> Sum a # (*) :: Sum a -> Sum a -> Sum a # negate :: Sum a -> Sum a # abs :: Sum a -> Sum a # signum :: Sum a -> Sum a # fromInteger :: Integer -> Sum a #
Integral a => Num (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (+) :: Ratio a -> Ratio a -> Ratio a # (-) :: Ratio a -> Ratio a -> Ratio a # (*) :: Ratio a -> Ratio a -> Ratio a # negate :: Ratio a -> Ratio a # abs :: Ratio a -> Ratio a # signum :: Ratio a -> Ratio a # fromInteger :: Integer -> Ratio a #
KnownNat n => Num (Zn n)
Instance details Defined in Basement.Bounded Methods (+) :: Zn n -> Zn n -> Zn n # (-) :: Zn n -> Zn n -> Zn n # (*) :: Zn n -> Zn n -> Zn n # negate :: Zn n -> Zn n # abs :: Zn n -> Zn n # signum :: Zn n -> Zn n # fromInteger :: Integer -> Zn n #
(KnownNat n, NatWithinBound Word64 n) => Num (Zn64 n)
Instance details Defined in Basement.Bounded Methods (+) :: Zn64 n -> Zn64 n -> Zn64 n # (-) :: Zn64 n -> Zn64 n -> Zn64 n # (*) :: Zn64 n -> Zn64 n -> Zn64 n # negate :: Zn64 n -> Zn64 n # abs :: Zn64 n -> Zn64 n # signum :: Zn64 n -> Zn64 n # fromInteger :: Integer -> Zn64 n #
Num (CountOf ty)
Instance details Defined in Basement.Types.OffsetSize Methods (+) :: CountOf ty -> CountOf ty -> CountOf ty # (-) :: CountOf ty -> CountOf ty -> CountOf ty # (*) :: CountOf ty -> CountOf ty -> CountOf ty # negate :: CountOf ty -> CountOf ty # abs :: CountOf ty -> CountOf ty # signum :: CountOf ty -> CountOf ty # fromInteger :: Integer -> CountOf ty #
Num (Offset ty)
Instance details Defined in Basement.Types.OffsetSize Methods (+) :: Offset ty -> Offset ty -> Offset ty # (-) :: Offset ty -> Offset ty -> Offset ty # (*) :: Offset ty -> Offset ty -> Offset ty # negate :: Offset ty -> Offset ty # abs :: Offset ty -> Offset ty # signum :: Offset ty -> Offset ty # fromInteger :: Integer -> Offset ty #
KnownNat p => Num (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods (+) :: Binary p -> Binary p -> Binary p # (-) :: Binary p -> Binary p -> Binary p # (*) :: Binary p -> Binary p -> Binary p # negate :: Binary p -> Binary p # abs :: Binary p -> Binary p # signum :: Binary p -> Binary p # fromInteger :: Integer -> Binary p #
KnownNat p => Num (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods (+) :: Prime p -> Prime p -> Prime p # (-) :: Prime p -> Prime p -> Prime p # (*) :: Prime p -> Prime p -> Prime p # negate :: Prime p -> Prime p # abs :: Prime p -> Prime p # signum :: Prime p -> Prime p # fromInteger :: Integer -> Prime p #
KnownNat m => Num (Mod m)
Instance details Defined in Data.Mod Methods (+) :: Mod m -> Mod m -> Mod m # (-) :: Mod m -> Mod m -> Mod m # (*) :: Mod m -> Mod m -> Mod m # negate :: Mod m -> Mod m # abs :: Mod m -> Mod m # signum :: Mod m -> Mod m # fromInteger :: Integer -> Mod m #
Num a => Num (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods (+) :: StringEncode a -> StringEncode a -> StringEncode a # (-) :: StringEncode a -> StringEncode a -> StringEncode a # (*) :: StringEncode a -> StringEncode a -> StringEncode a # negate :: StringEncode a -> StringEncode a # abs :: StringEncode a -> StringEncode a # signum :: StringEncode a -> StringEncode a # fromInteger :: Integer -> StringEncode a #
Num a => Num (Add a)
Instance details Defined in Data.Semiring Methods (+) :: Add a -> Add a -> Add a # (-) :: Add a -> Add a -> Add a # (*) :: Add a -> Add a -> Add a # negate :: Add a -> Add a # abs :: Add a -> Add a # signum :: Add a -> Add a # fromInteger :: Integer -> Add a #
Num a => Num (Mul a)
Instance details Defined in Data.Semiring Methods (+) :: Mul a -> Mul a -> Mul a # (-) :: Mul a -> Mul a -> Mul a # (*) :: Mul a -> Mul a -> Mul a # negate :: Mul a -> Mul a # abs :: Mul a -> Mul a # signum :: Mul a -> Mul a # fromInteger :: Integer -> Mul a #
Num a => Num (WrappedNum a)
Instance details Defined in Data.Semiring Methods (+) :: WrappedNum a -> WrappedNum a -> WrappedNum a # (-) :: WrappedNum a -> WrappedNum a -> WrappedNum a # (*) :: WrappedNum a -> WrappedNum a -> WrappedNum a # negate :: WrappedNum a -> WrappedNum a # abs :: WrappedNum a -> WrappedNum a # signum :: WrappedNum a -> WrappedNum a # fromInteger :: Integer -> WrappedNum a #
(Num t, KnownSymbol s) => Num (ElField '(s, t))
Instance details Defined in Data.Vinyl.Functor Methods (+) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # (-) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # (*) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # negate :: ElField '(s, t) -> ElField '(s, t) # abs :: ElField '(s, t) -> ElField '(s, t) # signum :: ElField '(s, t) -> ElField '(s, t) # fromInteger :: Integer -> ElField '(s, t) #
(RealFloat a) :=> (Num (Complex a))
Instance details Defined in Data.Constraint Methods ins :: RealFloat a :- Num (Complex a) #
(Num a) :=> (Num (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Num a :- Num (Const a b) #
(Num a) :=> (Num (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Num a :- Num (Identity a) #
(Integral a) :=> (Num (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Num (Ratio a) #
Class (Num a) (Fractional a)
Instance details Defined in Data.Constraint Methods cls :: Fractional a :- Num a #
(Num a, Bits a, TypeNum n) => Num (OddWord a n)
Instance details Defined in Data.Word.Odd Methods (+) :: OddWord a n -> OddWord a n -> OddWord a n # (-) :: OddWord a n -> OddWord a n -> OddWord a n # (*) :: OddWord a n -> OddWord a n -> OddWord a n # negate :: OddWord a n -> OddWord a n # abs :: OddWord a n -> OddWord a n # signum :: OddWord a n -> OddWord a n # fromInteger :: Integer -> OddWord a n #
HasResolution a => Num (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods (+) :: Fixed a -> Fixed a -> Fixed a # (-) :: Fixed a -> Fixed a -> Fixed a # (*) :: Fixed a -> Fixed a -> Fixed a # negate :: Fixed a -> Fixed a # abs :: Fixed a -> Fixed a # signum :: Fixed a -> Fixed a # fromInteger :: Integer -> Fixed a #
IrreducibleMonic p k => Num (Extension p k)
Instance details Defined in Data.Field.Galois.Extension Methods (+) :: Extension p k -> Extension p k -> Extension p k # (-) :: Extension p k -> Extension p k -> Extension p k # (*) :: Extension p k -> Extension p k -> Extension p k # negate :: Extension p k -> Extension p k # abs :: Extension p k -> Extension p k # signum :: Extension p k -> Extension p k # fromInteger :: Integer -> Extension p k #
(Eq a, Num a, Vector v a) => Num (Poly v a)	Note that `abs` = `id` and `signum` = `const` 1.
Instance details Defined in Data.Poly.Internal.Dense Methods (+) :: Poly v a -> Poly v a -> Poly v a # (-) :: Poly v a -> Poly v a -> Poly v a # (*) :: Poly v a -> Poly v a -> Poly v a # negate :: Poly v a -> Poly v a # abs :: Poly v a -> Poly v a # signum :: Poly v a -> Poly v a # fromInteger :: Integer -> Poly v a #
Class (Num a, Ord a) (Real a)
Instance details Defined in Data.Constraint Methods cls :: Real a :- (Num a, Ord a) #
Num a => Num (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (+) :: Const a b -> Const a b -> Const a b # (-) :: Const a b -> Const a b -> Const a b # (*) :: Const a b -> Const a b -> Const a b # negate :: Const a b -> Const a b # abs :: Const a b -> Const a b # signum :: Const a b -> Const a b # fromInteger :: Integer -> Const a b #
(Applicative f, Num a) => Num (Ap f a)	Note that even if the underlying `Num` and `Applicative` instances are lawful, for most `Applicative`s, this instance will not be lawful. If you use this instance with the list `Applicative`, the following customary laws will not hold: Commutativity: `>>>` `Ap [10,20] + Ap [1,2]`Ap {getAp = [11,12,21,22]} `>>>` `Ap [1,2] + Ap [10,20]`Ap {getAp = [11,21,12,22]} Additive inverse: `>>>` `Ap [] + negate (Ap [])`Ap {getAp = []} `>>>` `fromInteger 0 :: Ap [] Int`Ap {getAp = [0]} Distributivity: `>>>` *`Ap [1,2] (3 + 4)`Ap {getAp = [7,14]} `>>>` `(Ap [1,2] * 3) + (Ap [1,2] * 4)`*Ap {getAp = [7,11,10,14]} Since: base-4.12.0.0*
Instance details Defined in Data.Monoid Methods (+) :: Ap f a -> Ap f a -> Ap f a # (-) :: Ap f a -> Ap f a -> Ap f a # (*) :: Ap f a -> Ap f a -> Ap f a # negate :: Ap f a -> Ap f a # abs :: Ap f a -> Ap f a # signum :: Ap f a -> Ap f a # fromInteger :: Integer -> Ap f a #
Num (f a) => Num (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Alt f a -> Alt f a -> Alt f a # (-) :: Alt f a -> Alt f a -> Alt f a # (*) :: Alt f a -> Alt f a -> Alt f a # negate :: Alt f a -> Alt f a # abs :: Alt f a -> Alt f a # signum :: Alt f a -> Alt f a # fromInteger :: Integer -> Alt f a #
Num a => Num (Tagged s a)
Instance details Defined in Data.Tagged Methods (+) :: Tagged s a -> Tagged s a -> Tagged s a # (-) :: Tagged s a -> Tagged s a -> Tagged s a # (*) :: Tagged s a -> Tagged s a -> Tagged s a # negate :: Tagged s a -> Tagged s a # abs :: Tagged s a -> Tagged s a # signum :: Tagged s a -> Tagged s a # fromInteger :: Integer -> Tagged s a #
Num (BigMapId k2 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (+) :: BigMapId k2 v -> BigMapId k2 v -> BigMapId k2 v # (-) :: BigMapId k2 v -> BigMapId k2 v -> BigMapId k2 v # (*) :: BigMapId k2 v -> BigMapId k2 v -> BigMapId k2 v # negate :: BigMapId k2 v -> BigMapId k2 v # abs :: BigMapId k2 v -> BigMapId k2 v # signum :: BigMapId k2 v -> BigMapId k2 v # fromInteger :: Integer -> BigMapId k2 v #

class Eq a => Ord a where #

The Ord class is used for totally ordered datatypes.

Instances of Ord can be derived for any user-defined datatype whose constituent types are in Ord. The declared order of the constructors in the data declaration determines the ordering in derived Ord instances. The Ordering datatype allows a single comparison to determine the precise ordering of two objects.

The Haskell Report defines no laws for Ord. However, <= is customarily expected to implement a non-strict partial order and have the following properties:

Transitivity: if x <= y && y <= z = True, then x <= z = True
Reflexivity: x <= x = True
Antisymmetry: if x <= y && y <= x = True, then x == y = True

Note that the following operator interactions are expected to hold:

x >= y = y <= x
x < y = x <= y && x /= y
x > y = y < x
x < y = compare x y == LT
x > y = compare x y == GT
x == y = compare x y == EQ
min x y == if x <= y then x else y = True
max x y == if x >= y then x else y = True

Note that (7.) and (8.) do not require min and max to return either of their arguments. The result is merely required to equal one of the arguments in terms of (==).

Minimal complete definition: either compare or <=. Using compare can be more efficient for complex types.

Minimal complete definition

compare | (<=)

Methods

compare :: a -> a -> Ordering #

max :: a -> a -> a #

min :: a -> a -> a #

Instances

Instances details

Ord CabalSpecVersion
Instance details Defined in Distribution.CabalSpecVersion Methods compare :: CabalSpecVersion -> CabalSpecVersion -> Ordering # (<) :: CabalSpecVersion -> CabalSpecVersion -> Bool # (<=) :: CabalSpecVersion -> CabalSpecVersion -> Bool # (>) :: CabalSpecVersion -> CabalSpecVersion -> Bool # (>=) :: CabalSpecVersion -> CabalSpecVersion -> Bool # max :: CabalSpecVersion -> CabalSpecVersion -> CabalSpecVersion # min :: CabalSpecVersion -> CabalSpecVersion -> CabalSpecVersion #
Ord Position
Instance details Defined in Distribution.Parsec.Position Methods compare :: Position -> Position -> Ordering # (<) :: Position -> Position -> Bool # (<=) :: Position -> Position -> Bool # (>) :: Position -> Position -> Bool # (>=) :: Position -> Position -> Bool # max :: Position -> Position -> Position # min :: Position -> Position -> Position #
Ord PWarnType
Instance details Defined in Distribution.Parsec.Warning Methods compare :: PWarnType -> PWarnType -> Ordering # (<) :: PWarnType -> PWarnType -> Bool # (<=) :: PWarnType -> PWarnType -> Bool # (>) :: PWarnType -> PWarnType -> Bool # (>=) :: PWarnType -> PWarnType -> Bool # max :: PWarnType -> PWarnType -> PWarnType # min :: PWarnType -> PWarnType -> PWarnType #
Ord Structure
Instance details Defined in Distribution.Utils.Structured Methods compare :: Structure -> Structure -> Ordering # (<) :: Structure -> Structure -> Bool # (<=) :: Structure -> Structure -> Bool # (>) :: Structure -> Structure -> Bool # (>=) :: Structure -> Structure -> Bool # max :: Structure -> Structure -> Structure # min :: Structure -> Structure -> Structure #
Ord Extension
Instance details Defined in Language.Haskell.Extension Methods compare :: Extension -> Extension -> Ordering # (<) :: Extension -> Extension -> Bool # (<=) :: Extension -> Extension -> Bool # (>) :: Extension -> Extension -> Bool # (>=) :: Extension -> Extension -> Bool # max :: Extension -> Extension -> Extension # min :: Extension -> Extension -> Extension #
Ord KnownExtension
Instance details Defined in Language.Haskell.Extension Methods compare :: KnownExtension -> KnownExtension -> Ordering # (<) :: KnownExtension -> KnownExtension -> Bool # (<=) :: KnownExtension -> KnownExtension -> Bool # (>) :: KnownExtension -> KnownExtension -> Bool # (>=) :: KnownExtension -> KnownExtension -> Bool # max :: KnownExtension -> KnownExtension -> KnownExtension # min :: KnownExtension -> KnownExtension -> KnownExtension #
Ord DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods compare :: DotNetTime -> DotNetTime -> Ordering # (<) :: DotNetTime -> DotNetTime -> Bool # (<=) :: DotNetTime -> DotNetTime -> Bool # (>) :: DotNetTime -> DotNetTime -> Bool # (>=) :: DotNetTime -> DotNetTime -> Bool # max :: DotNetTime -> DotNetTime -> DotNetTime # min :: DotNetTime -> DotNetTime -> DotNetTime #
Ord JSONPathElement
Instance details Defined in Data.Aeson.Types.Internal Methods compare :: JSONPathElement -> JSONPathElement -> Ordering # (<) :: JSONPathElement -> JSONPathElement -> Bool # (<=) :: JSONPathElement -> JSONPathElement -> Bool # (>) :: JSONPathElement -> JSONPathElement -> Bool # (>=) :: JSONPathElement -> JSONPathElement -> Bool # max :: JSONPathElement -> JSONPathElement -> JSONPathElement # min :: JSONPathElement -> JSONPathElement -> JSONPathElement #
Ord Value	The ordering is total, consistent with `Eq` instance. However, nothing else about the ordering is specified, and it may change from environment to environment and version to version of either this package or its dependencies (`hashable` and 'unordered-containers'). Since: aeson-1.5.2.0
Instance details Defined in Data.Aeson.Types.Internal Methods compare :: Value -> Value -> Ordering # (<) :: Value -> Value -> Bool # (<=) :: Value -> Value -> Bool # (>) :: Value -> Value -> Bool # (>=) :: Value -> Value -> Bool # max :: Value -> Value -> Value # min :: Value -> Value -> Value #
Ord Pos
Instance details Defined in Data.Attoparsec.Internal.Types Methods compare :: Pos -> Pos -> Ordering # (<) :: Pos -> Pos -> Bool # (<=) :: Pos -> Pos -> Bool # (>) :: Pos -> Pos -> Bool # (>=) :: Pos -> Pos -> Bool # max :: Pos -> Pos -> Pos # min :: Pos -> Pos -> Pos #
Ord All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: All -> All -> Ordering # (<) :: All -> All -> Bool # (<=) :: All -> All -> Bool # (>) :: All -> All -> Bool # (>=) :: All -> All -> Bool # max :: All -> All -> All # min :: All -> All -> All #
Ord Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Any -> Any -> Ordering # (<) :: Any -> Any -> Bool # (<=) :: Any -> Any -> Bool # (>) :: Any -> Any -> Bool # (>=) :: Any -> Any -> Bool # max :: Any -> Any -> Any # min :: Any -> Any -> Any #
Ord SomeTypeRep
Instance details Defined in Data.Typeable.Internal Methods compare :: SomeTypeRep -> SomeTypeRep -> Ordering # (<) :: SomeTypeRep -> SomeTypeRep -> Bool # (<=) :: SomeTypeRep -> SomeTypeRep -> Bool # (>) :: SomeTypeRep -> SomeTypeRep -> Bool # (>=) :: SomeTypeRep -> SomeTypeRep -> Bool # max :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep # min :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep #
Ord Version	Since: base-2.1
Instance details Defined in Data.Version Methods compare :: Version -> Version -> Ordering # (<) :: Version -> Version -> Bool # (<=) :: Version -> Version -> Bool # (>) :: Version -> Version -> Bool # (>=) :: Version -> Version -> Bool # max :: Version -> Version -> Version # min :: Version -> Version -> Version #
Ord Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods compare :: Void -> Void -> Ordering # (<) :: Void -> Void -> Bool # (<=) :: Void -> Void -> Bool # (>) :: Void -> Void -> Bool # (>=) :: Void -> Void -> Bool # max :: Void -> Void -> Void # min :: Void -> Void -> Void #
Ord BlockReason	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods compare :: BlockReason -> BlockReason -> Ordering # (<) :: BlockReason -> BlockReason -> Bool # (<=) :: BlockReason -> BlockReason -> Bool # (>) :: BlockReason -> BlockReason -> Bool # (>=) :: BlockReason -> BlockReason -> Bool # max :: BlockReason -> BlockReason -> BlockReason # min :: BlockReason -> BlockReason -> BlockReason #
Ord ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods compare :: ThreadId -> ThreadId -> Ordering # (<) :: ThreadId -> ThreadId -> Bool # (<=) :: ThreadId -> ThreadId -> Bool # (>) :: ThreadId -> ThreadId -> Bool # (>=) :: ThreadId -> ThreadId -> Bool # max :: ThreadId -> ThreadId -> ThreadId # min :: ThreadId -> ThreadId -> ThreadId #
Ord ThreadStatus	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods compare :: ThreadStatus -> ThreadStatus -> Ordering # (<) :: ThreadStatus -> ThreadStatus -> Bool # (<=) :: ThreadStatus -> ThreadStatus -> Bool # (>) :: ThreadStatus -> ThreadStatus -> Bool # (>=) :: ThreadStatus -> ThreadStatus -> Bool # max :: ThreadStatus -> ThreadStatus -> ThreadStatus # min :: ThreadStatus -> ThreadStatus -> ThreadStatus #
Ord ErrorCall	Since: base-4.7.0.0
Instance details Defined in GHC.Exception Methods compare :: ErrorCall -> ErrorCall -> Ordering # (<) :: ErrorCall -> ErrorCall -> Bool # (<=) :: ErrorCall -> ErrorCall -> Bool # (>) :: ErrorCall -> ErrorCall -> Bool # (>=) :: ErrorCall -> ErrorCall -> Bool # max :: ErrorCall -> ErrorCall -> ErrorCall # min :: ErrorCall -> ErrorCall -> ErrorCall #
Ord ArithException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # max :: ArithException -> ArithException -> ArithException # min :: ArithException -> ArithException -> ArithException #
Ord Fingerprint	Since: base-4.4.0.0
Instance details Defined in GHC.Fingerprint.Type Methods compare :: Fingerprint -> Fingerprint -> Ordering # (<) :: Fingerprint -> Fingerprint -> Bool # (<=) :: Fingerprint -> Fingerprint -> Bool # (>) :: Fingerprint -> Fingerprint -> Bool # (>=) :: Fingerprint -> Fingerprint -> Bool # max :: Fingerprint -> Fingerprint -> Fingerprint # min :: Fingerprint -> Fingerprint -> Fingerprint #
Ord Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # max :: Associativity -> Associativity -> Associativity # min :: Associativity -> Associativity -> Associativity #
Ord DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness #
Ord Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods compare :: Fixity -> Fixity -> Ordering # (<) :: Fixity -> Fixity -> Bool # (<=) :: Fixity -> Fixity -> Bool # (>) :: Fixity -> Fixity -> Bool # (>=) :: Fixity -> Fixity -> Bool # max :: Fixity -> Fixity -> Fixity # min :: Fixity -> Fixity -> Fixity #
Ord SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness #
Ord SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness #
Ord ArrayException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # max :: ArrayException -> ArrayException -> ArrayException # min :: ArrayException -> ArrayException -> ArrayException #
Ord AsyncException	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # max :: AsyncException -> AsyncException -> AsyncException # min :: AsyncException -> AsyncException -> AsyncException #
Ord ExitCode
Instance details Defined in GHC.IO.Exception Methods compare :: ExitCode -> ExitCode -> Ordering # (<) :: ExitCode -> ExitCode -> Bool # (<=) :: ExitCode -> ExitCode -> Bool # (>) :: ExitCode -> ExitCode -> Bool # (>=) :: ExitCode -> ExitCode -> Bool # max :: ExitCode -> ExitCode -> ExitCode # min :: ExitCode -> ExitCode -> ExitCode #
Ord BufferMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods compare :: BufferMode -> BufferMode -> Ordering # (<) :: BufferMode -> BufferMode -> Bool # (<=) :: BufferMode -> BufferMode -> Bool # (>) :: BufferMode -> BufferMode -> Bool # (>=) :: BufferMode -> BufferMode -> Bool # max :: BufferMode -> BufferMode -> BufferMode # min :: BufferMode -> BufferMode -> BufferMode #
Ord Newline	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods compare :: Newline -> Newline -> Ordering # (<) :: Newline -> Newline -> Bool # (<=) :: Newline -> Newline -> Bool # (>) :: Newline -> Newline -> Bool # (>=) :: Newline -> Newline -> Bool # max :: Newline -> Newline -> Newline # min :: Newline -> Newline -> Newline #
Ord NewlineMode	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods compare :: NewlineMode -> NewlineMode -> Ordering # (<) :: NewlineMode -> NewlineMode -> Bool # (<=) :: NewlineMode -> NewlineMode -> Bool # (>) :: NewlineMode -> NewlineMode -> Bool # (>=) :: NewlineMode -> NewlineMode -> Bool # max :: NewlineMode -> NewlineMode -> NewlineMode # min :: NewlineMode -> NewlineMode -> NewlineMode #
Ord IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods compare :: IOMode -> IOMode -> Ordering # (<) :: IOMode -> IOMode -> Bool # (<=) :: IOMode -> IOMode -> Bool # (>) :: IOMode -> IOMode -> Bool # (>=) :: IOMode -> IOMode -> Bool # max :: IOMode -> IOMode -> IOMode # min :: IOMode -> IOMode -> IOMode #
Ord Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int16 -> Int16 -> Ordering # (<) :: Int16 -> Int16 -> Bool # (<=) :: Int16 -> Int16 -> Bool # (>) :: Int16 -> Int16 -> Bool # (>=) :: Int16 -> Int16 -> Bool # max :: Int16 -> Int16 -> Int16 # min :: Int16 -> Int16 -> Int16 #
Ord Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int32 -> Int32 -> Ordering # (<) :: Int32 -> Int32 -> Bool # (<=) :: Int32 -> Int32 -> Bool # (>) :: Int32 -> Int32 -> Bool # (>=) :: Int32 -> Int32 -> Bool # max :: Int32 -> Int32 -> Int32 # min :: Int32 -> Int32 -> Int32 #
Ord Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int64 -> Int64 -> Ordering # (<) :: Int64 -> Int64 -> Bool # (<=) :: Int64 -> Int64 -> Bool # (>) :: Int64 -> Int64 -> Bool # (>=) :: Int64 -> Int64 -> Bool # max :: Int64 -> Int64 -> Int64 # min :: Int64 -> Int64 -> Int64 #
Ord Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int8 -> Int8 -> Ordering # (<) :: Int8 -> Int8 -> Bool # (<=) :: Int8 -> Int8 -> Bool # (>) :: Int8 -> Int8 -> Bool # (>=) :: Int8 -> Int8 -> Bool # max :: Int8 -> Int8 -> Int8 # min :: Int8 -> Int8 -> Int8 #
Ord SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods compare :: SomeSymbol -> SomeSymbol -> Ordering # (<) :: SomeSymbol -> SomeSymbol -> Bool # (<=) :: SomeSymbol -> SomeSymbol -> Bool # (>) :: SomeSymbol -> SomeSymbol -> Bool # (>=) :: SomeSymbol -> SomeSymbol -> Bool # max :: SomeSymbol -> SomeSymbol -> SomeSymbol # min :: SomeSymbol -> SomeSymbol -> SomeSymbol #
Ord SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods compare :: SomeNat -> SomeNat -> Ordering # (<) :: SomeNat -> SomeNat -> Bool # (<=) :: SomeNat -> SomeNat -> Bool # (>) :: SomeNat -> SomeNat -> Bool # (>=) :: SomeNat -> SomeNat -> Bool # max :: SomeNat -> SomeNat -> SomeNat # min :: SomeNat -> SomeNat -> SomeNat #
Ord GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Unicode Methods compare :: GeneralCategory -> GeneralCategory -> Ordering # (<) :: GeneralCategory -> GeneralCategory -> Bool # (<=) :: GeneralCategory -> GeneralCategory -> Bool # (>) :: GeneralCategory -> GeneralCategory -> Bool # (>=) :: GeneralCategory -> GeneralCategory -> Bool # max :: GeneralCategory -> GeneralCategory -> GeneralCategory # min :: GeneralCategory -> GeneralCategory -> GeneralCategory #
Ord Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word16 -> Word16 -> Ordering # (<) :: Word16 -> Word16 -> Bool # (<=) :: Word16 -> Word16 -> Bool # (>) :: Word16 -> Word16 -> Bool # (>=) :: Word16 -> Word16 -> Bool # max :: Word16 -> Word16 -> Word16 # min :: Word16 -> Word16 -> Word16 #
Ord Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word32 -> Word32 -> Ordering # (<) :: Word32 -> Word32 -> Bool # (<=) :: Word32 -> Word32 -> Bool # (>) :: Word32 -> Word32 -> Bool # (>=) :: Word32 -> Word32 -> Bool # max :: Word32 -> Word32 -> Word32 # min :: Word32 -> Word32 -> Word32 #
Ord Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word64 -> Word64 -> Ordering # (<) :: Word64 -> Word64 -> Bool # (<=) :: Word64 -> Word64 -> Bool # (>) :: Word64 -> Word64 -> Bool # (>=) :: Word64 -> Word64 -> Bool # max :: Word64 -> Word64 -> Word64 # min :: Word64 -> Word64 -> Word64 #
Ord Alphabet
Instance details Defined in Data.ByteString.Base58.Internal Methods compare :: Alphabet -> Alphabet -> Ordering # (<) :: Alphabet -> Alphabet -> Bool # (<=) :: Alphabet -> Alphabet -> Bool # (>) :: Alphabet -> Alphabet -> Bool # (>=) :: Alphabet -> Alphabet -> Bool # max :: Alphabet -> Alphabet -> Alphabet # min :: Alphabet -> Alphabet -> Alphabet #
Ord Encoding
Instance details Defined in Basement.String Methods compare :: Encoding -> Encoding -> Ordering # (<) :: Encoding -> Encoding -> Bool # (<=) :: Encoding -> Encoding -> Bool # (>) :: Encoding -> Encoding -> Bool # (>=) :: Encoding -> Encoding -> Bool # max :: Encoding -> Encoding -> Encoding # min :: Encoding -> Encoding -> Encoding #
Ord UTF32_Invalid
Instance details Defined in Basement.String.Encoding.UTF32 Methods compare :: UTF32_Invalid -> UTF32_Invalid -> Ordering # (<) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (<=) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (>) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (>=) :: UTF32_Invalid -> UTF32_Invalid -> Bool # max :: UTF32_Invalid -> UTF32_Invalid -> UTF32_Invalid # min :: UTF32_Invalid -> UTF32_Invalid -> UTF32_Invalid #
Ord AsciiString
Instance details Defined in Basement.Types.AsciiString Methods compare :: AsciiString -> AsciiString -> Ordering # (<) :: AsciiString -> AsciiString -> Bool # (<=) :: AsciiString -> AsciiString -> Bool # (>) :: AsciiString -> AsciiString -> Bool # (>=) :: AsciiString -> AsciiString -> Bool # max :: AsciiString -> AsciiString -> AsciiString # min :: AsciiString -> AsciiString -> AsciiString #
Ord FileSize
Instance details Defined in Basement.Types.OffsetSize Methods compare :: FileSize -> FileSize -> Ordering # (<) :: FileSize -> FileSize -> Bool # (<=) :: FileSize -> FileSize -> Bool # (>) :: FileSize -> FileSize -> Bool # (>=) :: FileSize -> FileSize -> Bool # max :: FileSize -> FileSize -> FileSize # min :: FileSize -> FileSize -> FileSize #
Ord String
Instance details Defined in Basement.UTF8.Base Methods compare :: String -> String -> Ordering # (<) :: String -> String -> Bool # (<=) :: String -> String -> Bool # (>) :: String -> String -> Bool # (>=) :: String -> String -> Bool # max :: String -> String -> String # min :: String -> String -> String #
Ord F2Poly
Instance details Defined in Data.Bit.F2Poly Methods compare :: F2Poly -> F2Poly -> Ordering # (<) :: F2Poly -> F2Poly -> Bool # (<=) :: F2Poly -> F2Poly -> Bool # (>) :: F2Poly -> F2Poly -> Bool # (>=) :: F2Poly -> F2Poly -> Bool # max :: F2Poly -> F2Poly -> F2Poly # min :: F2Poly -> F2Poly -> F2Poly #
Ord Bit
Instance details Defined in Data.Bit.Internal Methods compare :: Bit -> Bit -> Ordering # (<) :: Bit -> Bit -> Bool # (<=) :: Bit -> Bit -> Bool # (>) :: Bit -> Bit -> Bool # (>=) :: Bit -> Bit -> Bool # max :: Bit -> Bit -> Bit # min :: Bit -> Bit -> Bit #
Ord ByteString
Instance details Defined in Data.ByteString.Internal Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString #
Ord ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString #
Ord ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods compare :: ShortByteString -> ShortByteString -> Ordering # (<) :: ShortByteString -> ShortByteString -> Bool # (<=) :: ShortByteString -> ShortByteString -> Bool # (>) :: ShortByteString -> ShortByteString -> Bool # (>=) :: ShortByteString -> ShortByteString -> Bool # max :: ShortByteString -> ShortByteString -> ShortByteString # min :: ShortByteString -> ShortByteString -> ShortByteString #
Ord TimeSpec
Instance details Defined in System.Clock Methods compare :: TimeSpec -> TimeSpec -> Ordering # (<) :: TimeSpec -> TimeSpec -> Bool # (<=) :: TimeSpec -> TimeSpec -> Bool # (>) :: TimeSpec -> TimeSpec -> Bool # (>=) :: TimeSpec -> TimeSpec -> Bool # max :: TimeSpec -> TimeSpec -> TimeSpec # min :: TimeSpec -> TimeSpec -> TimeSpec #
Ord IntSet
Instance details Defined in Data.IntSet.Internal Methods compare :: IntSet -> IntSet -> Ordering # (<) :: IntSet -> IntSet -> Bool # (<=) :: IntSet -> IntSet -> Bool # (>) :: IntSet -> IntSet -> Bool # (>=) :: IntSet -> IntSet -> Bool # max :: IntSet -> IntSet -> IntSet # min :: IntSet -> IntSet -> IntSet #
Ord BigNat
Instance details Defined in GHC.Num.BigNat Methods compare :: BigNat -> BigNat -> Ordering # (<) :: BigNat -> BigNat -> Bool # (<=) :: BigNat -> BigNat -> Bool # (>) :: BigNat -> BigNat -> Bool # (>=) :: BigNat -> BigNat -> Bool # max :: BigNat -> BigNat -> BigNat # min :: BigNat -> BigNat -> BigNat #
Ord Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods compare :: Extension -> Extension -> Ordering # (<) :: Extension -> Extension -> Bool # (<=) :: Extension -> Extension -> Bool # (>) :: Extension -> Extension -> Bool # (>=) :: Extension -> Extension -> Bool # max :: Extension -> Extension -> Extension # min :: Extension -> Extension -> Extension #
Ord Ordering
Instance details Defined in GHC.Classes Methods compare :: Ordering -> Ordering -> Ordering # (<) :: Ordering -> Ordering -> Bool # (<=) :: Ordering -> Ordering -> Bool # (>) :: Ordering -> Ordering -> Bool # (>=) :: Ordering -> Ordering -> Bool # max :: Ordering -> Ordering -> Ordering # min :: Ordering -> Ordering -> Ordering #
Ord TyCon
Instance details Defined in GHC.Classes Methods compare :: TyCon -> TyCon -> Ordering # (<) :: TyCon -> TyCon -> Bool # (<=) :: TyCon -> TyCon -> Bool # (>) :: TyCon -> TyCon -> Bool # (>=) :: TyCon -> TyCon -> Bool # max :: TyCon -> TyCon -> TyCon # min :: TyCon -> TyCon -> TyCon #
Ord RefId Source #
Instance details Defined in Indigo.Common.Var Methods compare :: RefId -> RefId -> Ordering # (<) :: RefId -> RefId -> Bool # (<=) :: RefId -> RefId -> Bool # (>) :: RefId -> RefId -> Bool # (>=) :: RefId -> RefId -> Bool # max :: RefId -> RefId -> RefId # min :: RefId -> RefId -> RefId #
Ord CommentsVerbosity Source #
Instance details Defined in Indigo.Compilation.Hooks Methods compare :: CommentsVerbosity -> CommentsVerbosity -> Ordering # (<) :: CommentsVerbosity -> CommentsVerbosity -> Bool # (<=) :: CommentsVerbosity -> CommentsVerbosity -> Bool # (>) :: CommentsVerbosity -> CommentsVerbosity -> Bool # (>=) :: CommentsVerbosity -> CommentsVerbosity -> Bool # max :: CommentsVerbosity -> CommentsVerbosity -> CommentsVerbosity # min :: CommentsVerbosity -> CommentsVerbosity -> CommentsVerbosity #
Ord DHashAlgorithm
Instance details Defined in Lorentz.Bytes Methods compare :: DHashAlgorithm -> DHashAlgorithm -> Ordering # (<) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (<=) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (>) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (>=) :: DHashAlgorithm -> DHashAlgorithm -> Bool # max :: DHashAlgorithm -> DHashAlgorithm -> DHashAlgorithm # min :: DHashAlgorithm -> DHashAlgorithm -> DHashAlgorithm #
Ord DViewDesc
Instance details Defined in Lorentz.Doc Methods compare :: DViewDesc -> DViewDesc -> Ordering # (<) :: DViewDesc -> DViewDesc -> Bool # (<=) :: DViewDesc -> DViewDesc -> Bool # (>) :: DViewDesc -> DViewDesc -> Bool # (>=) :: DViewDesc -> DViewDesc -> Bool # max :: DViewDesc -> DViewDesc -> DViewDesc # min :: DViewDesc -> DViewDesc -> DViewDesc #
Ord DError
Instance details Defined in Lorentz.Errors Methods compare :: DError -> DError -> Ordering # (<) :: DError -> DError -> Bool # (<=) :: DError -> DError -> Bool # (>) :: DError -> DError -> Bool # (>=) :: DError -> DError -> Bool # max :: DError -> DError -> DError # min :: DError -> DError -> DError #
Ord DDescribeErrorTagMap
Instance details Defined in Lorentz.Errors.Numeric.Doc Methods compare :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Ordering # (<) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (<=) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (>) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (>=) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # max :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> DDescribeErrorTagMap # min :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> DDescribeErrorTagMap #
Ord Never
Instance details Defined in Lorentz.Value Methods compare :: Never -> Never -> Ordering # (<) :: Never -> Never -> Bool # (<=) :: Never -> Never -> Bool # (>) :: Never -> Never -> Bool # (>=) :: Never -> Never -> Bool # max :: Never -> Never -> Never # min :: Never -> Never -> Never #
Ord Pos
Instance details Defined in Text.Megaparsec.Pos Methods compare :: Pos -> Pos -> Ordering # (<) :: Pos -> Pos -> Bool # (<=) :: Pos -> Pos -> Bool # (>) :: Pos -> Pos -> Bool # (>=) :: Pos -> Pos -> Bool # max :: Pos -> Pos -> Pos # min :: Pos -> Pos -> Pos #
Ord SourcePos
Instance details Defined in Text.Megaparsec.Pos Methods compare :: SourcePos -> SourcePos -> Ordering # (<) :: SourcePos -> SourcePos -> Bool # (<=) :: SourcePos -> SourcePos -> Bool # (>) :: SourcePos -> SourcePos -> Bool # (>=) :: SourcePos -> SourcePos -> Bool # max :: SourcePos -> SourcePos -> SourcePos # min :: SourcePos -> SourcePos -> SourcePos #
Ord DefName
Instance details Defined in Lens.Micro.TH Methods compare :: DefName -> DefName -> Ordering # (<) :: DefName -> DefName -> Bool # (<=) :: DefName -> DefName -> Bool # (>) :: DefName -> DefName -> Bool # (>=) :: DefName -> DefName -> Bool # max :: DefName -> DefName -> DefName # min :: DefName -> DefName -> DefName #
Ord MichelinePrimitive
Instance details Defined in Morley.Micheline.Expression Methods compare :: MichelinePrimitive -> MichelinePrimitive -> Ordering # (<) :: MichelinePrimitive -> MichelinePrimitive -> Bool # (<=) :: MichelinePrimitive -> MichelinePrimitive -> Bool # (>) :: MichelinePrimitive -> MichelinePrimitive -> Bool # (>=) :: MichelinePrimitive -> MichelinePrimitive -> Bool # max :: MichelinePrimitive -> MichelinePrimitive -> MichelinePrimitive # min :: MichelinePrimitive -> MichelinePrimitive -> MichelinePrimitive #
Ord TezosMutez
Instance details Defined in Morley.Micheline.Json Methods compare :: TezosMutez -> TezosMutez -> Ordering # (<) :: TezosMutez -> TezosMutez -> Bool # (<=) :: TezosMutez -> TezosMutez -> Bool # (>) :: TezosMutez -> TezosMutez -> Bool # (>=) :: TezosMutez -> TezosMutez -> Bool # max :: TezosMutez -> TezosMutez -> TezosMutez # min :: TezosMutez -> TezosMutez -> TezosMutez #
Ord DocItemId
Instance details Defined in Morley.Michelson.Doc Methods compare :: DocItemId -> DocItemId -> Ordering # (<) :: DocItemId -> DocItemId -> Bool # (<=) :: DocItemId -> DocItemId -> Bool # (>) :: DocItemId -> DocItemId -> Bool # (>=) :: DocItemId -> DocItemId -> Bool # max :: DocItemId -> DocItemId -> DocItemId # min :: DocItemId -> DocItemId -> DocItemId #
Ord DocItemPos
Instance details Defined in Morley.Michelson.Doc Methods compare :: DocItemPos -> DocItemPos -> Ordering # (<) :: DocItemPos -> DocItemPos -> Bool # (<=) :: DocItemPos -> DocItemPos -> Bool # (>) :: DocItemPos -> DocItemPos -> Bool # (>=) :: DocItemPos -> DocItemPos -> Bool # max :: DocItemPos -> DocItemPos -> DocItemPos # min :: DocItemPos -> DocItemPos -> DocItemPos #
Ord SomeDocDefinitionItem
Instance details Defined in Morley.Michelson.Doc Methods compare :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Ordering # (<) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (<=) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (>) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (>=) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # max :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> SomeDocDefinitionItem # min :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> SomeDocDefinitionItem #
Ord ErrorSrcPos
Instance details Defined in Morley.Michelson.ErrorPos Methods compare :: ErrorSrcPos -> ErrorSrcPos -> Ordering # (<) :: ErrorSrcPos -> ErrorSrcPos -> Bool # (<=) :: ErrorSrcPos -> ErrorSrcPos -> Bool # (>) :: ErrorSrcPos -> ErrorSrcPos -> Bool # (>=) :: ErrorSrcPos -> ErrorSrcPos -> Bool # max :: ErrorSrcPos -> ErrorSrcPos -> ErrorSrcPos # min :: ErrorSrcPos -> ErrorSrcPos -> ErrorSrcPos #
Ord Pos
Instance details Defined in Morley.Michelson.ErrorPos Methods compare :: Pos -> Pos -> Ordering # (<) :: Pos -> Pos -> Bool # (<=) :: Pos -> Pos -> Bool # (>) :: Pos -> Pos -> Bool # (>=) :: Pos -> Pos -> Bool # max :: Pos -> Pos -> Pos # min :: Pos -> Pos -> Pos #
Ord SrcPos
Instance details Defined in Morley.Michelson.ErrorPos Methods compare :: SrcPos -> SrcPos -> Ordering # (<) :: SrcPos -> SrcPos -> Bool # (<=) :: SrcPos -> SrcPos -> Bool # (>) :: SrcPos -> SrcPos -> Bool # (>=) :: SrcPos -> SrcPos -> Bool # max :: SrcPos -> SrcPos -> SrcPos # min :: SrcPos -> SrcPos -> SrcPos #
Ord BadViewNameError
Instance details Defined in Morley.Michelson.Internal.ViewName Methods compare :: BadViewNameError -> BadViewNameError -> Ordering # (<) :: BadViewNameError -> BadViewNameError -> Bool # (<=) :: BadViewNameError -> BadViewNameError -> Bool # (>) :: BadViewNameError -> BadViewNameError -> Bool # (>=) :: BadViewNameError -> BadViewNameError -> Bool # max :: BadViewNameError -> BadViewNameError -> BadViewNameError # min :: BadViewNameError -> BadViewNameError -> BadViewNameError #
Ord ViewName
Instance details Defined in Morley.Michelson.Internal.ViewName Methods compare :: ViewName -> ViewName -> Ordering # (<) :: ViewName -> ViewName -> Bool # (<=) :: ViewName -> ViewName -> Bool # (>) :: ViewName -> ViewName -> Bool # (>=) :: ViewName -> ViewName -> Bool # max :: ViewName -> ViewName -> ViewName # min :: ViewName -> ViewName -> ViewName #
Ord RemainingSteps
Instance details Defined in Morley.Michelson.Interpret Methods compare :: RemainingSteps -> RemainingSteps -> Ordering # (<) :: RemainingSteps -> RemainingSteps -> Bool # (<=) :: RemainingSteps -> RemainingSteps -> Bool # (>) :: RemainingSteps -> RemainingSteps -> Bool # (>=) :: RemainingSteps -> RemainingSteps -> Bool # max :: RemainingSteps -> RemainingSteps -> RemainingSteps # min :: RemainingSteps -> RemainingSteps -> RemainingSteps #
Ord OptimizationStage
Instance details Defined in Morley.Michelson.Optimizer Methods compare :: OptimizationStage -> OptimizationStage -> Ordering # (<) :: OptimizationStage -> OptimizationStage -> Bool # (<=) :: OptimizationStage -> OptimizationStage -> Bool # (>) :: OptimizationStage -> OptimizationStage -> Bool # (>=) :: OptimizationStage -> OptimizationStage -> Bool # max :: OptimizationStage -> OptimizationStage -> OptimizationStage # min :: OptimizationStage -> OptimizationStage -> OptimizationStage #
Ord CustomParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods compare :: CustomParserException -> CustomParserException -> Ordering # (<) :: CustomParserException -> CustomParserException -> Bool # (<=) :: CustomParserException -> CustomParserException -> Bool # (>) :: CustomParserException -> CustomParserException -> Bool # (>=) :: CustomParserException -> CustomParserException -> Bool # max :: CustomParserException -> CustomParserException -> CustomParserException # min :: CustomParserException -> CustomParserException -> CustomParserException #
Ord StringLiteralParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods compare :: StringLiteralParserException -> StringLiteralParserException -> Ordering # (<) :: StringLiteralParserException -> StringLiteralParserException -> Bool # (<=) :: StringLiteralParserException -> StringLiteralParserException -> Bool # (>) :: StringLiteralParserException -> StringLiteralParserException -> Bool # (>=) :: StringLiteralParserException -> StringLiteralParserException -> Bool # max :: StringLiteralParserException -> StringLiteralParserException -> StringLiteralParserException # min :: StringLiteralParserException -> StringLiteralParserException -> StringLiteralParserException #
Ord MText
Instance details Defined in Morley.Michelson.Text Methods compare :: MText -> MText -> Ordering # (<) :: MText -> MText -> Bool # (<=) :: MText -> MText -> Bool # (>) :: MText -> MText -> Bool # (>=) :: MText -> MText -> Bool # max :: MText -> MText -> MText # min :: MText -> MText -> MText #
Ord MutezArithErrorType
Instance details Defined in Morley.Michelson.Typed.Arith Methods compare :: MutezArithErrorType -> MutezArithErrorType -> Ordering # (<) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (<=) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (>) :: MutezArithErrorType -> MutezArithErrorType -> Bool # (>=) :: MutezArithErrorType -> MutezArithErrorType -> Bool # max :: MutezArithErrorType -> MutezArithErrorType -> MutezArithErrorType # min :: MutezArithErrorType -> MutezArithErrorType -> MutezArithErrorType #
Ord ShiftArithErrorType
Instance details Defined in Morley.Michelson.Typed.Arith Methods compare :: ShiftArithErrorType -> ShiftArithErrorType -> Ordering # (<) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (<=) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (>) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # (>=) :: ShiftArithErrorType -> ShiftArithErrorType -> Bool # max :: ShiftArithErrorType -> ShiftArithErrorType -> ShiftArithErrorType # min :: ShiftArithErrorType -> ShiftArithErrorType -> ShiftArithErrorType #
Ord EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods compare :: EpAddress -> EpAddress -> Ordering # (<) :: EpAddress -> EpAddress -> Bool # (<=) :: EpAddress -> EpAddress -> Bool # (>) :: EpAddress -> EpAddress -> Bool # (>=) :: EpAddress -> EpAddress -> Bool # max :: EpAddress -> EpAddress -> EpAddress # min :: EpAddress -> EpAddress -> EpAddress #
Ord DStorageType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods compare :: DStorageType -> DStorageType -> Ordering # (<) :: DStorageType -> DStorageType -> Bool # (<=) :: DStorageType -> DStorageType -> Bool # (>) :: DStorageType -> DStorageType -> Bool # (>=) :: DStorageType -> DStorageType -> Bool # max :: DStorageType -> DStorageType -> DStorageType # min :: DStorageType -> DStorageType -> DStorageType #
Ord DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods compare :: DType -> DType -> Ordering # (<) :: DType -> DType -> Bool # (<=) :: DType -> DType -> Bool # (>) :: DType -> DType -> Bool # (>=) :: DType -> DType -> Bool # max :: DType -> DType -> DType # min :: DType -> DType -> DType #
Ord OperationHash
Instance details Defined in Morley.Michelson.Typed.Operation Methods compare :: OperationHash -> OperationHash -> Ordering # (<) :: OperationHash -> OperationHash -> Bool # (<=) :: OperationHash -> OperationHash -> Bool # (>) :: OperationHash -> OperationHash -> Bool # (>=) :: OperationHash -> OperationHash -> Bool # max :: OperationHash -> OperationHash -> OperationHash # min :: OperationHash -> OperationHash -> OperationHash #
Ord EntriesOrder
Instance details Defined in Morley.Michelson.Untyped.Contract Methods compare :: EntriesOrder -> EntriesOrder -> Ordering # (<) :: EntriesOrder -> EntriesOrder -> Bool # (<=) :: EntriesOrder -> EntriesOrder -> Bool # (>) :: EntriesOrder -> EntriesOrder -> Bool # (>=) :: EntriesOrder -> EntriesOrder -> Bool # max :: EntriesOrder -> EntriesOrder -> EntriesOrder # min :: EntriesOrder -> EntriesOrder -> EntriesOrder #
Ord Entry
Instance details Defined in Morley.Michelson.Untyped.Contract Methods compare :: Entry -> Entry -> Ordering # (<) :: Entry -> Entry -> Bool # (<=) :: Entry -> Entry -> Bool # (>) :: Entry -> Entry -> Bool # (>=) :: Entry -> Entry -> Bool # max :: Entry -> Entry -> Entry # min :: Entry -> Entry -> Entry #
Ord EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods compare :: EpName -> EpName -> Ordering # (<) :: EpName -> EpName -> Bool # (<=) :: EpName -> EpName -> Bool # (>) :: EpName -> EpName -> Bool # (>=) :: EpName -> EpName -> Bool # max :: EpName -> EpName -> EpName # min :: EpName -> EpName -> EpName #
Ord HandleImplicitDefaultEp
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods compare :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Ordering # (<) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool # (<=) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool # (>) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool # (>=) :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> Bool # max :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> HandleImplicitDefaultEp # min :: HandleImplicitDefaultEp -> HandleImplicitDefaultEp -> HandleImplicitDefaultEp #
Ord Var
Instance details Defined in Morley.Michelson.Untyped.Ext Methods compare :: Var -> Var -> Ordering # (<) :: Var -> Var -> Bool # (<=) :: Var -> Var -> Bool # (>) :: Var -> Var -> Bool # (>=) :: Var -> Var -> Bool # max :: Var -> Var -> Var # min :: Var -> Var -> Var #
Ord AddressKind
Instance details Defined in Morley.Tezos.Address.Kinds Methods compare :: AddressKind -> AddressKind -> Ordering # (<) :: AddressKind -> AddressKind -> Bool # (<=) :: AddressKind -> AddressKind -> Bool # (>) :: AddressKind -> AddressKind -> Bool # (>=) :: AddressKind -> AddressKind -> Bool # max :: AddressKind -> AddressKind -> AddressKind # min :: AddressKind -> AddressKind -> AddressKind #
Ord ChainId
Instance details Defined in Morley.Tezos.Core Methods compare :: ChainId -> ChainId -> Ordering # (<) :: ChainId -> ChainId -> Bool # (<=) :: ChainId -> ChainId -> Bool # (>) :: ChainId -> ChainId -> Bool # (>=) :: ChainId -> ChainId -> Bool # max :: ChainId -> ChainId -> ChainId # min :: ChainId -> ChainId -> ChainId #
Ord Mutez
Instance details Defined in Morley.Tezos.Core Methods compare :: Mutez -> Mutez -> Ordering # (<) :: Mutez -> Mutez -> Bool # (<=) :: Mutez -> Mutez -> Bool # (>) :: Mutez -> Mutez -> Bool # (>=) :: Mutez -> Mutez -> Bool # max :: Mutez -> Mutez -> Mutez # min :: Mutez -> Mutez -> Mutez #
Ord Timestamp
Instance details Defined in Morley.Tezos.Core Methods compare :: Timestamp -> Timestamp -> Ordering # (<) :: Timestamp -> Timestamp -> Bool # (<=) :: Timestamp -> Timestamp -> Bool # (>) :: Timestamp -> Timestamp -> Bool # (>=) :: Timestamp -> Timestamp -> Bool # max :: Timestamp -> Timestamp -> Timestamp # min :: Timestamp -> Timestamp -> Timestamp #
Ord KeyType
Instance details Defined in Morley.Tezos.Crypto Methods compare :: KeyType -> KeyType -> Ordering # (<) :: KeyType -> KeyType -> Bool # (<=) :: KeyType -> KeyType -> Bool # (>) :: KeyType -> KeyType -> Bool # (>=) :: KeyType -> KeyType -> Bool # max :: KeyType -> KeyType -> KeyType # min :: KeyType -> KeyType -> KeyType #
Ord PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods compare :: PublicKey -> PublicKey -> Ordering # (<) :: PublicKey -> PublicKey -> Bool # (<=) :: PublicKey -> PublicKey -> Bool # (>) :: PublicKey -> PublicKey -> Bool # (>=) :: PublicKey -> PublicKey -> Bool # max :: PublicKey -> PublicKey -> PublicKey # min :: PublicKey -> PublicKey -> PublicKey #
Ord Signature
Instance details Defined in Morley.Tezos.Crypto Methods compare :: Signature -> Signature -> Ordering # (<) :: Signature -> Signature -> Bool # (<=) :: Signature -> Signature -> Bool # (>) :: Signature -> Signature -> Bool # (>=) :: Signature -> Signature -> Bool # max :: Signature -> Signature -> Signature # min :: Signature -> Signature -> Signature #
Ord PublicKey
Instance details Defined in Morley.Tezos.Crypto.BLS Methods compare :: PublicKey -> PublicKey -> Ordering # (<) :: PublicKey -> PublicKey -> Bool # (<=) :: PublicKey -> PublicKey -> Bool # (>) :: PublicKey -> PublicKey -> Bool # (>=) :: PublicKey -> PublicKey -> Bool # max :: PublicKey -> PublicKey -> PublicKey # min :: PublicKey -> PublicKey -> PublicKey #
Ord Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods compare :: Bls12381Fr -> Bls12381Fr -> Ordering # (<) :: Bls12381Fr -> Bls12381Fr -> Bool # (<=) :: Bls12381Fr -> Bls12381Fr -> Bool # (>) :: Bls12381Fr -> Bls12381Fr -> Bool # (>=) :: Bls12381Fr -> Bls12381Fr -> Bool # max :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # min :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr #
Ord PublicKey
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Methods compare :: PublicKey -> PublicKey -> Ordering # (<) :: PublicKey -> PublicKey -> Bool # (<=) :: PublicKey -> PublicKey -> Bool # (>) :: PublicKey -> PublicKey -> Bool # (>=) :: PublicKey -> PublicKey -> Bool # max :: PublicKey -> PublicKey -> PublicKey # min :: PublicKey -> PublicKey -> PublicKey #
Ord PublicKey
Instance details Defined in Morley.Tezos.Crypto.P256 Methods compare :: PublicKey -> PublicKey -> Ordering # (<) :: PublicKey -> PublicKey -> Bool # (<=) :: PublicKey -> PublicKey -> Bool # (>) :: PublicKey -> PublicKey -> Bool # (>=) :: PublicKey -> PublicKey -> Bool # max :: PublicKey -> PublicKey -> PublicKey # min :: PublicKey -> PublicKey -> PublicKey #
Ord PublicKey
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Methods compare :: PublicKey -> PublicKey -> Ordering # (<) :: PublicKey -> PublicKey -> Bool # (<=) :: PublicKey -> PublicKey -> Bool # (>) :: PublicKey -> PublicKey -> Bool # (>=) :: PublicKey -> PublicKey -> Bool # max :: PublicKey -> PublicKey -> PublicKey # min :: PublicKey -> PublicKey -> PublicKey #
Ord HexJSONByteString
Instance details Defined in Morley.Util.ByteString Methods compare :: HexJSONByteString -> HexJSONByteString -> Ordering # (<) :: HexJSONByteString -> HexJSONByteString -> Bool # (<=) :: HexJSONByteString -> HexJSONByteString -> Bool # (>) :: HexJSONByteString -> HexJSONByteString -> Bool # (>=) :: HexJSONByteString -> HexJSONByteString -> Bool # max :: HexJSONByteString -> HexJSONByteString -> HexJSONByteString # min :: HexJSONByteString -> HexJSONByteString -> HexJSONByteString #
Ord ByteArray	Non-lexicographic ordering. This compares the lengths of the byte arrays first and uses a lexicographic ordering if the lengths are equal. Subject to change between major versions. Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.ByteArray Methods compare :: ByteArray -> ByteArray -> Ordering # (<) :: ByteArray -> ByteArray -> Bool # (<=) :: ByteArray -> ByteArray -> Bool # (>) :: ByteArray -> ByteArray -> Bool # (>=) :: ByteArray -> ByteArray -> Bool # max :: ByteArray -> ByteArray -> ByteArray # min :: ByteArray -> ByteArray -> ByteArray #
Ord Scientific	Scientific numbers can be safely compared for ordering. No magnitude `10^e` is calculated so there's no risk of a blowup in space or time when comparing scientific numbers coming from untrusted sources.
Instance details Defined in Data.Scientific Methods compare :: Scientific -> Scientific -> Ordering # (<) :: Scientific -> Scientific -> Bool # (<=) :: Scientific -> Scientific -> Bool # (>) :: Scientific -> Scientific -> Bool # (>=) :: Scientific -> Scientific -> Bool # max :: Scientific -> Scientific -> Scientific # min :: Scientific -> Scientific -> Scientific #
Ord Mod2
Instance details Defined in Data.Semiring Methods compare :: Mod2 -> Mod2 -> Ordering # (<) :: Mod2 -> Mod2 -> Bool # (<=) :: Mod2 -> Mod2 -> Bool # (>) :: Mod2 -> Mod2 -> Bool # (>=) :: Mod2 -> Mod2 -> Bool # max :: Mod2 -> Mod2 -> Mod2 # min :: Mod2 -> Mod2 -> Mod2 #
Ord AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: AnnLookup -> AnnLookup -> Ordering # (<) :: AnnLookup -> AnnLookup -> Bool # (<=) :: AnnLookup -> AnnLookup -> Bool # (>) :: AnnLookup -> AnnLookup -> Bool # (>=) :: AnnLookup -> AnnLookup -> Bool # max :: AnnLookup -> AnnLookup -> AnnLookup # min :: AnnLookup -> AnnLookup -> AnnLookup #
Ord AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: AnnTarget -> AnnTarget -> Ordering # (<) :: AnnTarget -> AnnTarget -> Bool # (<=) :: AnnTarget -> AnnTarget -> Bool # (>) :: AnnTarget -> AnnTarget -> Bool # (>=) :: AnnTarget -> AnnTarget -> Bool # max :: AnnTarget -> AnnTarget -> AnnTarget # min :: AnnTarget -> AnnTarget -> AnnTarget #
Ord Bang
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Bang -> Bang -> Ordering # (<) :: Bang -> Bang -> Bool # (<=) :: Bang -> Bang -> Bool # (>) :: Bang -> Bang -> Bool # (>=) :: Bang -> Bang -> Bool # max :: Bang -> Bang -> Bang # min :: Bang -> Bang -> Bang #
Ord Body
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Body -> Body -> Ordering # (<) :: Body -> Body -> Bool # (<=) :: Body -> Body -> Bool # (>) :: Body -> Body -> Bool # (>=) :: Body -> Body -> Bool # max :: Body -> Body -> Body # min :: Body -> Body -> Body #
Ord Bytes
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Bytes -> Bytes -> Ordering # (<) :: Bytes -> Bytes -> Bool # (<=) :: Bytes -> Bytes -> Bool # (>) :: Bytes -> Bytes -> Bool # (>=) :: Bytes -> Bytes -> Bool # max :: Bytes -> Bytes -> Bytes # min :: Bytes -> Bytes -> Bytes #
Ord Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Callconv -> Callconv -> Ordering # (<) :: Callconv -> Callconv -> Bool # (<=) :: Callconv -> Callconv -> Bool # (>) :: Callconv -> Callconv -> Bool # (>=) :: Callconv -> Callconv -> Bool # max :: Callconv -> Callconv -> Callconv # min :: Callconv -> Callconv -> Callconv #
Ord Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Clause -> Clause -> Ordering # (<) :: Clause -> Clause -> Bool # (<=) :: Clause -> Clause -> Bool # (>) :: Clause -> Clause -> Bool # (>=) :: Clause -> Clause -> Bool # max :: Clause -> Clause -> Clause # min :: Clause -> Clause -> Clause #
Ord Con
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Con -> Con -> Ordering # (<) :: Con -> Con -> Bool # (<=) :: Con -> Con -> Bool # (>) :: Con -> Con -> Bool # (>=) :: Con -> Con -> Bool # max :: Con -> Con -> Con # min :: Con -> Con -> Con #
Ord Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Dec -> Dec -> Ordering # (<) :: Dec -> Dec -> Bool # (<=) :: Dec -> Dec -> Bool # (>) :: Dec -> Dec -> Bool # (>=) :: Dec -> Dec -> Bool # max :: Dec -> Dec -> Dec # min :: Dec -> Dec -> Dec #
Ord DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness #
Ord DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: DerivClause -> DerivClause -> Ordering # (<) :: DerivClause -> DerivClause -> Bool # (<=) :: DerivClause -> DerivClause -> Bool # (>) :: DerivClause -> DerivClause -> Bool # (>=) :: DerivClause -> DerivClause -> Bool # max :: DerivClause -> DerivClause -> DerivClause # min :: DerivClause -> DerivClause -> DerivClause #
Ord DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: DerivStrategy -> DerivStrategy -> Ordering # (<) :: DerivStrategy -> DerivStrategy -> Bool # (<=) :: DerivStrategy -> DerivStrategy -> Bool # (>) :: DerivStrategy -> DerivStrategy -> Bool # (>=) :: DerivStrategy -> DerivStrategy -> Bool # max :: DerivStrategy -> DerivStrategy -> DerivStrategy # min :: DerivStrategy -> DerivStrategy -> DerivStrategy #
Ord Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Exp -> Exp -> Ordering # (<) :: Exp -> Exp -> Bool # (<=) :: Exp -> Exp -> Bool # (>) :: Exp -> Exp -> Bool # (>=) :: Exp -> Exp -> Bool # max :: Exp -> Exp -> Exp # min :: Exp -> Exp -> Exp #
Ord FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FamilyResultSig -> FamilyResultSig -> Ordering # (<) :: FamilyResultSig -> FamilyResultSig -> Bool # (<=) :: FamilyResultSig -> FamilyResultSig -> Bool # (>) :: FamilyResultSig -> FamilyResultSig -> Bool # (>=) :: FamilyResultSig -> FamilyResultSig -> Bool # max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig #
Ord Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Fixity -> Fixity -> Ordering # (<) :: Fixity -> Fixity -> Bool # (<=) :: Fixity -> Fixity -> Bool # (>) :: Fixity -> Fixity -> Bool # (>=) :: Fixity -> Fixity -> Bool # max :: Fixity -> Fixity -> Fixity # min :: Fixity -> Fixity -> Fixity #
Ord FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FixityDirection -> FixityDirection -> Ordering # (<) :: FixityDirection -> FixityDirection -> Bool # (<=) :: FixityDirection -> FixityDirection -> Bool # (>) :: FixityDirection -> FixityDirection -> Bool # (>=) :: FixityDirection -> FixityDirection -> Bool # max :: FixityDirection -> FixityDirection -> FixityDirection # min :: FixityDirection -> FixityDirection -> FixityDirection #
Ord Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Foreign -> Foreign -> Ordering # (<) :: Foreign -> Foreign -> Bool # (<=) :: Foreign -> Foreign -> Bool # (>) :: Foreign -> Foreign -> Bool # (>=) :: Foreign -> Foreign -> Bool # max :: Foreign -> Foreign -> Foreign # min :: Foreign -> Foreign -> Foreign #
Ord FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: FunDep -> FunDep -> Ordering # (<) :: FunDep -> FunDep -> Bool # (<=) :: FunDep -> FunDep -> Bool # (>) :: FunDep -> FunDep -> Bool # (>=) :: FunDep -> FunDep -> Bool # max :: FunDep -> FunDep -> FunDep # min :: FunDep -> FunDep -> FunDep #
Ord Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Guard -> Guard -> Ordering # (<) :: Guard -> Guard -> Bool # (<=) :: Guard -> Guard -> Bool # (>) :: Guard -> Guard -> Bool # (>=) :: Guard -> Guard -> Bool # max :: Guard -> Guard -> Guard # min :: Guard -> Guard -> Guard #
Ord Info
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Info -> Info -> Ordering # (<) :: Info -> Info -> Bool # (<=) :: Info -> Info -> Bool # (>) :: Info -> Info -> Bool # (>=) :: Info -> Info -> Bool # max :: Info -> Info -> Info # min :: Info -> Info -> Info #
Ord InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: InjectivityAnn -> InjectivityAnn -> Ordering # (<) :: InjectivityAnn -> InjectivityAnn -> Bool # (<=) :: InjectivityAnn -> InjectivityAnn -> Bool # (>) :: InjectivityAnn -> InjectivityAnn -> Bool # (>=) :: InjectivityAnn -> InjectivityAnn -> Bool # max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn # min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn #
Ord Inline
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Inline -> Inline -> Ordering # (<) :: Inline -> Inline -> Bool # (<=) :: Inline -> Inline -> Bool # (>) :: Inline -> Inline -> Bool # (>=) :: Inline -> Inline -> Bool # max :: Inline -> Inline -> Inline # min :: Inline -> Inline -> Inline #
Ord Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Lit -> Lit -> Ordering # (<) :: Lit -> Lit -> Bool # (<=) :: Lit -> Lit -> Bool # (>) :: Lit -> Lit -> Bool # (>=) :: Lit -> Lit -> Bool # max :: Lit -> Lit -> Lit # min :: Lit -> Lit -> Lit #
Ord Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Loc -> Loc -> Ordering # (<) :: Loc -> Loc -> Bool # (<=) :: Loc -> Loc -> Bool # (>) :: Loc -> Loc -> Bool # (>=) :: Loc -> Loc -> Bool # max :: Loc -> Loc -> Loc # min :: Loc -> Loc -> Loc #
Ord Match
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Match -> Match -> Ordering # (<) :: Match -> Match -> Bool # (<=) :: Match -> Match -> Bool # (>) :: Match -> Match -> Bool # (>=) :: Match -> Match -> Bool # max :: Match -> Match -> Match # min :: Match -> Match -> Match #
Ord ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: ModName -> ModName -> Ordering # (<) :: ModName -> ModName -> Bool # (<=) :: ModName -> ModName -> Bool # (>) :: ModName -> ModName -> Bool # (>=) :: ModName -> ModName -> Bool # max :: ModName -> ModName -> ModName # min :: ModName -> ModName -> ModName #
Ord Module
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Module -> Module -> Ordering # (<) :: Module -> Module -> Bool # (<=) :: Module -> Module -> Bool # (>) :: Module -> Module -> Bool # (>=) :: Module -> Module -> Bool # max :: Module -> Module -> Module # min :: Module -> Module -> Module #
Ord ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: ModuleInfo -> ModuleInfo -> Ordering # (<) :: ModuleInfo -> ModuleInfo -> Bool # (<=) :: ModuleInfo -> ModuleInfo -> Bool # (>) :: ModuleInfo -> ModuleInfo -> Bool # (>=) :: ModuleInfo -> ModuleInfo -> Bool # max :: ModuleInfo -> ModuleInfo -> ModuleInfo # min :: ModuleInfo -> ModuleInfo -> ModuleInfo #
Ord Name
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Name -> Name -> Ordering # (<) :: Name -> Name -> Bool # (<=) :: Name -> Name -> Bool # (>) :: Name -> Name -> Bool # (>=) :: Name -> Name -> Bool # max :: Name -> Name -> Name # min :: Name -> Name -> Name #
Ord NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: NameFlavour -> NameFlavour -> Ordering # (<) :: NameFlavour -> NameFlavour -> Bool # (<=) :: NameFlavour -> NameFlavour -> Bool # (>) :: NameFlavour -> NameFlavour -> Bool # (>=) :: NameFlavour -> NameFlavour -> Bool # max :: NameFlavour -> NameFlavour -> NameFlavour # min :: NameFlavour -> NameFlavour -> NameFlavour #
Ord NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: NameSpace -> NameSpace -> Ordering # (<) :: NameSpace -> NameSpace -> Bool # (<=) :: NameSpace -> NameSpace -> Bool # (>) :: NameSpace -> NameSpace -> Bool # (>=) :: NameSpace -> NameSpace -> Bool # max :: NameSpace -> NameSpace -> NameSpace # min :: NameSpace -> NameSpace -> NameSpace #
Ord OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: OccName -> OccName -> Ordering # (<) :: OccName -> OccName -> Bool # (<=) :: OccName -> OccName -> Bool # (>) :: OccName -> OccName -> Bool # (>=) :: OccName -> OccName -> Bool # max :: OccName -> OccName -> OccName # min :: OccName -> OccName -> OccName #
Ord Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Overlap -> Overlap -> Ordering # (<) :: Overlap -> Overlap -> Bool # (<=) :: Overlap -> Overlap -> Bool # (>) :: Overlap -> Overlap -> Bool # (>=) :: Overlap -> Overlap -> Bool # max :: Overlap -> Overlap -> Overlap # min :: Overlap -> Overlap -> Overlap #
Ord Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Pat -> Pat -> Ordering # (<) :: Pat -> Pat -> Bool # (<=) :: Pat -> Pat -> Bool # (>) :: Pat -> Pat -> Bool # (>=) :: Pat -> Pat -> Bool # max :: Pat -> Pat -> Pat # min :: Pat -> Pat -> Pat #
Ord PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynArgs -> PatSynArgs -> Ordering # (<) :: PatSynArgs -> PatSynArgs -> Bool # (<=) :: PatSynArgs -> PatSynArgs -> Bool # (>) :: PatSynArgs -> PatSynArgs -> Bool # (>=) :: PatSynArgs -> PatSynArgs -> Bool # max :: PatSynArgs -> PatSynArgs -> PatSynArgs # min :: PatSynArgs -> PatSynArgs -> PatSynArgs #
Ord PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynDir -> PatSynDir -> Ordering # (<) :: PatSynDir -> PatSynDir -> Bool # (<=) :: PatSynDir -> PatSynDir -> Bool # (>) :: PatSynDir -> PatSynDir -> Bool # (>=) :: PatSynDir -> PatSynDir -> Bool # max :: PatSynDir -> PatSynDir -> PatSynDir # min :: PatSynDir -> PatSynDir -> PatSynDir #
Ord Phases
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Phases -> Phases -> Ordering # (<) :: Phases -> Phases -> Bool # (<=) :: Phases -> Phases -> Bool # (>) :: Phases -> Phases -> Bool # (>=) :: Phases -> Phases -> Bool # max :: Phases -> Phases -> Phases # min :: Phases -> Phases -> Phases #
Ord PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: PkgName -> PkgName -> Ordering # (<) :: PkgName -> PkgName -> Bool # (<=) :: PkgName -> PkgName -> Bool # (>) :: PkgName -> PkgName -> Bool # (>=) :: PkgName -> PkgName -> Bool # max :: PkgName -> PkgName -> PkgName # min :: PkgName -> PkgName -> PkgName #
Ord Pragma
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Pragma -> Pragma -> Ordering # (<) :: Pragma -> Pragma -> Bool # (<=) :: Pragma -> Pragma -> Bool # (>) :: Pragma -> Pragma -> Bool # (>=) :: Pragma -> Pragma -> Bool # max :: Pragma -> Pragma -> Pragma # min :: Pragma -> Pragma -> Pragma #
Ord Range
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Range -> Range -> Ordering # (<) :: Range -> Range -> Bool # (<=) :: Range -> Range -> Bool # (>) :: Range -> Range -> Bool # (>=) :: Range -> Range -> Bool # max :: Range -> Range -> Range # min :: Range -> Range -> Range #
Ord Role
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Role -> Role -> Ordering # (<) :: Role -> Role -> Bool # (<=) :: Role -> Role -> Bool # (>) :: Role -> Role -> Bool # (>=) :: Role -> Role -> Bool # max :: Role -> Role -> Role # min :: Role -> Role -> Role #
Ord RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: RuleBndr -> RuleBndr -> Ordering # (<) :: RuleBndr -> RuleBndr -> Bool # (<=) :: RuleBndr -> RuleBndr -> Bool # (>) :: RuleBndr -> RuleBndr -> Bool # (>=) :: RuleBndr -> RuleBndr -> Bool # max :: RuleBndr -> RuleBndr -> RuleBndr # min :: RuleBndr -> RuleBndr -> RuleBndr #
Ord RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: RuleMatch -> RuleMatch -> Ordering # (<) :: RuleMatch -> RuleMatch -> Bool # (<=) :: RuleMatch -> RuleMatch -> Bool # (>) :: RuleMatch -> RuleMatch -> Bool # (>=) :: RuleMatch -> RuleMatch -> Bool # max :: RuleMatch -> RuleMatch -> RuleMatch # min :: RuleMatch -> RuleMatch -> RuleMatch #
Ord Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Safety -> Safety -> Ordering # (<) :: Safety -> Safety -> Bool # (<=) :: Safety -> Safety -> Bool # (>) :: Safety -> Safety -> Bool # (>=) :: Safety -> Safety -> Bool # max :: Safety -> Safety -> Safety # min :: Safety -> Safety -> Safety #
Ord SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness #
Ord SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness #
Ord Specificity
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Specificity -> Specificity -> Ordering # (<) :: Specificity -> Specificity -> Bool # (<=) :: Specificity -> Specificity -> Bool # (>) :: Specificity -> Specificity -> Bool # (>=) :: Specificity -> Specificity -> Bool # max :: Specificity -> Specificity -> Specificity # min :: Specificity -> Specificity -> Specificity #
Ord Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Stmt -> Stmt -> Ordering # (<) :: Stmt -> Stmt -> Bool # (<=) :: Stmt -> Stmt -> Bool # (>) :: Stmt -> Stmt -> Bool # (>=) :: Stmt -> Stmt -> Bool # max :: Stmt -> Stmt -> Stmt # min :: Stmt -> Stmt -> Stmt #
Ord TyLit
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TyLit -> TyLit -> Ordering # (<) :: TyLit -> TyLit -> Bool # (<=) :: TyLit -> TyLit -> Bool # (>) :: TyLit -> TyLit -> Bool # (>=) :: TyLit -> TyLit -> Bool # max :: TyLit -> TyLit -> TyLit # min :: TyLit -> TyLit -> TyLit #
Ord TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TySynEqn -> TySynEqn -> Ordering # (<) :: TySynEqn -> TySynEqn -> Bool # (<=) :: TySynEqn -> TySynEqn -> Bool # (>) :: TySynEqn -> TySynEqn -> Bool # (>=) :: TySynEqn -> TySynEqn -> Bool # max :: TySynEqn -> TySynEqn -> TySynEqn # min :: TySynEqn -> TySynEqn -> TySynEqn #
Ord Type
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: Type -> Type -> Ordering # (<) :: Type -> Type -> Bool # (<=) :: Type -> Type -> Bool # (>) :: Type -> Type -> Bool # (>=) :: Type -> Type -> Bool # max :: Type -> Type -> Type # min :: Type -> Type -> Type #
Ord TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering # (<) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead # min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead #
Ord Builder
Instance details Defined in Data.Text.Internal.Builder Methods compare :: Builder -> Builder -> Ordering # (<) :: Builder -> Builder -> Bool # (<=) :: Builder -> Builder -> Bool # (>) :: Builder -> Builder -> Bool # (>=) :: Builder -> Builder -> Bool # max :: Builder -> Builder -> Builder # min :: Builder -> Builder -> Builder #
Ord B
Instance details Defined in Data.Text.Short.Internal Methods compare :: B -> B -> Ordering # (<) :: B -> B -> Bool # (<=) :: B -> B -> Bool # (>) :: B -> B -> Bool # (>=) :: B -> B -> Bool # max :: B -> B -> B # min :: B -> B -> B #
Ord ShortText
Instance details Defined in Data.Text.Short.Internal Methods compare :: ShortText -> ShortText -> Ordering # (<) :: ShortText -> ShortText -> Bool # (<=) :: ShortText -> ShortText -> Bool # (>) :: ShortText -> ShortText -> Bool # (>=) :: ShortText -> ShortText -> Bool # max :: ShortText -> ShortText -> ShortText # min :: ShortText -> ShortText -> ShortText #
Ord ConstructorVariant
Instance details Defined in Language.Haskell.TH.Datatype Methods compare :: ConstructorVariant -> ConstructorVariant -> Ordering # (<) :: ConstructorVariant -> ConstructorVariant -> Bool # (<=) :: ConstructorVariant -> ConstructorVariant -> Bool # (>) :: ConstructorVariant -> ConstructorVariant -> Bool # (>=) :: ConstructorVariant -> ConstructorVariant -> Bool # max :: ConstructorVariant -> ConstructorVariant -> ConstructorVariant # min :: ConstructorVariant -> ConstructorVariant -> ConstructorVariant #
Ord DatatypeVariant
Instance details Defined in Language.Haskell.TH.Datatype Methods compare :: DatatypeVariant -> DatatypeVariant -> Ordering # (<) :: DatatypeVariant -> DatatypeVariant -> Bool # (<=) :: DatatypeVariant -> DatatypeVariant -> Bool # (>) :: DatatypeVariant -> DatatypeVariant -> Bool # (>=) :: DatatypeVariant -> DatatypeVariant -> Bool # max :: DatatypeVariant -> DatatypeVariant -> DatatypeVariant # min :: DatatypeVariant -> DatatypeVariant -> DatatypeVariant #
Ord FieldStrictness
Instance details Defined in Language.Haskell.TH.Datatype Methods compare :: FieldStrictness -> FieldStrictness -> Ordering # (<) :: FieldStrictness -> FieldStrictness -> Bool # (<=) :: FieldStrictness -> FieldStrictness -> Bool # (>) :: FieldStrictness -> FieldStrictness -> Bool # (>=) :: FieldStrictness -> FieldStrictness -> Bool # max :: FieldStrictness -> FieldStrictness -> FieldStrictness # min :: FieldStrictness -> FieldStrictness -> FieldStrictness #
Ord Strictness
Instance details Defined in Language.Haskell.TH.Datatype Methods compare :: Strictness -> Strictness -> Ordering # (<) :: Strictness -> Strictness -> Bool # (<=) :: Strictness -> Strictness -> Bool # (>) :: Strictness -> Strictness -> Bool # (>=) :: Strictness -> Strictness -> Bool # max :: Strictness -> Strictness -> Strictness # min :: Strictness -> Strictness -> Strictness #
Ord Unpackedness
Instance details Defined in Language.Haskell.TH.Datatype Methods compare :: Unpackedness -> Unpackedness -> Ordering # (<) :: Unpackedness -> Unpackedness -> Bool # (<=) :: Unpackedness -> Unpackedness -> Bool # (>) :: Unpackedness -> Unpackedness -> Bool # (>=) :: Unpackedness -> Unpackedness -> Bool # max :: Unpackedness -> Unpackedness -> Unpackedness # min :: Unpackedness -> Unpackedness -> Unpackedness #
Ord NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods compare :: NominalDiffTime -> NominalDiffTime -> Ordering # (<) :: NominalDiffTime -> NominalDiffTime -> Bool # (<=) :: NominalDiffTime -> NominalDiffTime -> Bool # (>) :: NominalDiffTime -> NominalDiffTime -> Bool # (>=) :: NominalDiffTime -> NominalDiffTime -> Bool # max :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # min :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime #
Ord UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods compare :: UTCTime -> UTCTime -> Ordering # (<) :: UTCTime -> UTCTime -> Bool # (<=) :: UTCTime -> UTCTime -> Bool # (>) :: UTCTime -> UTCTime -> Bool # (>=) :: UTCTime -> UTCTime -> Bool # max :: UTCTime -> UTCTime -> UTCTime # min :: UTCTime -> UTCTime -> UTCTime #
Ord LocalTime
Instance details Defined in Data.Time.LocalTime.Internal.LocalTime Methods compare :: LocalTime -> LocalTime -> Ordering # (<) :: LocalTime -> LocalTime -> Bool # (<=) :: LocalTime -> LocalTime -> Bool # (>) :: LocalTime -> LocalTime -> Bool # (>=) :: LocalTime -> LocalTime -> Bool # max :: LocalTime -> LocalTime -> LocalTime # min :: LocalTime -> LocalTime -> LocalTime #
Ord Undefined
Instance details Defined in Universum.Debug Methods compare :: Undefined -> Undefined -> Ordering # (<) :: Undefined -> Undefined -> Bool # (<=) :: Undefined -> Undefined -> Bool # (>) :: Undefined -> Undefined -> Bool # (>=) :: Undefined -> Undefined -> Bool # max :: Undefined -> Undefined -> Undefined # min :: Undefined -> Undefined -> Undefined #
Ord UUID
Instance details Defined in Data.UUID.Types.Internal Methods compare :: UUID -> UUID -> Ordering # (<) :: UUID -> UUID -> Bool # (<=) :: UUID -> UUID -> Bool # (>) :: UUID -> UUID -> Bool # (>=) :: UUID -> UUID -> Bool # max :: UUID -> UUID -> UUID # min :: UUID -> UUID -> UUID #
Ord UnpackedUUID
Instance details Defined in Data.UUID.Types.Internal Methods compare :: UnpackedUUID -> UnpackedUUID -> Ordering # (<) :: UnpackedUUID -> UnpackedUUID -> Bool # (<=) :: UnpackedUUID -> UnpackedUUID -> Bool # (>) :: UnpackedUUID -> UnpackedUUID -> Bool # (>=) :: UnpackedUUID -> UnpackedUUID -> Bool # max :: UnpackedUUID -> UnpackedUUID -> UnpackedUUID # min :: UnpackedUUID -> UnpackedUUID -> UnpackedUUID #
Ord Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word8 -> Word8 -> Ordering # (<) :: Word8 -> Word8 -> Bool # (<=) :: Word8 -> Word8 -> Bool # (>) :: Word8 -> Word8 -> Bool # (>=) :: Word8 -> Word8 -> Bool # max :: Word8 -> Word8 -> Word8 # min :: Word8 -> Word8 -> Word8 #
Ord Integer
Instance details Defined in GHC.Num.Integer Methods compare :: Integer -> Integer -> Ordering # (<) :: Integer -> Integer -> Bool # (<=) :: Integer -> Integer -> Bool # (>) :: Integer -> Integer -> Bool # (>=) :: Integer -> Integer -> Bool # max :: Integer -> Integer -> Integer # min :: Integer -> Integer -> Integer #
Ord Natural
Instance details Defined in GHC.Num.Natural Methods compare :: Natural -> Natural -> Ordering # (<) :: Natural -> Natural -> Bool # (<=) :: Natural -> Natural -> Bool # (>) :: Natural -> Natural -> Bool # (>=) :: Natural -> Natural -> Bool # max :: Natural -> Natural -> Natural # min :: Natural -> Natural -> Natural #
Ord ()
Instance details Defined in GHC.Classes Methods compare :: () -> () -> Ordering # (<) :: () -> () -> Bool # (<=) :: () -> () -> Bool # (>) :: () -> () -> Bool # (>=) :: () -> () -> Bool # max :: () -> () -> () # min :: () -> () -> () #
Ord Bool
Instance details Defined in GHC.Classes Methods compare :: Bool -> Bool -> Ordering # (<) :: Bool -> Bool -> Bool # (<=) :: Bool -> Bool -> Bool # (>) :: Bool -> Bool -> Bool # (>=) :: Bool -> Bool -> Bool # max :: Bool -> Bool -> Bool # min :: Bool -> Bool -> Bool #
Ord Char
Instance details Defined in GHC.Classes Methods compare :: Char -> Char -> Ordering # (<) :: Char -> Char -> Bool # (<=) :: Char -> Char -> Bool # (>) :: Char -> Char -> Bool # (>=) :: Char -> Char -> Bool # max :: Char -> Char -> Char # min :: Char -> Char -> Char #
Ord Double	Note that due to the presence of `NaN`, `Double`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Double)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Double`'s instance: `>>>` `(0/0 :: Double) > 1`False `>>>` `compare (0/0 :: Double) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Double -> Double -> Ordering # (<) :: Double -> Double -> Bool # (<=) :: Double -> Double -> Bool # (>) :: Double -> Double -> Bool # (>=) :: Double -> Double -> Bool # max :: Double -> Double -> Double # min :: Double -> Double -> Double #
Ord Float	Note that due to the presence of `NaN`, `Float`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Float)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Float`'s instance: `>>>` `(0/0 :: Float) > 1`False `>>>` `compare (0/0 :: Float) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Float -> Float -> Ordering # (<) :: Float -> Float -> Bool # (<=) :: Float -> Float -> Bool # (>) :: Float -> Float -> Bool # (>=) :: Float -> Float -> Bool # max :: Float -> Float -> Float # min :: Float -> Float -> Float #
Ord Int
Instance details Defined in GHC.Classes Methods compare :: Int -> Int -> Ordering # (<) :: Int -> Int -> Bool # (<=) :: Int -> Int -> Bool # (>) :: Int -> Int -> Bool # (>=) :: Int -> Int -> Bool # max :: Int -> Int -> Int # min :: Int -> Int -> Int #
Ord Word
Instance details Defined in GHC.Classes Methods compare :: Word -> Word -> Ordering # (<) :: Word -> Word -> Bool # (<=) :: Word -> Word -> Bool # (>) :: Word -> Word -> Bool # (>=) :: Word -> Word -> Bool # max :: Word -> Word -> Word # min :: Word -> Word -> Word #
() :=> (Ord (a :- b))
Instance details Defined in Data.Constraint Methods ins :: () :- Ord (a :- b) #
() :=> (Ord (Dict a))
Instance details Defined in Data.Constraint Methods ins :: () :- Ord (Dict a) #
() :=> (Ord Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Integer #
() :=> (Ord Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Natural #
() :=> (Ord ())
Instance details Defined in Data.Constraint Methods ins :: () :- Ord () #
() :=> (Ord Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Bool #
() :=> (Ord Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Char #
() :=> (Ord Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Double #
() :=> (Ord Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Float #
() :=> (Ord Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Int #
() :=> (Ord Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Word #
Ord a => Ord (First' a)
Instance details Defined in Distribution.Compat.Semigroup Methods compare :: First' a -> First' a -> Ordering # (<) :: First' a -> First' a -> Bool # (<=) :: First' a -> First' a -> Bool # (>) :: First' a -> First' a -> Bool # (>=) :: First' a -> First' a -> Bool # max :: First' a -> First' a -> First' a # min :: First' a -> First' a -> First' a #
Ord a => Ord (Last' a)
Instance details Defined in Distribution.Compat.Semigroup Methods compare :: Last' a -> Last' a -> Ordering # (<) :: Last' a -> Last' a -> Bool # (<=) :: Last' a -> Last' a -> Bool # (>) :: Last' a -> Last' a -> Bool # (>=) :: Last' a -> Last' a -> Bool # max :: Last' a -> Last' a -> Last' a # min :: Last' a -> Last' a -> Last' a #
Ord a => Ord (Option' a)
Instance details Defined in Distribution.Compat.Semigroup Methods compare :: Option' a -> Option' a -> Ordering # (<) :: Option' a -> Option' a -> Bool # (<=) :: Option' a -> Option' a -> Bool # (>) :: Option' a -> Option' a -> Bool # (>=) :: Option' a -> Option' a -> Bool # max :: Option' a -> Option' a -> Option' a # min :: Option' a -> Option' a -> Option' a #
Ord v => Ord (KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods compare :: KeyMap v -> KeyMap v -> Ordering # (<) :: KeyMap v -> KeyMap v -> Bool # (<=) :: KeyMap v -> KeyMap v -> Bool # (>) :: KeyMap v -> KeyMap v -> Bool # (>=) :: KeyMap v -> KeyMap v -> Bool # max :: KeyMap v -> KeyMap v -> KeyMap v # min :: KeyMap v -> KeyMap v -> KeyMap v #
Ord a => Ord (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods compare :: ZipList a -> ZipList a -> Ordering # (<) :: ZipList a -> ZipList a -> Bool # (<=) :: ZipList a -> ZipList a -> Bool # (>) :: ZipList a -> ZipList a -> Bool # (>=) :: ZipList a -> ZipList a -> Bool # max :: ZipList a -> ZipList a -> ZipList a # min :: ZipList a -> ZipList a -> ZipList a #
Ord a => Ord (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering # (<) :: Identity a -> Identity a -> Bool # (<=) :: Identity a -> Identity a -> Bool # (>) :: Identity a -> Identity a -> Bool # (>=) :: Identity a -> Identity a -> Bool # max :: Identity a -> Identity a -> Identity a # min :: Identity a -> Identity a -> Identity a #
Ord a => Ord (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods compare :: First a -> First a -> Ordering # (<) :: First a -> First a -> Bool # (<=) :: First a -> First a -> Bool # (>) :: First a -> First a -> Bool # (>=) :: First a -> First a -> Bool # max :: First a -> First a -> First a # min :: First a -> First a -> First a #
Ord a => Ord (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods compare :: Last a -> Last a -> Ordering # (<) :: Last a -> Last a -> Bool # (<=) :: Last a -> Last a -> Bool # (>) :: Last a -> Last a -> Bool # (>=) :: Last a -> Last a -> Bool # max :: Last a -> Last a -> Last a # min :: Last a -> Last a -> Last a #
Ord a => Ord (Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods compare :: Down a -> Down a -> Ordering # (<) :: Down a -> Down a -> Bool # (<=) :: Down a -> Down a -> Bool # (>) :: Down a -> Down a -> Bool # (>=) :: Down a -> Down a -> Bool # max :: Down a -> Down a -> Down a # min :: Down a -> Down a -> Down a #
Ord a => Ord (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: First a -> First a -> Ordering # (<) :: First a -> First a -> Bool # (<=) :: First a -> First a -> Bool # (>) :: First a -> First a -> Bool # (>=) :: First a -> First a -> Bool # max :: First a -> First a -> First a # min :: First a -> First a -> First a #
Ord a => Ord (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Last a -> Last a -> Ordering # (<) :: Last a -> Last a -> Bool # (<=) :: Last a -> Last a -> Bool # (>) :: Last a -> Last a -> Bool # (>=) :: Last a -> Last a -> Bool # max :: Last a -> Last a -> Last a # min :: Last a -> Last a -> Last a #
Ord a => Ord (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Max a -> Max a -> Ordering # (<) :: Max a -> Max a -> Bool # (<=) :: Max a -> Max a -> Bool # (>) :: Max a -> Max a -> Bool # (>=) :: Max a -> Max a -> Bool # max :: Max a -> Max a -> Max a # min :: Max a -> Max a -> Max a #
Ord a => Ord (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Min a -> Min a -> Ordering # (<) :: Min a -> Min a -> Bool # (<=) :: Min a -> Min a -> Bool # (>) :: Min a -> Min a -> Bool # (>=) :: Min a -> Min a -> Bool # max :: Min a -> Min a -> Min a # min :: Min a -> Min a -> Min a #
Ord a => Ord (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Option a -> Option a -> Ordering # (<) :: Option a -> Option a -> Bool # (<=) :: Option a -> Option a -> Bool # (>) :: Option a -> Option a -> Bool # (>=) :: Option a -> Option a -> Bool # max :: Option a -> Option a -> Option a # min :: Option a -> Option a -> Option a #
Ord m => Ord (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m #
Ord a => Ord (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Dual a -> Dual a -> Ordering # (<) :: Dual a -> Dual a -> Bool # (<=) :: Dual a -> Dual a -> Bool # (>) :: Dual a -> Dual a -> Bool # (>=) :: Dual a -> Dual a -> Bool # max :: Dual a -> Dual a -> Dual a # min :: Dual a -> Dual a -> Dual a #
Ord a => Ord (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Product a -> Product a -> Ordering # (<) :: Product a -> Product a -> Bool # (<=) :: Product a -> Product a -> Bool # (>) :: Product a -> Product a -> Bool # (>=) :: Product a -> Product a -> Bool # max :: Product a -> Product a -> Product a # min :: Product a -> Product a -> Product a #
Ord a => Ord (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Sum a -> Sum a -> Ordering # (<) :: Sum a -> Sum a -> Bool # (<=) :: Sum a -> Sum a -> Bool # (>) :: Sum a -> Sum a -> Bool # (>=) :: Sum a -> Sum a -> Bool # max :: Sum a -> Sum a -> Sum a # min :: Sum a -> Sum a -> Sum a #
Ord a => Ord (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods compare :: NonEmpty a -> NonEmpty a -> Ordering # (<) :: NonEmpty a -> NonEmpty a -> Bool # (<=) :: NonEmpty a -> NonEmpty a -> Bool # (>) :: NonEmpty a -> NonEmpty a -> Bool # (>=) :: NonEmpty a -> NonEmpty a -> Bool # max :: NonEmpty a -> NonEmpty a -> NonEmpty a # min :: NonEmpty a -> NonEmpty a -> NonEmpty a #
Ord (ForeignPtr a)	Since: base-2.1
Instance details Defined in GHC.ForeignPtr Methods compare :: ForeignPtr a -> ForeignPtr a -> Ordering # (<) :: ForeignPtr a -> ForeignPtr a -> Bool # (<=) :: ForeignPtr a -> ForeignPtr a -> Bool # (>) :: ForeignPtr a -> ForeignPtr a -> Bool # (>=) :: ForeignPtr a -> ForeignPtr a -> Bool # max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a # min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a #
Ord p => Ord (Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: Par1 p -> Par1 p -> Ordering # (<) :: Par1 p -> Par1 p -> Bool # (<=) :: Par1 p -> Par1 p -> Bool # (>) :: Par1 p -> Par1 p -> Bool # (>=) :: Par1 p -> Par1 p -> Bool # max :: Par1 p -> Par1 p -> Par1 p # min :: Par1 p -> Par1 p -> Par1 p #
Ord (FunPtr a)
Instance details Defined in GHC.Ptr Methods compare :: FunPtr a -> FunPtr a -> Ordering # (<) :: FunPtr a -> FunPtr a -> Bool # (<=) :: FunPtr a -> FunPtr a -> Bool # (>) :: FunPtr a -> FunPtr a -> Bool # (>=) :: FunPtr a -> FunPtr a -> Bool # max :: FunPtr a -> FunPtr a -> FunPtr a # min :: FunPtr a -> FunPtr a -> FunPtr a #
Ord (Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods compare :: Ptr a -> Ptr a -> Ordering # (<) :: Ptr a -> Ptr a -> Bool # (<=) :: Ptr a -> Ptr a -> Bool # (>) :: Ptr a -> Ptr a -> Bool # (>=) :: Ptr a -> Ptr a -> Bool # max :: Ptr a -> Ptr a -> Ptr a # min :: Ptr a -> Ptr a -> Ptr a #
Integral a => Ord (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods compare :: Ratio a -> Ratio a -> Ordering # (<) :: Ratio a -> Ratio a -> Bool # (<=) :: Ratio a -> Ratio a -> Bool # (>) :: Ratio a -> Ratio a -> Bool # (>=) :: Ratio a -> Ratio a -> Bool # max :: Ratio a -> Ratio a -> Ratio a # min :: Ratio a -> Ratio a -> Ratio a #
Ord (Bits n)
Instance details Defined in Basement.Bits Methods compare :: Bits n -> Bits n -> Ordering # (<) :: Bits n -> Bits n -> Bool # (<=) :: Bits n -> Bits n -> Bool # (>) :: Bits n -> Bits n -> Bool # (>=) :: Bits n -> Bits n -> Bool # max :: Bits n -> Bits n -> Bits n # min :: Bits n -> Bits n -> Bits n #
(PrimType ty, Ord ty) => Ord (Block ty)
Instance details Defined in Basement.Block.Base Methods compare :: Block ty -> Block ty -> Ordering # (<) :: Block ty -> Block ty -> Bool # (<=) :: Block ty -> Block ty -> Bool # (>) :: Block ty -> Block ty -> Bool # (>=) :: Block ty -> Block ty -> Bool # max :: Block ty -> Block ty -> Block ty # min :: Block ty -> Block ty -> Block ty #
Ord (Zn n)
Instance details Defined in Basement.Bounded Methods compare :: Zn n -> Zn n -> Ordering # (<) :: Zn n -> Zn n -> Bool # (<=) :: Zn n -> Zn n -> Bool # (>) :: Zn n -> Zn n -> Bool # (>=) :: Zn n -> Zn n -> Bool # max :: Zn n -> Zn n -> Zn n # min :: Zn n -> Zn n -> Zn n #
Ord (Zn64 n)
Instance details Defined in Basement.Bounded Methods compare :: Zn64 n -> Zn64 n -> Ordering # (<) :: Zn64 n -> Zn64 n -> Bool # (<=) :: Zn64 n -> Zn64 n -> Bool # (>) :: Zn64 n -> Zn64 n -> Bool # (>=) :: Zn64 n -> Zn64 n -> Bool # max :: Zn64 n -> Zn64 n -> Zn64 n # min :: Zn64 n -> Zn64 n -> Zn64 n #
Ord a => Ord (Array a)
Instance details Defined in Basement.BoxedArray Methods compare :: Array a -> Array a -> Ordering # (<) :: Array a -> Array a -> Bool # (<=) :: Array a -> Array a -> Bool # (>) :: Array a -> Array a -> Bool # (>=) :: Array a -> Array a -> Bool # max :: Array a -> Array a -> Array a # min :: Array a -> Array a -> Array a #
Ord (CountOf ty)
Instance details Defined in Basement.Types.OffsetSize Methods compare :: CountOf ty -> CountOf ty -> Ordering # (<) :: CountOf ty -> CountOf ty -> Bool # (<=) :: CountOf ty -> CountOf ty -> Bool # (>) :: CountOf ty -> CountOf ty -> Bool # (>=) :: CountOf ty -> CountOf ty -> Bool # max :: CountOf ty -> CountOf ty -> CountOf ty # min :: CountOf ty -> CountOf ty -> CountOf ty #
Ord (Offset ty)
Instance details Defined in Basement.Types.OffsetSize Methods compare :: Offset ty -> Offset ty -> Ordering # (<) :: Offset ty -> Offset ty -> Bool # (<=) :: Offset ty -> Offset ty -> Bool # (>) :: Offset ty -> Offset ty -> Bool # (>=) :: Offset ty -> Offset ty -> Bool # max :: Offset ty -> Offset ty -> Offset ty # min :: Offset ty -> Offset ty -> Offset ty #
(PrimType ty, Ord ty) => Ord (UArray ty)
Instance details Defined in Basement.UArray.Base Methods compare :: UArray ty -> UArray ty -> Ordering # (<) :: UArray ty -> UArray ty -> Bool # (<=) :: UArray ty -> UArray ty -> Bool # (>) :: UArray ty -> UArray ty -> Bool # (>=) :: UArray ty -> UArray ty -> Bool # max :: UArray ty -> UArray ty -> UArray ty # min :: UArray ty -> UArray ty -> UArray ty #
Ord (Dict a)
Instance details 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 #
Ord a => Ord (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods compare :: IntMap a -> IntMap a -> Ordering # (<) :: IntMap a -> IntMap a -> Bool # (<=) :: IntMap a -> IntMap a -> Bool # (>) :: IntMap a -> IntMap a -> Bool # (>=) :: IntMap a -> IntMap a -> Bool # max :: IntMap a -> IntMap a -> IntMap a # min :: IntMap a -> IntMap a -> IntMap a #
Ord a => Ord (Seq a)
Instance details Defined in Data.Sequence.Internal Methods compare :: Seq a -> Seq a -> Ordering # (<) :: Seq a -> Seq a -> Bool # (<=) :: Seq a -> Seq a -> Bool # (>) :: Seq a -> Seq a -> Bool # (>=) :: Seq a -> Seq a -> Bool # max :: Seq a -> Seq a -> Seq a # min :: Seq a -> Seq a -> Seq a #
Ord a => Ord (ViewL a)
Instance details Defined in Data.Sequence.Internal Methods compare :: ViewL a -> ViewL a -> Ordering # (<) :: ViewL a -> ViewL a -> Bool # (<=) :: ViewL a -> ViewL a -> Bool # (>) :: ViewL a -> ViewL a -> Bool # (>=) :: ViewL a -> ViewL a -> Bool # max :: ViewL a -> ViewL a -> ViewL a # min :: ViewL a -> ViewL a -> ViewL a #
Ord a => Ord (ViewR a)
Instance details Defined in Data.Sequence.Internal Methods compare :: ViewR a -> ViewR a -> Ordering # (<) :: ViewR a -> ViewR a -> Bool # (<=) :: ViewR a -> ViewR a -> Bool # (>) :: ViewR a -> ViewR a -> Bool # (>=) :: ViewR a -> ViewR a -> Bool # max :: ViewR a -> ViewR a -> ViewR a # min :: ViewR a -> ViewR a -> ViewR a #
Ord a => Ord (Set a)
Instance details Defined in Data.Set.Internal Methods compare :: Set a -> Set a -> Ordering # (<) :: Set a -> Set a -> Bool # (<=) :: Set a -> Set a -> Bool # (>) :: Set a -> Set a -> Bool # (>=) :: Set a -> Set a -> Bool # max :: Set a -> Set a -> Set a # min :: Set a -> Set a -> Set a #
Ord1 f => Ord (Fix f)
Instance details Defined in Data.Fix Methods compare :: Fix f -> Fix f -> Ordering # (<) :: Fix f -> Fix f -> Bool # (<=) :: Fix f -> Fix f -> Bool # (>) :: Fix f -> Fix f -> Bool # (>=) :: Fix f -> Fix f -> Bool # max :: Fix f -> Fix f -> Fix f # min :: Fix f -> Fix f -> Fix f #
(Functor f, Ord1 f) => Ord (Mu f)
Instance details Defined in Data.Fix Methods compare :: Mu f -> Mu f -> Ordering # (<) :: Mu f -> Mu f -> Bool # (<=) :: Mu f -> Mu f -> Bool # (>) :: Mu f -> Mu f -> Bool # (>=) :: Mu f -> Mu f -> Bool # max :: Mu f -> Mu f -> Mu f # min :: Mu f -> Mu f -> Mu f #
(Functor f, Ord1 f) => Ord (Nu f)
Instance details Defined in Data.Fix Methods compare :: Nu f -> Nu f -> Ordering # (<) :: Nu f -> Nu f -> Bool # (<=) :: Nu f -> Nu f -> Bool # (>) :: Nu f -> Nu f -> Bool # (>=) :: Nu f -> Nu f -> Bool # max :: Nu f -> Nu f -> Nu f # min :: Nu f -> Nu f -> Nu f #
Ord a => Ord (DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods compare :: DNonEmpty a -> DNonEmpty a -> Ordering # (<) :: DNonEmpty a -> DNonEmpty a -> Bool # (<=) :: DNonEmpty a -> DNonEmpty a -> Bool # (>) :: DNonEmpty a -> DNonEmpty a -> Bool # (>=) :: DNonEmpty a -> DNonEmpty a -> Bool # max :: DNonEmpty a -> DNonEmpty a -> DNonEmpty a # min :: DNonEmpty a -> DNonEmpty a -> DNonEmpty a #
Ord a => Ord (DList a)
Instance details Defined in Data.DList.Internal Methods compare :: DList a -> DList a -> Ordering # (<) :: DList a -> DList a -> Bool # (<=) :: DList a -> DList a -> Bool # (>) :: DList a -> DList a -> Bool # (>=) :: DList a -> DList a -> Bool # max :: DList a -> DList a -> DList a # min :: DList a -> DList a -> DList a #
Ord (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods compare :: Binary p -> Binary p -> Ordering # (<) :: Binary p -> Binary p -> Bool # (<=) :: Binary p -> Binary p -> Bool # (>) :: Binary p -> Binary p -> Bool # (>=) :: Binary p -> Binary p -> Bool # max :: Binary p -> Binary p -> Binary p # min :: Binary p -> Binary p -> Binary p #
Ord (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods compare :: Prime p -> Prime p -> Ordering # (<) :: Prime p -> Prime p -> Bool # (<=) :: Prime p -> Prime p -> Bool # (>) :: Prime p -> Prime p -> Bool # (>=) :: Prime p -> Prime p -> Bool # max :: Prime p -> Prime p -> Prime p # min :: Prime p -> Prime p -> Prime p #
Ord a => Ord (Hashed a)
Instance details Defined in Data.Hashable.Class Methods compare :: Hashed a -> Hashed a -> Ordering # (<) :: Hashed a -> Hashed a -> Bool # (<=) :: Hashed a -> Hashed a -> Bool # (>) :: Hashed a -> Hashed a -> Bool # (>=) :: Hashed a -> Hashed a -> Bool # max :: Hashed a -> Hashed a -> Hashed a # min :: Hashed a -> Hashed a -> Hashed a #
Ord (Packed a)
Instance details Defined in Lorentz.Bytes Methods compare :: Packed a -> Packed a -> Ordering # (<) :: Packed a -> Packed a -> Bool # (<=) :: Packed a -> Packed a -> Bool # (>) :: Packed a -> Packed a -> Bool # (>=) :: Packed a -> Packed a -> Bool # max :: Packed a -> Packed a -> Packed a # min :: Packed a -> Packed a -> Packed a #
Ord a => Ord (ReadTicket a)
Instance details Defined in Lorentz.Value Methods compare :: ReadTicket a -> ReadTicket a -> Ordering # (<) :: ReadTicket a -> ReadTicket a -> Bool # (<=) :: ReadTicket a -> ReadTicket a -> Bool # (>) :: ReadTicket a -> ReadTicket a -> Bool # (>=) :: ReadTicket a -> ReadTicket a -> Bool # max :: ReadTicket a -> ReadTicket a -> ReadTicket a # min :: ReadTicket a -> ReadTicket a -> ReadTicket a #
Ord e => Ord (ErrorFancy e)
Instance details Defined in Text.Megaparsec.Error Methods compare :: ErrorFancy e -> ErrorFancy e -> Ordering # (<) :: ErrorFancy e -> ErrorFancy e -> Bool # (<=) :: ErrorFancy e -> ErrorFancy e -> Bool # (>) :: ErrorFancy e -> ErrorFancy e -> Bool # (>=) :: ErrorFancy e -> ErrorFancy e -> Bool # max :: ErrorFancy e -> ErrorFancy e -> ErrorFancy e # min :: ErrorFancy e -> ErrorFancy e -> ErrorFancy e #
Ord t => Ord (ErrorItem t)
Instance details Defined in Text.Megaparsec.Error Methods compare :: ErrorItem t -> ErrorItem t -> Ordering # (<) :: ErrorItem t -> ErrorItem t -> Bool # (<=) :: ErrorItem t -> ErrorItem t -> Bool # (>) :: ErrorItem t -> ErrorItem t -> Bool # (>=) :: ErrorItem t -> ErrorItem t -> Bool # max :: ErrorItem t -> ErrorItem t -> ErrorItem t # min :: ErrorItem t -> ErrorItem t -> ErrorItem t #
Ord (Mod m)
Instance details Defined in Data.Mod Methods compare :: Mod m -> Mod m -> Ordering # (<) :: Mod m -> Mod m -> Bool # (<=) :: Mod m -> Mod m -> Bool # (>) :: Mod m -> Mod m -> Bool # (>=) :: Mod m -> Mod m -> Bool # max :: Mod m -> Mod m -> Mod m # min :: Mod m -> Mod m -> Mod m #
Ord a => Ord (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods compare :: StringEncode a -> StringEncode a -> Ordering # (<) :: StringEncode a -> StringEncode a -> Bool # (<=) :: StringEncode a -> StringEncode a -> Bool # (>) :: StringEncode a -> StringEncode a -> Bool # (>=) :: StringEncode a -> StringEncode a -> Bool # max :: StringEncode a -> StringEncode a -> StringEncode a # min :: StringEncode a -> StringEncode a -> StringEncode a #
Ord (KindedAddress kind)
Instance details Defined in Morley.Tezos.Address Methods compare :: KindedAddress kind -> KindedAddress kind -> Ordering # (<) :: KindedAddress kind -> KindedAddress kind -> Bool # (<=) :: KindedAddress kind -> KindedAddress kind -> Bool # (>) :: KindedAddress kind -> KindedAddress kind -> Bool # (>=) :: KindedAddress kind -> KindedAddress kind -> Bool # max :: KindedAddress kind -> KindedAddress kind -> KindedAddress kind # min :: KindedAddress kind -> KindedAddress kind -> KindedAddress kind #
Ord (AddressOrAlias kind)
Instance details Defined in Morley.Tezos.Address.Alias Methods compare :: AddressOrAlias kind -> AddressOrAlias kind -> Ordering # (<) :: AddressOrAlias kind -> AddressOrAlias kind -> Bool # (<=) :: AddressOrAlias kind -> AddressOrAlias kind -> Bool # (>) :: AddressOrAlias kind -> AddressOrAlias kind -> Bool # (>=) :: AddressOrAlias kind -> AddressOrAlias kind -> Bool # max :: AddressOrAlias kind -> AddressOrAlias kind -> AddressOrAlias kind # min :: AddressOrAlias kind -> AddressOrAlias kind -> AddressOrAlias kind #
Ord (Alias kind)
Instance details Defined in Morley.Tezos.Address.Alias Methods compare :: Alias kind -> Alias kind -> Ordering # (<) :: Alias kind -> Alias kind -> Bool # (<=) :: Alias kind -> Alias kind -> Bool # (>) :: Alias kind -> Alias kind -> Bool # (>=) :: Alias kind -> Alias kind -> Bool # max :: Alias kind -> Alias kind -> Alias kind # min :: Alias kind -> Alias kind -> Alias kind #
Ord (Hash kind)
Instance details Defined in Morley.Tezos.Crypto Methods compare :: Hash kind -> Hash kind -> Ordering # (<) :: Hash kind -> Hash kind -> Bool # (<=) :: Hash kind -> Hash kind -> Bool # (>) :: Hash kind -> Hash kind -> Bool # (>=) :: Hash kind -> Hash kind -> Bool # max :: Hash kind -> Hash kind -> Hash kind # min :: Hash kind -> Hash kind -> Hash kind #
Ord (HashTag kind)
Instance details Defined in Morley.Tezos.Crypto Methods compare :: HashTag kind -> HashTag kind -> Ordering # (<) :: HashTag kind -> HashTag kind -> Bool # (<=) :: HashTag kind -> HashTag kind -> Bool # (>) :: HashTag kind -> HashTag kind -> Bool # (>=) :: HashTag kind -> HashTag kind -> Bool # max :: HashTag kind -> HashTag kind -> HashTag kind # min :: HashTag kind -> HashTag kind -> HashTag kind #
Ord a => Ord (All a)
Instance details Defined in Morley.Prelude.Boolean Methods compare :: All a -> All a -> Ordering # (<) :: All a -> All a -> Bool # (<=) :: All a -> All a -> Bool # (>) :: All a -> All a -> Bool # (>=) :: All a -> All a -> Bool # max :: All a -> All a -> All a # min :: All a -> All a -> All a #
Ord a => Ord (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods compare :: Any a -> Any a -> Ordering # (<) :: Any a -> Any a -> Bool # (<=) :: Any a -> Any a -> Bool # (>) :: Any a -> Any a -> Bool # (>=) :: Any a -> Any a -> Bool # max :: Any a -> Any a -> Any a # min :: Any a -> Any a -> Any a #
Ord a => Ord (Array a)	Lexicographic ordering. Subject to change between major versions.
Instance details Defined in Data.Primitive.Array Methods compare :: Array a -> Array a -> Ordering # (<) :: Array a -> Array a -> Bool # (<=) :: Array a -> Array a -> Bool # (>) :: Array a -> Array a -> Bool # (>=) :: Array a -> Array a -> Bool # max :: Array a -> Array a -> Array a # min :: Array a -> Array a -> Array a #
(Ord a, Prim a) => Ord (PrimArray a)	Lexicographic ordering. Subject to change between major versions. Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods compare :: PrimArray a -> PrimArray a -> Ordering # (<) :: PrimArray a -> PrimArray a -> Bool # (<=) :: PrimArray a -> PrimArray a -> Bool # (>) :: PrimArray a -> PrimArray a -> Bool # (>=) :: PrimArray a -> PrimArray a -> Bool # max :: PrimArray a -> PrimArray a -> PrimArray a # min :: PrimArray a -> PrimArray a -> PrimArray a #
Ord a => Ord (SmallArray a)	Lexicographic ordering. Subject to change between major versions.
Instance details Defined in Data.Primitive.SmallArray Methods compare :: SmallArray a -> SmallArray a -> Ordering # (<) :: SmallArray a -> SmallArray a -> Bool # (<=) :: SmallArray a -> SmallArray a -> Bool # (>) :: SmallArray a -> SmallArray a -> Bool # (>=) :: SmallArray a -> SmallArray a -> Bool # max :: SmallArray a -> SmallArray a -> SmallArray a # min :: SmallArray a -> SmallArray a -> SmallArray a #
Ord g => Ord (StateGen g)
Instance details Defined in System.Random.Internal Methods compare :: StateGen g -> StateGen g -> Ordering # (<) :: StateGen g -> StateGen g -> Bool # (<=) :: StateGen g -> StateGen g -> Bool # (>) :: StateGen g -> StateGen g -> Bool # (>=) :: StateGen g -> StateGen g -> Bool # max :: StateGen g -> StateGen g -> StateGen g # min :: StateGen g -> StateGen g -> StateGen g #
Ord g => Ord (AtomicGen g)
Instance details Defined in System.Random.Stateful Methods compare :: AtomicGen g -> AtomicGen g -> Ordering # (<) :: AtomicGen g -> AtomicGen g -> Bool # (<=) :: AtomicGen g -> AtomicGen g -> Bool # (>) :: AtomicGen g -> AtomicGen g -> Bool # (>=) :: AtomicGen g -> AtomicGen g -> Bool # max :: AtomicGen g -> AtomicGen g -> AtomicGen g # min :: AtomicGen g -> AtomicGen g -> AtomicGen g #
Ord g => Ord (IOGen g)
Instance details Defined in System.Random.Stateful Methods compare :: IOGen g -> IOGen g -> Ordering # (<) :: IOGen g -> IOGen g -> Bool # (<=) :: IOGen g -> IOGen g -> Bool # (>) :: IOGen g -> IOGen g -> Bool # (>=) :: IOGen g -> IOGen g -> Bool # max :: IOGen g -> IOGen g -> IOGen g # min :: IOGen g -> IOGen g -> IOGen g #
Ord g => Ord (STGen g)
Instance details Defined in System.Random.Stateful Methods compare :: STGen g -> STGen g -> Ordering # (<) :: STGen g -> STGen g -> Bool # (<=) :: STGen g -> STGen g -> Bool # (>) :: STGen g -> STGen g -> Bool # (>=) :: STGen g -> STGen g -> Bool # max :: STGen g -> STGen g -> STGen g # min :: STGen g -> STGen g -> STGen g #
Ord g => Ord (TGen g)
Instance details Defined in System.Random.Stateful Methods compare :: TGen g -> TGen g -> Ordering # (<) :: TGen g -> TGen g -> Bool # (<=) :: TGen g -> TGen g -> Bool # (>) :: TGen g -> TGen g -> Bool # (>=) :: TGen g -> TGen g -> Bool # max :: TGen g -> TGen g -> TGen g # min :: TGen g -> TGen g -> TGen g #
Ord a => Ord (Add a)
Instance details Defined in Data.Semiring Methods compare :: Add a -> Add a -> Ordering # (<) :: Add a -> Add a -> Bool # (<=) :: Add a -> Add a -> Bool # (>) :: Add a -> Add a -> Bool # (>=) :: Add a -> Add a -> Bool # max :: Add a -> Add a -> Add a # min :: Add a -> Add a -> Add a #
Ord (IntSetOf a)
Instance details Defined in Data.Semiring Methods compare :: IntSetOf a -> IntSetOf a -> Ordering # (<) :: IntSetOf a -> IntSetOf a -> Bool # (<=) :: IntSetOf a -> IntSetOf a -> Bool # (>) :: IntSetOf a -> IntSetOf a -> Bool # (>=) :: IntSetOf a -> IntSetOf a -> Bool # max :: IntSetOf a -> IntSetOf a -> IntSetOf a # min :: IntSetOf a -> IntSetOf a -> IntSetOf a #
Ord a => Ord (Mul a)
Instance details Defined in Data.Semiring Methods compare :: Mul a -> Mul a -> Ordering # (<) :: Mul a -> Mul a -> Bool # (<=) :: Mul a -> Mul a -> Bool # (>) :: Mul a -> Mul a -> Bool # (>=) :: Mul a -> Mul a -> Bool # max :: Mul a -> Mul a -> Mul a # min :: Mul a -> Mul a -> Mul a #
Ord a => Ord (WrappedNum a)
Instance details Defined in Data.Semiring Methods compare :: WrappedNum a -> WrappedNum a -> Ordering # (<) :: WrappedNum a -> WrappedNum a -> Bool # (<=) :: WrappedNum a -> WrappedNum a -> Bool # (>) :: WrappedNum a -> WrappedNum a -> Bool # (>=) :: WrappedNum a -> WrappedNum a -> Bool # max :: WrappedNum a -> WrappedNum a -> WrappedNum a # min :: WrappedNum a -> WrappedNum a -> WrappedNum a #
Ord a => Ord (Maybe a)
Instance details Defined in Data.Strict.Maybe Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
Ord flag => Ord (TyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Syntax Methods compare :: TyVarBndr flag -> TyVarBndr flag -> Ordering # (<) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (<=) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (>) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (>=) :: TyVarBndr flag -> TyVarBndr flag -> Bool # max :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag # min :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag #
Ord a => Ord (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods compare :: HashSet a -> HashSet a -> Ordering # (<) :: HashSet a -> HashSet a -> Bool # (<=) :: HashSet a -> HashSet a -> Bool # (>) :: HashSet a -> HashSet a -> Bool # (>=) :: HashSet a -> HashSet a -> Bool # max :: HashSet a -> HashSet a -> HashSet a # min :: HashSet a -> HashSet a -> HashSet a #
Ord a => Ord (Vector a)
Instance details Defined in Data.Vector Methods compare :: Vector a -> Vector a -> Ordering # (<) :: Vector a -> Vector a -> Bool # (<=) :: Vector a -> Vector a -> Bool # (>) :: Vector a -> Vector a -> Bool # (>=) :: Vector a -> Vector a -> Bool # max :: Vector a -> Vector a -> Vector a # min :: Vector a -> Vector a -> Vector a #
(Prim a, Ord a) => Ord (Vector a)
Instance details Defined in Data.Vector.Primitive Methods compare :: Vector a -> Vector a -> Ordering # (<) :: Vector a -> Vector a -> Bool # (<=) :: Vector a -> Vector a -> Bool # (>) :: Vector a -> Vector a -> Bool # (>=) :: Vector a -> Vector a -> Bool # max :: Vector a -> Vector a -> Vector a # min :: Vector a -> Vector a -> Vector a #
(Storable a, Ord a) => Ord (Vector a)
Instance details Defined in Data.Vector.Storable Methods compare :: Vector a -> Vector a -> Ordering # (<) :: Vector a -> Vector a -> Bool # (<=) :: Vector a -> Vector a -> Bool # (>) :: Vector a -> Vector a -> Bool # (>=) :: Vector a -> Vector a -> Bool # max :: Vector a -> Vector a -> Vector a # min :: Vector a -> Vector a -> Vector a #
Ord t => Ord (ElField '(s, t))
Instance details Defined in Data.Vinyl.Functor Methods compare :: ElField '(s, t) -> ElField '(s, t) -> Ordering # (<) :: ElField '(s, t) -> ElField '(s, t) -> Bool # (<=) :: ElField '(s, t) -> ElField '(s, t) -> Bool # (>) :: ElField '(s, t) -> ElField '(s, t) -> Bool # (>=) :: ElField '(s, t) -> ElField '(s, t) -> Bool # max :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # min :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) #
Ord a => Ord (Identity a)
Instance details Defined in Data.Vinyl.Functor Methods compare :: Identity a -> Identity a -> Ordering # (<) :: Identity a -> Identity a -> Bool # (<=) :: Identity a -> Identity a -> Bool # (>) :: Identity a -> Identity a -> Bool # (>=) :: Identity a -> Identity a -> Bool # max :: Identity a -> Identity a -> Identity a # min :: Identity a -> Identity a -> Identity a #
Ord a => Ord (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
Ord a => Ord [a]
Instance details Defined in GHC.Classes Methods compare :: [a] -> [a] -> Ordering # (<) :: [a] -> [a] -> Bool # (<=) :: [a] -> [a] -> Bool # (>) :: [a] -> [a] -> Bool # (>=) :: [a] -> [a] -> Bool # max :: [a] -> [a] -> [a] # min :: [a] -> [a] -> [a] #
(Integral a) :=> (Ord (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Ord (Ratio a) #
(Ord a) :=> (Ord (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Ord a :- Ord (Const a b) #
(Ord a) :=> (Ord (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Ord a :- Ord (Identity a) #
(Ord a) :=> (Ord (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Ord a :- Ord (Maybe a) #
(Ord a) :=> (Ord [a])
Instance details Defined in Data.Constraint Methods ins :: Ord a :- Ord [a] #
Class (Eq a) (Ord a)
Instance details Defined in Data.Constraint Methods cls :: Ord a :- Eq a #
Ord a => Ord (OddWord a n)
Instance details Defined in Data.Word.Odd Methods compare :: OddWord a n -> OddWord a n -> Ordering # (<) :: OddWord a n -> OddWord a n -> Bool # (<=) :: OddWord a n -> OddWord a n -> Bool # (>) :: OddWord a n -> OddWord a n -> Bool # (>=) :: OddWord a n -> OddWord a n -> Bool # max :: OddWord a n -> OddWord a n -> OddWord a n # min :: OddWord a n -> OddWord a n -> OddWord a n #
(Ord a, Ord b) => Ord (Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods compare :: Either a b -> Either a b -> Ordering # (<) :: Either a b -> Either a b -> Bool # (<=) :: Either a b -> Either a b -> Bool # (>) :: Either a b -> Either a b -> Bool # (>=) :: Either a b -> Either a b -> Bool # max :: Either a b -> Either a b -> Either a b # min :: Either a b -> Either a b -> Either a b #
Ord (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods compare :: Fixed a -> Fixed a -> Ordering # (<) :: Fixed a -> Fixed a -> Bool # (<=) :: Fixed a -> Fixed a -> Bool # (>) :: Fixed a -> Fixed a -> Bool # (>=) :: Fixed a -> Fixed a -> Bool # max :: Fixed a -> Fixed a -> Fixed a # min :: Fixed a -> Fixed a -> Fixed a #
Ord (Proxy s)	Since: base-4.7.0.0
Instance details 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 #
Ord a => Ord (Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Arg a b -> Arg a b -> Ordering # (<) :: Arg a b -> Arg a b -> Bool # (<=) :: Arg a b -> Arg a b -> Bool # (>) :: Arg a b -> Arg a b -> Bool # (>=) :: Arg a b -> Arg a b -> Bool # max :: Arg a b -> Arg a b -> Arg a b # min :: Arg a b -> Arg a b -> Arg a b #
Ord (TypeRep a)	Since: base-4.4.0.0
Instance details Defined in Data.Typeable.Internal Methods compare :: TypeRep a -> TypeRep a -> Ordering # (<) :: TypeRep a -> TypeRep a -> Bool # (<=) :: TypeRep a -> TypeRep a -> Bool # (>) :: TypeRep a -> TypeRep a -> Bool # (>=) :: TypeRep a -> TypeRep a -> Bool # max :: TypeRep a -> TypeRep a -> TypeRep a # min :: TypeRep a -> TypeRep a -> TypeRep a #
Ord (U1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: U1 p -> U1 p -> Ordering # (<) :: U1 p -> U1 p -> Bool # (<=) :: U1 p -> U1 p -> Bool # (>) :: U1 p -> U1 p -> Bool # (>=) :: U1 p -> U1 p -> Bool # max :: U1 p -> U1 p -> U1 p # min :: U1 p -> U1 p -> U1 p #
Ord (V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: V1 p -> V1 p -> Ordering # (<) :: V1 p -> V1 p -> Bool # (<=) :: V1 p -> V1 p -> Bool # (>) :: V1 p -> V1 p -> Bool # (>=) :: V1 p -> V1 p -> Bool # max :: V1 p -> V1 p -> V1 p # min :: V1 p -> V1 p -> V1 p #
Ord a => Ord (ListN n a)
Instance details Defined in Basement.Sized.List Methods compare :: ListN n a -> ListN n a -> Ordering # (<) :: ListN n a -> ListN n a -> Bool # (<=) :: ListN n a -> ListN n a -> Bool # (>) :: ListN n a -> ListN n a -> Bool # (>=) :: ListN n a -> ListN n a -> Bool # max :: ListN n a -> ListN n a -> ListN n a # min :: ListN n a -> ListN n a -> ListN n a #
(Ord a, Ord b) => Ord (Bimap a b)
Instance details Defined in Data.Bimap Methods compare :: Bimap a b -> Bimap a b -> Ordering # (<) :: Bimap a b -> Bimap a b -> Bool # (<=) :: Bimap a b -> Bimap a b -> Bool # (>) :: Bimap a b -> Bimap a b -> Bool # (>=) :: Bimap a b -> Bimap a b -> Bool # max :: Bimap a b -> Bimap a b -> Bimap a b # min :: Bimap a b -> Bimap a b -> Bimap a b #
Ord (a :- b)	Assumes `IncoherentInstances` doesn't exist.
Instance details 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 #
(Ord k, Ord v) => Ord (Map k v)
Instance details Defined in Data.Map.Internal Methods compare :: Map k v -> Map k v -> Ordering # (<) :: Map k v -> Map k v -> Bool # (<=) :: Map k v -> Map k v -> Bool # (>) :: Map k v -> Map k v -> Bool # (>=) :: Map k v -> Map k v -> Bool # max :: Map k v -> Map k v -> Map k v # min :: Map k v -> Map k v -> Map k v #
(Ord1 f, Ord a) => Ord (Cofree f a)
Instance details Defined in Control.Comonad.Cofree Methods compare :: Cofree f a -> Cofree f a -> Ordering # (<) :: Cofree f a -> Cofree f a -> Bool # (<=) :: Cofree f a -> Cofree f a -> Bool # (>) :: Cofree f a -> Cofree f a -> Bool # (>=) :: Cofree f a -> Cofree f a -> Bool # max :: Cofree f a -> Cofree f a -> Cofree f a # min :: Cofree f a -> Cofree f a -> Cofree f a #
(Ord1 f, Ord a) => Ord (Free f a)
Instance details Defined in Control.Monad.Free Methods compare :: Free f a -> Free f a -> Ordering # (<) :: Free f a -> Free f a -> Bool # (<=) :: Free f a -> Free f a -> Bool # (>) :: Free f a -> Free f a -> Bool # (>=) :: Free f a -> Free f a -> Bool # max :: Free f a -> Free f a -> Free f a # min :: Free f a -> Free f a -> Free f a #
Ord k => Ord (Extension p k)
Instance details Defined in Data.Field.Galois.Extension Methods compare :: Extension p k -> Extension p k -> Ordering # (<) :: Extension p k -> Extension p k -> Bool # (<=) :: Extension p k -> Extension p k -> Bool # (>) :: Extension p k -> Extension p k -> Bool # (>=) :: Extension p k -> Extension p k -> Bool # max :: Extension p k -> Extension p k -> Extension p k # min :: Extension p k -> Extension p k -> Extension p k #
Ord k => Ord (RootsOfUnity n k)
Instance details Defined in Data.Field.Galois.Unity Methods compare :: RootsOfUnity n k -> RootsOfUnity n k -> Ordering # (<) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # (<=) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # (>) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # (>=) :: RootsOfUnity n k -> RootsOfUnity n k -> Bool # max :: RootsOfUnity n k -> RootsOfUnity n k -> RootsOfUnity n k # min :: RootsOfUnity n k -> RootsOfUnity n k -> RootsOfUnity n k #
(Ord1 f, Ord a) => Ord (Yoneda f a)
Instance details Defined in Data.Functor.Yoneda Methods compare :: Yoneda f a -> Yoneda f a -> Ordering # (<) :: Yoneda f a -> Yoneda f a -> Bool # (<=) :: Yoneda f a -> Yoneda f a -> Bool # (>) :: Yoneda f a -> Yoneda f a -> Bool # (>=) :: Yoneda f a -> Yoneda f a -> Bool # max :: Yoneda f a -> Yoneda f a -> Yoneda f a # min :: Yoneda f a -> Yoneda f a -> Yoneda f a #
Ord (TAddress p vd)
Instance details Defined in Lorentz.Address Methods compare :: TAddress p vd -> TAddress p vd -> Ordering # (<) :: TAddress p vd -> TAddress p vd -> Bool # (<=) :: TAddress p vd -> TAddress p vd -> Bool # (>) :: TAddress p vd -> TAddress p vd -> Bool # (>=) :: TAddress p vd -> TAddress p vd -> Bool # max :: TAddress p vd -> TAddress p vd -> TAddress p vd # min :: TAddress p vd -> TAddress p vd -> TAddress p vd #
Ord (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods compare :: Hash alg a -> Hash alg a -> Ordering # (<) :: Hash alg a -> Hash alg a -> Bool # (<=) :: Hash alg a -> Hash alg a -> Bool # (>) :: Hash alg a -> Hash alg a -> Bool # (>=) :: Hash alg a -> Hash alg a -> Bool # max :: Hash alg a -> Hash alg a -> Hash alg a # min :: Hash alg a -> Hash alg a -> Hash alg a #
(Ord n, Ord m) => Ord (ArithError n m)
Instance details Defined in Morley.Michelson.Typed.Arith Methods compare :: ArithError n m -> ArithError n m -> Ordering # (<) :: ArithError n m -> ArithError n m -> Bool # (<=) :: ArithError n m -> ArithError n m -> Bool # (>) :: ArithError n m -> ArithError n m -> Bool # (>=) :: ArithError n m -> ArithError n m -> Bool # max :: ArithError n m -> ArithError n m -> ArithError n m # min :: ArithError n m -> ArithError n m -> ArithError n m #
Comparable t => Ord (Value' instr t)
Instance details Defined in Morley.Michelson.Typed.Value Methods compare :: Value' instr t -> Value' instr t -> Ordering # (<) :: Value' instr t -> Value' instr t -> Bool # (<=) :: Value' instr t -> Value' instr t -> Bool # (>) :: Value' instr t -> Value' instr t -> Bool # (>=) :: Value' instr t -> Value' instr t -> Bool # max :: Value' instr t -> Value' instr t -> Value' instr t # min :: Value' instr t -> Value' instr t -> Value' instr t #
(Ord a, Ord b) => Ord (Bimap a b)
Instance details Defined in Morley.Util.Bimap Methods compare :: Bimap a b -> Bimap a b -> Ordering # (<) :: Bimap a b -> Bimap a b -> Bool # (<=) :: Bimap a b -> Bimap a b -> Bool # (>) :: Bimap a b -> Bimap a b -> Bool # (>=) :: Bimap a b -> Bimap a b -> Bool # max :: Bimap a b -> Bimap a b -> Bimap a b # min :: Bimap a b -> Bimap a b -> Bimap a b #
Ord a => Ord (SizedList' n a)
Instance details Defined in Morley.Util.SizedList Methods compare :: SizedList' n a -> SizedList' n a -> Ordering # (<) :: SizedList' n a -> SizedList' n a -> Bool # (<=) :: SizedList' n a -> SizedList' n a -> Bool # (>) :: SizedList' n a -> SizedList' n a -> Bool # (>=) :: SizedList' n a -> SizedList' n a -> Bool # max :: SizedList' n a -> SizedList' n a -> SizedList' n a # min :: SizedList' n a -> SizedList' n a -> SizedList' n a #
Ord (v a) => Ord (Poly v a)
Instance details Defined in Data.Poly.Internal.Dense Methods compare :: Poly v a -> Poly v a -> Ordering # (<) :: Poly v a -> Poly v a -> Bool # (<=) :: Poly v a -> Poly v a -> Bool # (>) :: Poly v a -> Poly v a -> Bool # (>=) :: Poly v a -> Poly v a -> Bool # max :: Poly v a -> Poly v a -> Poly v a # min :: Poly v a -> Poly v a -> Poly v a #
Ord v => Ord (IntMapOf k v)
Instance details Defined in Data.Semiring Methods compare :: IntMapOf k v -> IntMapOf k v -> Ordering # (<) :: IntMapOf k v -> IntMapOf k v -> Bool # (<=) :: IntMapOf k v -> IntMapOf k v -> Bool # (>) :: IntMapOf k v -> IntMapOf k v -> Bool # (>=) :: IntMapOf k v -> IntMapOf k v -> Bool # max :: IntMapOf k v -> IntMapOf k v -> IntMapOf k v # min :: IntMapOf k v -> IntMapOf k v -> IntMapOf k v #
(Ord a, Ord b) => Ord (Either a b)
Instance details Defined in Data.Strict.Either Methods compare :: Either a b -> Either a b -> Ordering # (<) :: Either a b -> Either a b -> Bool # (<=) :: Either a b -> Either a b -> Bool # (>) :: Either a b -> Either a b -> Bool # (>=) :: Either a b -> Either a b -> Bool # max :: Either a b -> Either a b -> Either a b # min :: Either a b -> Either a b -> Either a b #
(Ord a, Ord b) => Ord (These a b)
Instance details Defined in Data.Strict.These Methods compare :: These a b -> These a b -> Ordering # (<) :: These a b -> These a b -> Bool # (<=) :: These a b -> These a b -> Bool # (>) :: These a b -> These a b -> Bool # (>=) :: These a b -> These a b -> Bool # max :: These a b -> These a b -> These a b # min :: These a b -> These a b -> These a b #
(Ord a, Ord b) => Ord (Pair a b)
Instance details Defined in Data.Strict.Tuple Methods compare :: Pair a b -> Pair a b -> Ordering # (<) :: Pair a b -> Pair a b -> Bool # (<=) :: Pair a b -> Pair a b -> Bool # (>) :: Pair a b -> Pair a b -> Bool # (>=) :: Pair a b -> Pair a b -> Bool # max :: Pair a b -> Pair a b -> Pair a b # min :: Pair a b -> Pair a b -> Pair a b #
(Ord a, Ord b) => Ord (These a b)
Instance details Defined in Data.These Methods compare :: These a b -> These a b -> Ordering # (<) :: These a b -> These a b -> Bool # (<=) :: These a b -> These a b -> Bool # (>) :: These a b -> These a b -> Bool # (>=) :: These a b -> These a b -> Bool # max :: These a b -> These a b -> These a b # min :: These a b -> These a b -> These a b #
(Ord1 m, Ord a) => Ord (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods compare :: MaybeT m a -> MaybeT m a -> Ordering # (<) :: MaybeT m a -> MaybeT m a -> Bool # (<=) :: MaybeT m a -> MaybeT m a -> Bool # (>) :: MaybeT m a -> MaybeT m a -> Bool # (>=) :: MaybeT m a -> MaybeT m a -> Bool # max :: MaybeT m a -> MaybeT m a -> MaybeT m a # min :: MaybeT m a -> MaybeT m a -> MaybeT m a #
(Ord k, Ord v) => Ord (HashMap k v)	The ordering is total and consistent with the `Eq` instance. However, nothing else about the ordering is specified, and it may change from version to version of either this package or of hashable.
Instance details Defined in Data.HashMap.Internal Methods compare :: HashMap k v -> HashMap k v -> Ordering # (<) :: HashMap k v -> HashMap k v -> Bool # (<=) :: HashMap k v -> HashMap k v -> Bool # (>) :: HashMap k v -> HashMap k v -> Bool # (>=) :: HashMap k v -> HashMap k v -> Bool # max :: HashMap k v -> HashMap k v -> HashMap k v # min :: HashMap k v -> HashMap k v -> HashMap k v #
(Ord a, Ord b) => Ord (a, b)
Instance details Defined in GHC.Classes 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) #
(Ord a, Ord b) :=> (Ord (Either a b))
Instance details Defined in Data.Constraint Methods ins :: (Ord a, Ord b) :- Ord (Either a b) #
(Ord a, Ord b) :=> (Ord (a, b))
Instance details Defined in Data.Constraint Methods ins :: (Ord a, Ord b) :- Ord (a, b) #
Class (Num a, Ord a) (Real a)
Instance details Defined in Data.Constraint Methods cls :: Real a :- (Num a, Ord a) #
Ord a => Ord (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods compare :: Const a b -> Const a b -> Ordering # (<) :: Const a b -> Const a b -> Bool # (<=) :: Const a b -> Const a b -> Bool # (>) :: Const a b -> Const a b -> Bool # (>=) :: Const a b -> Const a b -> Bool # max :: Const a b -> Const a b -> Const a b # min :: Const a b -> Const a b -> Const a b #
Ord (f a) => Ord (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods compare :: Ap f a -> Ap f a -> Ordering # (<) :: Ap f a -> Ap f a -> Bool # (<=) :: Ap f a -> Ap f a -> Bool # (>) :: Ap f a -> Ap f a -> Bool # (>=) :: Ap f a -> Ap f a -> Bool # max :: Ap f a -> Ap f a -> Ap f a # min :: Ap f a -> Ap f a -> Ap f a #
Ord (f a) => Ord (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods compare :: Alt f a -> Alt f a -> Ordering # (<) :: Alt f a -> Alt f a -> Bool # (<=) :: Alt f a -> Alt f a -> Bool # (>) :: Alt f a -> Alt f a -> Bool # (>=) :: Alt f a -> Alt f a -> Bool # max :: Alt f a -> Alt f a -> Alt f a # min :: Alt f a -> Alt f a -> Alt f a #
Ord (Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods compare :: Coercion a b -> Coercion a b -> Ordering # (<) :: Coercion a b -> Coercion a b -> Bool # (<=) :: Coercion a b -> Coercion a b -> Bool # (>) :: Coercion a b -> Coercion a b -> Bool # (>=) :: Coercion a b -> Coercion a b -> Bool # max :: Coercion a b -> Coercion a b -> Coercion a b # min :: Coercion a b -> Coercion a b -> Coercion a b #
Ord (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality 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 #
Ord (f p) => Ord (Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: Rec1 f p -> Rec1 f p -> Ordering # (<) :: Rec1 f p -> Rec1 f p -> Bool # (<=) :: Rec1 f p -> Rec1 f p -> Bool # (>) :: Rec1 f p -> Rec1 f p -> Bool # (>=) :: Rec1 f p -> Rec1 f p -> Bool # max :: Rec1 f p -> Rec1 f p -> Rec1 f p # min :: Rec1 f p -> Rec1 f p -> Rec1 f p #
Ord (URec (Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p #
Ord (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Char p -> URec Char p -> Ordering # (<) :: URec Char p -> URec Char p -> Bool # (<=) :: URec Char p -> URec Char p -> Bool # (>) :: URec Char p -> URec Char p -> Bool # (>=) :: URec Char p -> URec Char p -> Bool # max :: URec Char p -> URec Char p -> URec Char p # min :: URec Char p -> URec Char p -> URec Char p #
Ord (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # max :: URec Double p -> URec Double p -> URec Double p # min :: URec Double p -> URec Double p -> URec Double p #
Ord (URec Float p)
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering # (<) :: URec Float p -> URec Float p -> Bool # (<=) :: URec Float p -> URec Float p -> Bool # (>) :: URec Float p -> URec Float p -> Bool # (>=) :: URec Float p -> URec Float p -> Bool # max :: URec Float p -> URec Float p -> URec Float p # min :: URec Float p -> URec Float p -> URec Float p #
Ord (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Int p -> URec Int p -> Ordering # (<) :: URec Int p -> URec Int p -> Bool # (<=) :: URec Int p -> URec Int p -> Bool # (>) :: URec Int p -> URec Int p -> Bool # (>=) :: URec Int p -> URec Int p -> Bool # max :: URec Int p -> URec Int p -> URec Int p # min :: URec Int p -> URec Int p -> URec Int p #
Ord (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Word p -> URec Word p -> Ordering # (<) :: URec Word p -> URec Word p -> Bool # (<=) :: URec Word p -> URec Word p -> Bool # (>) :: URec Word p -> URec Word p -> Bool # (>=) :: URec Word p -> URec Word p -> Bool # max :: URec Word p -> URec Word p -> URec Word p # min :: URec Word p -> URec Word p -> URec Word p #
Ord (p (Fix p a) a) => Ord (Fix p a)
Instance details Defined in Data.Bifunctor.Fix Methods compare :: Fix p a -> Fix p a -> Ordering # (<) :: Fix p a -> Fix p a -> Bool # (<=) :: Fix p a -> Fix p a -> Bool # (>) :: Fix p a -> Fix p a -> Bool # (>=) :: Fix p a -> Fix p a -> Bool # max :: Fix p a -> Fix p a -> Fix p a # min :: Fix p a -> Fix p a -> Fix p a #
Ord (p a a) => Ord (Join p a)
Instance details Defined in Data.Bifunctor.Join Methods compare :: Join p a -> Join p a -> Ordering # (<) :: Join p a -> Join p a -> Bool # (<=) :: Join p a -> Join p a -> Bool # (>) :: Join p a -> Join p a -> Bool # (>=) :: Join p a -> Join p a -> Bool # max :: Join p a -> Join p a -> Join p a # min :: Join p a -> Join p a -> Join p a #
(Ord a, Ord (f b)) => Ord (CofreeF f a b)
Instance details Defined in Control.Comonad.Trans.Cofree Methods compare :: CofreeF f a b -> CofreeF f a b -> Ordering # (<) :: CofreeF f a b -> CofreeF f a b -> Bool # (<=) :: CofreeF f a b -> CofreeF f a b -> Bool # (>) :: CofreeF f a b -> CofreeF f a b -> Bool # (>=) :: CofreeF f a b -> CofreeF f a b -> Bool # max :: CofreeF f a b -> CofreeF f a b -> CofreeF f a b # min :: CofreeF f a b -> CofreeF f a b -> CofreeF f a b #
Ord (w (CofreeF f a (CofreeT f w a))) => Ord (CofreeT f w a)
Instance details Defined in Control.Comonad.Trans.Cofree Methods compare :: CofreeT f w a -> CofreeT f w a -> Ordering # (<) :: CofreeT f w a -> CofreeT f w a -> Bool # (<=) :: CofreeT f w a -> CofreeT f w a -> Bool # (>) :: CofreeT f w a -> CofreeT f w a -> Bool # (>=) :: CofreeT f w a -> CofreeT f w a -> Bool # max :: CofreeT f w a -> CofreeT f w a -> CofreeT f w a # min :: CofreeT f w a -> CofreeT f w a -> CofreeT f w a #
(Ord a, Ord (f b)) => Ord (FreeF f a b)
Instance details Defined in Control.Monad.Trans.Free Methods compare :: FreeF f a b -> FreeF f a b -> Ordering # (<) :: FreeF f a b -> FreeF f a b -> Bool # (<=) :: FreeF f a b -> FreeF f a b -> Bool # (>) :: FreeF f a b -> FreeF f a b -> Bool # (>=) :: FreeF f a b -> FreeF f a b -> Bool # max :: FreeF f a b -> FreeF f a b -> FreeF f a b # min :: FreeF f a b -> FreeF f a b -> FreeF f a b #
(Ord1 f, Ord1 m, Ord a) => Ord (FreeT f m a)
Instance details Defined in Control.Monad.Trans.Free Methods compare :: FreeT f m a -> FreeT f m a -> Ordering # (<) :: FreeT f m a -> FreeT f m a -> Bool # (<=) :: FreeT f m a -> FreeT f m a -> Bool # (>) :: FreeT f m a -> FreeT f m a -> Bool # (>=) :: FreeT f m a -> FreeT f m a -> Bool # max :: FreeT f m a -> FreeT f m a -> FreeT f m a # min :: FreeT f m a -> FreeT f m a -> FreeT f m a #
GCompare f => Ord (Constrained c f)
Instance details Defined in Morley.Util.Constrained Methods compare :: Constrained c f -> Constrained c f -> Ordering # (<) :: Constrained c f -> Constrained c f -> Bool # (<=) :: Constrained c f -> Constrained c f -> Bool # (>) :: Constrained c f -> Constrained c f -> Bool # (>=) :: Constrained c f -> Constrained c f -> Bool # max :: Constrained c f -> Constrained c f -> Constrained c f # min :: Constrained c f -> Constrained c f -> Constrained c f #
Ord b => Ord (Tagged s b)
Instance details Defined in Data.Tagged Methods compare :: Tagged s b -> Tagged s b -> Ordering # (<) :: Tagged s b -> Tagged s b -> Bool # (<=) :: Tagged s b -> Tagged s b -> Bool # (>) :: Tagged s b -> Tagged s b -> Bool # (>=) :: Tagged s b -> Tagged s b -> Bool # max :: Tagged s b -> Tagged s b -> Tagged s b # min :: Tagged s b -> Tagged s b -> Tagged s b #
(Ord1 f, Ord1 g, Ord a) => Ord (These1 f g a)
Instance details Defined in Data.Functor.These Methods compare :: These1 f g a -> These1 f g a -> Ordering # (<) :: These1 f g a -> These1 f g a -> Bool # (<=) :: These1 f g a -> These1 f g a -> Bool # (>) :: These1 f g a -> These1 f g a -> Bool # (>=) :: These1 f g a -> These1 f g a -> Bool # max :: These1 f g a -> These1 f g a -> These1 f g a # min :: These1 f g a -> These1 f g a -> These1 f g a #
(Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a)
Instance details Defined in Control.Monad.Trans.Error Methods compare :: ErrorT e m a -> ErrorT e m a -> Ordering # (<) :: ErrorT e m a -> ErrorT e m a -> Bool # (<=) :: ErrorT e m a -> ErrorT e m a -> Bool # (>) :: ErrorT e m a -> ErrorT e m a -> Bool # (>=) :: ErrorT e m a -> ErrorT e m a -> Bool # max :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a # min :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a #
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # max :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # min :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
(Ord1 f, Ord a) => Ord (IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods compare :: IdentityT f a -> IdentityT f a -> Ordering # (<) :: IdentityT f a -> IdentityT f a -> Bool # (<=) :: IdentityT f a -> IdentityT f a -> Bool # (>) :: IdentityT f a -> IdentityT f a -> Bool # (>=) :: IdentityT f a -> IdentityT f a -> Bool # max :: IdentityT f a -> IdentityT f a -> IdentityT f a # min :: IdentityT f a -> IdentityT f a -> IdentityT f a #
(RPureConstrained (IndexableField rs) rs, RecApplicative rs, Ord (Rec f rs)) => Ord (ARec f rs)
Instance details Defined in Data.Vinyl.ARec.Internal Methods compare :: ARec f rs -> ARec f rs -> Ordering # (<) :: ARec f rs -> ARec f rs -> Bool # (<=) :: ARec f rs -> ARec f rs -> Bool # (>) :: ARec f rs -> ARec f rs -> Bool # (>=) :: ARec f rs -> ARec f rs -> Bool # max :: ARec f rs -> ARec f rs -> ARec f rs # min :: ARec f rs -> ARec f rs -> ARec f rs #
(Ord (f r), Ord (Rec f rs)) => Ord (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Methods compare :: Rec f (r ': rs) -> Rec f (r ': rs) -> Ordering # (<) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (<=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (>) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (>=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # max :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) # min :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) #
Ord (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Methods compare :: Rec f '[] -> Rec f '[] -> Ordering # (<) :: Rec f '[] -> Rec f '[] -> Bool # (<=) :: Rec f '[] -> Rec f '[] -> Bool # (>) :: Rec f '[] -> Rec f '[] -> Bool # (>=) :: Rec f '[] -> Rec f '[] -> Bool # max :: Rec f '[] -> Rec f '[] -> Rec f '[] # min :: Rec f '[] -> Rec f '[] -> Rec f '[] #
(Ord a, Ord b, Ord c) => Ord (a, b, c)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c) -> (a, b, c) -> Ordering # (<) :: (a, b, c) -> (a, b, c) -> Bool # (<=) :: (a, b, c) -> (a, b, c) -> Bool # (>) :: (a, b, c) -> (a, b, c) -> Bool # (>=) :: (a, b, c) -> (a, b, c) -> Bool # max :: (a, b, c) -> (a, b, c) -> (a, b, c) # min :: (a, b, c) -> (a, b, c) -> (a, b, c) #
(Ord1 f, Ord1 g, Ord a) => Ord (Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering # (<) :: Product f g a -> Product f g a -> Bool # (<=) :: Product f g a -> Product f g a -> Bool # (>) :: Product f g a -> Product f g a -> Bool # (>=) :: Product f g a -> Product f g a -> Bool # max :: Product f g a -> Product f g a -> Product f g a # min :: Product f g a -> Product f g a -> Product f g a #
(Ord1 f, Ord1 g, Ord a) => Ord (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods compare :: Sum f g a -> Sum f g a -> Ordering # (<) :: Sum f g a -> Sum f g a -> Bool # (<=) :: Sum f g a -> Sum f g a -> Bool # (>) :: Sum f g a -> Sum f g a -> Bool # (>=) :: Sum f g a -> Sum f g a -> Bool # max :: Sum f g a -> Sum f g a -> Sum f g a # min :: Sum f g a -> Sum f g a -> Sum f g a #
Ord (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality 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 #
(Ord (f p), Ord (g p)) => Ord ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :: g) p -> (f :: g) p -> Ordering # (<) :: (f :: g) p -> (f :: g) p -> Bool # (<=) :: (f :: g) p -> (f :: g) p -> Bool # (>) :: (f :: g) p -> (f :: g) p -> Bool # (>=) :: (f :: g) p -> (f :: g) p -> Bool # max :: (f :: g) p -> (f :: g) p -> (f :: g) p # min :: (f :: g) p -> (f :: g) p -> (f :: g) p #
(Ord (f p), Ord (g p)) => Ord ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :+: g) p -> (f :+: g) p -> Ordering # (<) :: (f :+: g) p -> (f :+: g) p -> Bool # (<=) :: (f :+: g) p -> (f :+: g) p -> Bool # (>) :: (f :+: g) p -> (f :+: g) p -> Bool # (>=) :: (f :+: g) p -> (f :+: g) p -> Bool # max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p # min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p #
Ord c => Ord (K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: K1 i c p -> K1 i c p -> Ordering # (<) :: K1 i c p -> K1 i c p -> Bool # (<=) :: K1 i c p -> K1 i c p -> Bool # (>) :: K1 i c p -> K1 i c p -> Bool # (>=) :: K1 i c p -> K1 i c p -> Bool # max :: K1 i c p -> K1 i c p -> K1 i c p # min :: K1 i c p -> K1 i c p -> K1 i c p #
(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d) -> (a, b, c, d) -> Ordering # (<) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (<=) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (>) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (>=) :: (a, b, c, d) -> (a, b, c, d) -> Bool # max :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # min :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) #
(Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # max :: Compose f g a -> Compose f g a -> Compose f g a # min :: Compose f g a -> Compose f g a -> Compose f g a #
Ord (f (g p)) => Ord ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :.: g) p -> (f :.: g) p -> Ordering # (<) :: (f :.: g) p -> (f :.: g) p -> Bool # (<=) :: (f :.: g) p -> (f :.: g) p -> Bool # (>) :: (f :.: g) p -> (f :.: g) p -> Bool # (>=) :: (f :.: g) p -> (f :.: g) p -> Bool # max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p #
Ord (f p) => Ord (M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: M1 i c f p -> M1 i c f p -> Ordering # (<) :: M1 i c f p -> M1 i c f p -> Bool # (<=) :: M1 i c f p -> M1 i c f p -> Bool # (>) :: M1 i c f p -> M1 i c f p -> Bool # (>=) :: M1 i c f p -> M1 i c f p -> Bool # max :: M1 i c f p -> M1 i c f p -> M1 i c f p # min :: M1 i c f p -> M1 i c f p -> M1 i c f p #
Ord (f a) => Ord (Clown f a b)
Instance details Defined in Data.Bifunctor.Clown Methods compare :: Clown f a b -> Clown f a b -> Ordering # (<) :: Clown f a b -> Clown f a b -> Bool # (<=) :: Clown f a b -> Clown f a b -> Bool # (>) :: Clown f a b -> Clown f a b -> Bool # (>=) :: Clown f a b -> Clown f a b -> Bool # max :: Clown f a b -> Clown f a b -> Clown f a b # min :: Clown f a b -> Clown f a b -> Clown f a b #
Ord (p b a) => Ord (Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Methods compare :: Flip p a b -> Flip p a b -> Ordering # (<) :: Flip p a b -> Flip p a b -> Bool # (<=) :: Flip p a b -> Flip p a b -> Bool # (>) :: Flip p a b -> Flip p a b -> Bool # (>=) :: Flip p a b -> Flip p a b -> Bool # max :: Flip p a b -> Flip p a b -> Flip p a b # min :: Flip p a b -> Flip p a b -> Flip p a b #
Ord (g b) => Ord (Joker g a b)
Instance details Defined in Data.Bifunctor.Joker Methods compare :: Joker g a b -> Joker g a b -> Ordering # (<) :: Joker g a b -> Joker g a b -> Bool # (<=) :: Joker g a b -> Joker g a b -> Bool # (>) :: Joker g a b -> Joker g a b -> Bool # (>=) :: Joker g a b -> Joker g a b -> Bool # max :: Joker g a b -> Joker g a b -> Joker g a b # min :: Joker g a b -> Joker g a b -> Joker g a b #
Ord (p a b) => Ord (WrappedBifunctor p a b)
Instance details Defined in Data.Bifunctor.Wrapped Methods compare :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Ordering # (<) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # (<=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # (>) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # (>=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool # max :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> WrappedBifunctor p a b # min :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> WrappedBifunctor p a b #
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering # (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) #
(Ord (f a b), Ord (g a b)) => Ord (Product f g a b)
Instance details Defined in Data.Bifunctor.Product Methods compare :: Product f g a b -> Product f g a b -> Ordering # (<) :: Product f g a b -> Product f g a b -> Bool # (<=) :: Product f g a b -> Product f g a b -> Bool # (>) :: Product f g a b -> Product f g a b -> Bool # (>=) :: Product f g a b -> Product f g a b -> Bool # max :: Product f g a b -> Product f g a b -> Product f g a b # min :: Product f g a b -> Product f g a b -> Product f g a b #
(Ord (p a b), Ord (q a b)) => Ord (Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Methods compare :: Sum p q a b -> Sum p q a b -> Ordering # (<) :: Sum p q a b -> Sum p q a b -> Bool # (<=) :: Sum p q a b -> Sum p q a b -> Bool # (>) :: Sum p q a b -> Sum p q a b -> Bool # (>=) :: Sum p q a b -> Sum p q a b -> Bool # max :: Sum p q a b -> Sum p q a b -> Sum p q a b # min :: Sum p q a b -> Sum p q a b -> Sum p q a b #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering # (<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) #
Ord (f (p a b)) => Ord (Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Methods compare :: Tannen f p a b -> Tannen f p a b -> Ordering # (<) :: Tannen f p a b -> Tannen f p a b -> Bool # (<=) :: Tannen f p a b -> Tannen f p a b -> Bool # (>) :: Tannen f p a b -> Tannen f p a b -> Bool # (>=) :: Tannen f p a b -> Tannen f p a b -> Bool # max :: Tannen f p a b -> Tannen f p a b -> Tannen f p a b # min :: Tannen f p a b -> Tannen f p a b -> Tannen f p a b #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering # (<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering # (<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) #
Ord (p (f a) (g b)) => Ord (Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Methods compare :: Biff p f g a b -> Biff p f g a b -> Ordering # (<) :: Biff p f g a b -> Biff p f g a b -> Bool # (<=) :: Biff p f g a b -> Biff p f g a b -> Bool # (>) :: Biff p f g a b -> Biff p f g a b -> Bool # (>=) :: Biff p f g a b -> Biff p f g a b -> Bool # max :: Biff p f g a b -> Biff p f g a b -> Biff p f g a b # min :: Biff p f g a b -> Biff p f g a b -> Biff p f g a b #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
Instance details Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #

class Read a #

Parsing of Strings, producing values.

Derived instances of Read make the following assumptions, which derived instances of Show obey:

If the constructor is defined to be an infix operator, then the derived Read instance will parse only infix applications of the constructor (not the prefix form).
Associativity is not used to reduce the occurrence of parentheses, although precedence may be.
If the constructor is defined using record syntax, the derived Read will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration.
The derived Read instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.

For example, given the declarations

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

the derived instance of Read in Haskell 2010 is equivalent to

instance (Read a) => Read (Tree a) where

        readsPrec d r =  readParen (d > app_prec)
                         (\r -> [(Leaf m,t) |
                                 ("Leaf",s) <- lex r,
                                 (m,t) <- readsPrec (app_prec+1) s]) r

                      ++ readParen (d > up_prec)
                         (\r -> [(u:^:v,w) |
                                 (u,s) <- readsPrec (up_prec+1) r,
                                 (":^:",t) <- lex s,
                                 (v,w) <- readsPrec (up_prec+1) t]) r

          where app_prec = 10
                up_prec = 5

Note that right-associativity of :^: is unused.

The derived instance in GHC is equivalent to

instance (Read a) => Read (Tree a) where

        readPrec = parens $ (prec app_prec $ do
                                 Ident "Leaf" <- lexP
                                 m <- step readPrec
                                 return (Leaf m))

                     +++ (prec up_prec $ do
                                 u <- step readPrec
                                 Symbol ":^:" <- lexP
                                 v <- step readPrec
                                 return (u :^: v))

          where app_prec = 10
                up_prec = 5

        readListPrec = readListPrecDefault

Why do both readsPrec and readPrec exist, and why does GHC opt to implement readPrec in derived Read instances instead of readsPrec? The reason is that readsPrec is based on the ReadS type, and although ReadS is mentioned in the Haskell 2010 Report, it is not a very efficient parser data structure.

readPrec, on the other hand, is based on a much more efficient ReadPrec datatype (a.k.a "new-style parsers"), but its definition relies on the use of the RankNTypes language extension. Therefore, readPrec (and its cousin, readListPrec) are marked as GHC-only. Nevertheless, it is recommended to use readPrec instead of readsPrec whenever possible for the efficiency improvements it brings.

As mentioned above, derived Read instances in GHC will implement readPrec instead of readsPrec. The default implementations of readsPrec (and its cousin, readList) will simply use readPrec under the hood. If you are writing a Read instance by hand, it is recommended to write it like so:

instance Read T where
  readPrec     = ...
  readListPrec = readListPrecDefault

Minimal complete definition

readsPrec | readPrec

Instances

Instances details

Read CabalSpecVersion
Instance details Defined in Distribution.CabalSpecVersion Methods readsPrec :: Int -> ReadS CabalSpecVersion # readList :: ReadS [CabalSpecVersion] # readPrec :: ReadPrec CabalSpecVersion # readListPrec :: ReadPrec [CabalSpecVersion] #
Read Extension
Instance details Defined in Language.Haskell.Extension Methods readsPrec :: Int -> ReadS Extension # readList :: ReadS [Extension] # readPrec :: ReadPrec Extension # readListPrec :: ReadPrec [Extension] #
Read KnownExtension
Instance details Defined in Language.Haskell.Extension Methods readsPrec :: Int -> ReadS KnownExtension # readList :: ReadS [KnownExtension] # readPrec :: ReadPrec KnownExtension # readListPrec :: ReadPrec [KnownExtension] #
Read Language
Instance details Defined in Language.Haskell.Extension Methods readsPrec :: Int -> ReadS Language # readList :: ReadS [Language] # readPrec :: ReadPrec Language # readListPrec :: ReadPrec [Language] #
Read DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods readsPrec :: Int -> ReadS DotNetTime # readList :: ReadS [DotNetTime] # readPrec :: ReadPrec DotNetTime # readListPrec :: ReadPrec [DotNetTime] #
Read Value
Instance details Defined in Data.Aeson.Types.Internal Methods readsPrec :: Int -> ReadS Value # readList :: ReadS [Value] # readPrec :: ReadPrec Value # readListPrec :: ReadPrec [Value] #
Read All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS All # readList :: ReadS [All] # readPrec :: ReadPrec All # readListPrec :: ReadPrec [All] #
Read Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS Any # readList :: ReadS [Any] # readPrec :: ReadPrec Any # readListPrec :: ReadPrec [Any] #
Read Version	Since: base-2.1
Instance details Defined in Data.Version Methods readsPrec :: Int -> ReadS Version # readList :: ReadS [Version] # readPrec :: ReadPrec Version # readListPrec :: ReadPrec [Version] #
Read Void	Reading a `Void` value is always a parse error, considering `Void` as a data type with no constructors. Since: base-4.8.0.0
Instance details Defined in Data.Void Methods readsPrec :: Int -> ReadS Void # readList :: ReadS [Void] # readPrec :: ReadPrec Void # readListPrec :: ReadPrec [Void] #
Read Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS Associativity # readList :: ReadS [Associativity] # readPrec :: ReadPrec Associativity # readListPrec :: ReadPrec [Associativity] #
Read DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS DecidedStrictness # readList :: ReadS [DecidedStrictness] # readPrec :: ReadPrec DecidedStrictness # readListPrec :: ReadPrec [DecidedStrictness] #
Read Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS Fixity # readList :: ReadS [Fixity] # readPrec :: ReadPrec Fixity # readListPrec :: ReadPrec [Fixity] #
Read SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS SourceStrictness # readList :: ReadS [SourceStrictness] # readPrec :: ReadPrec SourceStrictness # readListPrec :: ReadPrec [SourceStrictness] #
Read SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS SourceUnpackedness # readList :: ReadS [SourceUnpackedness] # readPrec :: ReadPrec SourceUnpackedness # readListPrec :: ReadPrec [SourceUnpackedness] #
Read ExitCode
Instance details Defined in GHC.IO.Exception Methods readsPrec :: Int -> ReadS ExitCode # readList :: ReadS [ExitCode] # readPrec :: ReadPrec ExitCode # readListPrec :: ReadPrec [ExitCode] #
Read BufferMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods readsPrec :: Int -> ReadS BufferMode # readList :: ReadS [BufferMode] # readPrec :: ReadPrec BufferMode # readListPrec :: ReadPrec [BufferMode] #
Read Newline	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods readsPrec :: Int -> ReadS Newline # readList :: ReadS [Newline] # readPrec :: ReadPrec Newline # readListPrec :: ReadPrec [Newline] #
Read NewlineMode	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods readsPrec :: Int -> ReadS NewlineMode # readList :: ReadS [NewlineMode] # readPrec :: ReadPrec NewlineMode # readListPrec :: ReadPrec [NewlineMode] #
Read IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods readsPrec :: Int -> ReadS IOMode # readList :: ReadS [IOMode] # readPrec :: ReadPrec IOMode # readListPrec :: ReadPrec [IOMode] #
Read Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int16 # readList :: ReadS [Int16] # readPrec :: ReadPrec Int16 # readListPrec :: ReadPrec [Int16] #
Read Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] # readPrec :: ReadPrec Int32 # readListPrec :: ReadPrec [Int32] #
Read Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] # readPrec :: ReadPrec Int64 # readListPrec :: ReadPrec [Int64] #
Read Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int8 # readList :: ReadS [Int8] # readPrec :: ReadPrec Int8 # readListPrec :: ReadPrec [Int8] #
Read GCDetails	Since: base-4.10.0.0
Instance details Defined in GHC.Stats Methods readsPrec :: Int -> ReadS GCDetails # readList :: ReadS [GCDetails] # readPrec :: ReadPrec GCDetails # readListPrec :: ReadPrec [GCDetails] #
Read RTSStats	Since: base-4.10.0.0
Instance details Defined in GHC.Stats Methods readsPrec :: Int -> ReadS RTSStats # readList :: ReadS [RTSStats] # readPrec :: ReadPrec RTSStats # readListPrec :: ReadPrec [RTSStats] #
Read SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods readsPrec :: Int -> ReadS SomeSymbol # readList :: ReadS [SomeSymbol] # readPrec :: ReadPrec SomeSymbol # readListPrec :: ReadPrec [SomeSymbol] #
Read SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods readsPrec :: Int -> ReadS SomeNat # readList :: ReadS [SomeNat] # readPrec :: ReadPrec SomeNat # readListPrec :: ReadPrec [SomeNat] #
Read GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS GeneralCategory # readList :: ReadS [GeneralCategory] # readPrec :: ReadPrec GeneralCategory # readListPrec :: ReadPrec [GeneralCategory] #
Read Word16	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word16 # readList :: ReadS [Word16] # readPrec :: ReadPrec Word16 # readListPrec :: ReadPrec [Word16] #
Read Word32	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word32 # readList :: ReadS [Word32] # readPrec :: ReadPrec Word32 # readListPrec :: ReadPrec [Word32] #
Read Word64	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word64 # readList :: ReadS [Word64] # readPrec :: ReadPrec Word64 # readListPrec :: ReadPrec [Word64] #
Read Lexeme	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Lexeme # readList :: ReadS [Lexeme] # readPrec :: ReadPrec Lexeme # readListPrec :: ReadPrec [Lexeme] #
Read Bit
Instance details Defined in Data.Bit.Internal Methods readsPrec :: Int -> ReadS Bit # readList :: ReadS [Bit] # readPrec :: ReadPrec Bit # readListPrec :: ReadPrec [Bit] #
Read ByteString
Instance details Defined in Data.ByteString.Internal Methods readsPrec :: Int -> ReadS ByteString # readList :: ReadS [ByteString] # readPrec :: ReadPrec ByteString # readListPrec :: ReadPrec [ByteString] #
Read ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods readsPrec :: Int -> ReadS ByteString # readList :: ReadS [ByteString] # readPrec :: ReadPrec ByteString # readListPrec :: ReadPrec [ByteString] #
Read ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods readsPrec :: Int -> ReadS ShortByteString # readList :: ReadS [ShortByteString] # readPrec :: ReadPrec ShortByteString # readListPrec :: ReadPrec [ShortByteString] #
Read Clock
Instance details Defined in System.Clock Methods readsPrec :: Int -> ReadS Clock # readList :: ReadS [Clock] # readPrec :: ReadPrec Clock # readListPrec :: ReadPrec [Clock] #
Read TimeSpec
Instance details Defined in System.Clock Methods readsPrec :: Int -> ReadS TimeSpec # readList :: ReadS [TimeSpec] # readPrec :: ReadPrec TimeSpec # readListPrec :: ReadPrec [TimeSpec] #
Read IntSet
Instance details Defined in Data.IntSet.Internal Methods readsPrec :: Int -> ReadS IntSet # readList :: ReadS [IntSet] # readPrec :: ReadPrec IntSet # readListPrec :: ReadPrec [IntSet] #
Read KeyPair
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods readsPrec :: Int -> ReadS KeyPair # readList :: ReadS [KeyPair] # readPrec :: ReadPrec KeyPair # readListPrec :: ReadPrec [KeyPair] #
Read PrivateKey
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods readsPrec :: Int -> ReadS PrivateKey # readList :: ReadS [PrivateKey] # readPrec :: ReadPrec PrivateKey # readListPrec :: ReadPrec [PrivateKey] #
Read PublicKey
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods readsPrec :: Int -> ReadS PublicKey # readList :: ReadS [PublicKey] # readPrec :: ReadPrec PublicKey # readListPrec :: ReadPrec [PublicKey] #
Read Signature
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods readsPrec :: Int -> ReadS Signature # readList :: ReadS [Signature] # readPrec :: ReadPrec Signature # readListPrec :: ReadPrec [Signature] #
Read Ordering	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Ordering # readList :: ReadS [Ordering] # readPrec :: ReadPrec Ordering # readListPrec :: ReadPrec [Ordering] #
Read Pos
Instance details Defined in Text.Megaparsec.Pos Methods readsPrec :: Int -> ReadS Pos # readList :: ReadS [Pos] # readPrec :: ReadPrec Pos # readListPrec :: ReadPrec [Pos] #
Read SourcePos
Instance details Defined in Text.Megaparsec.Pos Methods readsPrec :: Int -> ReadS SourcePos # readList :: ReadS [SourcePos] # readPrec :: ReadPrec SourcePos # readListPrec :: ReadPrec [SourcePos] #
Read Scientific	Supports the skipping of parentheses and whitespaces. Example: > read " ( (( -1.0e+3 ) ))" :: Scientific -1000.0 (Note: This `Read` instance makes internal use of `scientificP` to parse the floating-point number.)
Instance details Defined in Data.Scientific Methods readsPrec :: Int -> ReadS Scientific # readList :: ReadS [Scientific] # readPrec :: ReadPrec Scientific # readListPrec :: ReadPrec [Scientific] #
Read Mod2
Instance details Defined in Data.Semiring Methods readsPrec :: Int -> ReadS Mod2 # readList :: ReadS [Mod2] # readPrec :: ReadPrec Mod2 # readListPrec :: ReadPrec [Mod2] #
Read ShortText
Instance details Defined in Data.Text.Short.Internal Methods readsPrec :: Int -> ReadS ShortText # readList :: ReadS [ShortText] # readPrec :: ReadPrec ShortText # readListPrec :: ReadPrec [ShortText] #
Read DatatypeVariant
Instance details Defined in Language.Haskell.TH.Datatype Methods readsPrec :: Int -> ReadS DatatypeVariant # readList :: ReadS [DatatypeVariant] # readPrec :: ReadPrec DatatypeVariant # readListPrec :: ReadPrec [DatatypeVariant] #
Read Undefined
Instance details Defined in Universum.Debug Methods readsPrec :: Int -> ReadS Undefined # readList :: ReadS [Undefined] # readPrec :: ReadPrec Undefined # readListPrec :: ReadPrec [Undefined] #
Read UUID
Instance details Defined in Data.UUID.Types.Internal Methods readsPrec :: Int -> ReadS UUID # readList :: ReadS [UUID] # readPrec :: ReadPrec UUID # readListPrec :: ReadPrec [UUID] #
Read UnpackedUUID
Instance details Defined in Data.UUID.Types.Internal Methods readsPrec :: Int -> ReadS UnpackedUUID # readList :: ReadS [UnpackedUUID] # readPrec :: ReadPrec UnpackedUUID # readListPrec :: ReadPrec [UnpackedUUID] #
Read Word8	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word8 # readList :: ReadS [Word8] # readPrec :: ReadPrec Word8 # readListPrec :: ReadPrec [Word8] #
Read Integer	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Integer # readList :: ReadS [Integer] # readPrec :: ReadPrec Integer # readListPrec :: ReadPrec [Integer] #
Read Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Natural # readList :: ReadS [Natural] # readPrec :: ReadPrec Natural # readListPrec :: ReadPrec [Natural] #
Read ()	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS () # readList :: ReadS [()] # readPrec :: ReadPrec () # readListPrec :: ReadPrec [()] #
Read Bool	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Bool # readList :: ReadS [Bool] # readPrec :: ReadPrec Bool # readListPrec :: ReadPrec [Bool] #
Read Char	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Char # readList :: ReadS [Char] # readPrec :: ReadPrec Char # readListPrec :: ReadPrec [Char] #
Read Double	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
Read Float	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
Read Int	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Int # readList :: ReadS [Int] # readPrec :: ReadPrec Int # readListPrec :: ReadPrec [Int] #
Read Word	Since: base-4.5.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word # readList :: ReadS [Word] # readPrec :: ReadPrec Word # readListPrec :: ReadPrec [Word] #
() :=> (Read Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Ordering #
() :=> (Read Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Natural #
() :=> (Read ())
Instance details Defined in Data.Constraint Methods ins :: () :- Read () #
() :=> (Read Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Bool #
() :=> (Read Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Char #
() :=> (Read Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Int #
() :=> (Read Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Word #
a :=> (Read (Dict a))
Instance details Defined in Data.Constraint Methods ins :: a :- Read (Dict a) #
Class () (Read a)
Instance details Defined in Data.Constraint Methods cls :: Read a :- () #
Read a => Read (Last' a)
Instance details Defined in Distribution.Compat.Semigroup Methods readsPrec :: Int -> ReadS (Last' a) # readList :: ReadS [Last' a] # readPrec :: ReadPrec (Last' a) # readListPrec :: ReadPrec [Last' a] #
Read a => Read (Option' a)
Instance details Defined in Distribution.Compat.Semigroup Methods readsPrec :: Int -> ReadS (Option' a) # readList :: ReadS [Option' a] # readPrec :: ReadPrec (Option' a) # readListPrec :: ReadPrec [Option' a] #
Read v => Read (KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods readsPrec :: Int -> ReadS (KeyMap v) # readList :: ReadS [KeyMap v] # readPrec :: ReadPrec (KeyMap v) # readListPrec :: ReadPrec [KeyMap v] #
Read a => Read (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods readsPrec :: Int -> ReadS (ZipList a) # readList :: ReadS [ZipList a] # readPrec :: ReadPrec (ZipList a) # readListPrec :: ReadPrec [ZipList a] #
Read a => Read (Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods readsPrec :: Int -> ReadS (Complex a) # readList :: ReadS [Complex a] # readPrec :: ReadPrec (Complex a) # readListPrec :: ReadPrec [Complex a] #
Read a => Read (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods readsPrec :: Int -> ReadS (Identity a) # readList :: ReadS [Identity a] # readPrec :: ReadPrec (Identity a) # readListPrec :: ReadPrec [Identity a] #
Read a => Read (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS (First a) # readList :: ReadS [First a] # readPrec :: ReadPrec (First a) # readListPrec :: ReadPrec [First a] #
Read a => Read (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS (Last a) # readList :: ReadS [Last a] # readPrec :: ReadPrec (Last a) # readListPrec :: ReadPrec [Last a] #
Read a => Read (Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods readsPrec :: Int -> ReadS (Down a) # readList :: ReadS [Down a] # readPrec :: ReadPrec (Down a) # readListPrec :: ReadPrec [Down a] #
Read a => Read (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS (First a) # readList :: ReadS [First a] # readPrec :: ReadPrec (First a) # readListPrec :: ReadPrec [First a] #
Read a => Read (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS (Last a) # readList :: ReadS [Last a] # readPrec :: ReadPrec (Last a) # readListPrec :: ReadPrec [Last a] #
Read a => Read (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS (Max a) # readList :: ReadS [Max a] # readPrec :: ReadPrec (Max a) # readListPrec :: ReadPrec [Max a] #
Read a => Read (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS (Min a) # readList :: ReadS [Min a] # readPrec :: ReadPrec (Min a) # readListPrec :: ReadPrec [Min a] #
Read a => Read (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS (Option a) # readList :: ReadS [Option a] # readPrec :: ReadPrec (Option a) # readListPrec :: ReadPrec [Option a] #
Read m => Read (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS (WrappedMonoid m) # readList :: ReadS [WrappedMonoid m] # readPrec :: ReadPrec (WrappedMonoid m) # readListPrec :: ReadPrec [WrappedMonoid m] #
Read a => Read (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS (Dual a) # readList :: ReadS [Dual a] # readPrec :: ReadPrec (Dual a) # readListPrec :: ReadPrec [Dual a] #
Read a => Read (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS (Product a) # readList :: ReadS [Product a] # readPrec :: ReadPrec (Product a) # readListPrec :: ReadPrec [Product a] #
Read a => Read (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS (Sum a) # readList :: ReadS [Sum a] # readPrec :: ReadPrec (Sum a) # readListPrec :: ReadPrec [Sum a] #
Read a => Read (NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (NonEmpty a) # readList :: ReadS [NonEmpty a] # readPrec :: ReadPrec (NonEmpty a) # readListPrec :: ReadPrec [NonEmpty a] #
Read p => Read (Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (Par1 p) # readList :: ReadS [Par1 p] # readPrec :: ReadPrec (Par1 p) # readListPrec :: ReadPrec [Par1 p] #
(Integral a, Read a) => Read (Ratio a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (Ratio a) # readList :: ReadS [Ratio a] # readPrec :: ReadPrec (Ratio a) # readListPrec :: ReadPrec [Ratio a] #
a => Read (Dict a)
Instance details Defined in Data.Constraint Methods readsPrec :: Int -> ReadS (Dict a) # readList :: ReadS [Dict a] # readPrec :: ReadPrec (Dict a) # readListPrec :: ReadPrec [Dict a] #
Read vertex => Read (SCC vertex)	Since: containers-0.5.9
Instance details Defined in Data.Graph Methods readsPrec :: Int -> ReadS (SCC vertex) # readList :: ReadS [SCC vertex] # readPrec :: ReadPrec (SCC vertex) # readListPrec :: ReadPrec [SCC vertex] #
Read e => Read (IntMap e)
Instance details Defined in Data.IntMap.Internal Methods readsPrec :: Int -> ReadS (IntMap e) # readList :: ReadS [IntMap e] # readPrec :: ReadPrec (IntMap e) # readListPrec :: ReadPrec [IntMap e] #
Read a => Read (Seq a)
Instance details Defined in Data.Sequence.Internal Methods readsPrec :: Int -> ReadS (Seq a) # readList :: ReadS [Seq a] # readPrec :: ReadPrec (Seq a) # readListPrec :: ReadPrec [Seq a] #
Read a => Read (ViewL a)
Instance details Defined in Data.Sequence.Internal Methods readsPrec :: Int -> ReadS (ViewL a) # readList :: ReadS [ViewL a] # readPrec :: ReadPrec (ViewL a) # readListPrec :: ReadPrec [ViewL a] #
Read a => Read (ViewR a)
Instance details Defined in Data.Sequence.Internal Methods readsPrec :: Int -> ReadS (ViewR a) # readList :: ReadS [ViewR a] # readPrec :: ReadPrec (ViewR a) # readListPrec :: ReadPrec [ViewR a] #
(Read a, Ord a) => Read (Set a)
Instance details Defined in Data.Set.Internal Methods readsPrec :: Int -> ReadS (Set a) # readList :: ReadS [Set a] # readPrec :: ReadPrec (Set a) # readListPrec :: ReadPrec [Set a] #
Read a => Read (Tree a)
Instance details Defined in Data.Tree Methods readsPrec :: Int -> ReadS (Tree a) # readList :: ReadS [Tree a] # readPrec :: ReadPrec (Tree a) # readListPrec :: ReadPrec [Tree a] #
Read1 f => Read (Fix f)
Instance details Defined in Data.Fix Methods readsPrec :: Int -> ReadS (Fix f) # readList :: ReadS [Fix f] # readPrec :: ReadPrec (Fix f) # readListPrec :: ReadPrec [Fix f] #
(Functor f, Read1 f) => Read (Mu f)
Instance details Defined in Data.Fix Methods readsPrec :: Int -> ReadS (Mu f) # readList :: ReadS [Mu f] # readPrec :: ReadPrec (Mu f) # readListPrec :: ReadPrec [Mu f] #
(Functor f, Read1 f) => Read (Nu f)
Instance details Defined in Data.Fix Methods readsPrec :: Int -> ReadS (Nu f) # readList :: ReadS [Nu f] # readPrec :: ReadPrec (Nu f) # readListPrec :: ReadPrec [Nu f] #
Read a => Read (DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods readsPrec :: Int -> ReadS (DNonEmpty a) # readList :: ReadS [DNonEmpty a] # readPrec :: ReadPrec (DNonEmpty a) # readListPrec :: ReadPrec [DNonEmpty a] #
Read a => Read (DList a)
Instance details Defined in Data.DList.Internal Methods readsPrec :: Int -> ReadS (DList a) # readList :: ReadS [DList a] # readPrec :: ReadPrec (DList a) # readListPrec :: ReadPrec [DList a] #
Read e => Read (ErrorFancy e)
Instance details Defined in Text.Megaparsec.Error Methods readsPrec :: Int -> ReadS (ErrorFancy e) # readList :: ReadS [ErrorFancy e] # readPrec :: ReadPrec (ErrorFancy e) # readListPrec :: ReadPrec [ErrorFancy e] #
Read t => Read (ErrorItem t)
Instance details Defined in Text.Megaparsec.Error Methods readsPrec :: Int -> ReadS (ErrorItem t) # readList :: ReadS [ErrorItem t] # readPrec :: ReadPrec (ErrorItem t) # readListPrec :: ReadPrec [ErrorItem t] #
Read a => Read (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods readsPrec :: Int -> ReadS (StringEncode a) # readList :: ReadS [StringEncode a] # readPrec :: ReadPrec (StringEncode a) # readListPrec :: ReadPrec [StringEncode a] #
Read a => Read (All a)
Instance details Defined in Morley.Prelude.Boolean Methods readsPrec :: Int -> ReadS (All a) # readList :: ReadS [All a] # readPrec :: ReadPrec (All a) # readListPrec :: ReadPrec [All a] #
Read a => Read (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods readsPrec :: Int -> ReadS (Any a) # readList :: ReadS [Any a] # readPrec :: ReadPrec (Any a) # readListPrec :: ReadPrec [Any a] #
Read a => Read (Array a)
Instance details Defined in Data.Primitive.Array Methods readsPrec :: Int -> ReadS (Array a) # readList :: ReadS [Array a] # readPrec :: ReadPrec (Array a) # readListPrec :: ReadPrec [Array a] #
Read a => Read (SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods readsPrec :: Int -> ReadS (SmallArray a) # readList :: ReadS [SmallArray a] # readPrec :: ReadPrec (SmallArray a) # readListPrec :: ReadPrec [SmallArray a] #
Read a => Read (Add a)
Instance details Defined in Data.Semiring Methods readsPrec :: Int -> ReadS (Add a) # readList :: ReadS [Add a] # readPrec :: ReadPrec (Add a) # readListPrec :: ReadPrec [Add a] #
Read (IntSetOf a)
Instance details Defined in Data.Semiring Methods readsPrec :: Int -> ReadS (IntSetOf a) # readList :: ReadS [IntSetOf a] # readPrec :: ReadPrec (IntSetOf a) # readListPrec :: ReadPrec [IntSetOf a] #
Read a => Read (Mul a)
Instance details Defined in Data.Semiring Methods readsPrec :: Int -> ReadS (Mul a) # readList :: ReadS [Mul a] # readPrec :: ReadPrec (Mul a) # readListPrec :: ReadPrec [Mul a] #
Read a => Read (WrappedNum a)
Instance details Defined in Data.Semiring Methods readsPrec :: Int -> ReadS (WrappedNum a) # readList :: ReadS [WrappedNum a] # readPrec :: ReadPrec (WrappedNum a) # readListPrec :: ReadPrec [WrappedNum a] #
Read a => Read (Maybe a)
Instance details Defined in Data.Strict.Maybe Methods readsPrec :: Int -> ReadS (Maybe a) # readList :: ReadS [Maybe a] # readPrec :: ReadPrec (Maybe a) # readListPrec :: ReadPrec [Maybe a] #
(Eq a, Hashable a, Read a) => Read (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods readsPrec :: Int -> ReadS (HashSet a) # readList :: ReadS [HashSet a] # readPrec :: ReadPrec (HashSet a) # readListPrec :: ReadPrec [HashSet a] #
Read a => Read (Vector a)
Instance details Defined in Data.Vector Methods readsPrec :: Int -> ReadS (Vector a) # readList :: ReadS [Vector a] # readPrec :: ReadPrec (Vector a) # readListPrec :: ReadPrec [Vector a] #
(Read a, Prim a) => Read (Vector a)
Instance details Defined in Data.Vector.Primitive Methods readsPrec :: Int -> ReadS (Vector a) # readList :: ReadS [Vector a] # readPrec :: ReadPrec (Vector a) # readListPrec :: ReadPrec [Vector a] #
(Read a, Storable a) => Read (Vector a)
Instance details Defined in Data.Vector.Storable Methods readsPrec :: Int -> ReadS (Vector a) # readList :: ReadS [Vector a] # readPrec :: ReadPrec (Vector a) # readListPrec :: ReadPrec [Vector a] #
Read a => Read (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (Maybe a) # readList :: ReadS [Maybe a] # readPrec :: ReadPrec (Maybe a) # readListPrec :: ReadPrec [Maybe a] #
Read a => Read (a)	Since: base-4.15
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a) # readList :: ReadS [(a)] # readPrec :: ReadPrec (a) # readListPrec :: ReadPrec [(a)] #
Read a => Read [a]	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS [a] # readList :: ReadS [[a]] # readPrec :: ReadPrec [a] # readListPrec :: ReadPrec [[a]] #
(Read a) :=> (Read (Complex a))
Instance details Defined in Data.Constraint Methods ins :: Read a :- Read (Complex a) #
(Read a) :=> (Read (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Read a :- Read (Const a b) #
(Read a) :=> (Read (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Read a :- Read (Identity a) #
(Read a) :=> (Read (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Read a :- Read (Maybe a) #
(Read a) :=> (Read [a])
Instance details Defined in Data.Constraint Methods ins :: Read a :- Read [a] #
(Read a, Num a, Bits a, TypeNum n) => Read (OddWord a n)
Instance details Defined in Data.Word.Odd Methods readsPrec :: Int -> ReadS (OddWord a n) # readList :: ReadS [OddWord a n] # readPrec :: ReadPrec (OddWord a n) # readListPrec :: ReadPrec [OddWord a n] #
(Read a, Read b) => Read (Either a b)	Since: base-3.0
Instance details Defined in Data.Either Methods readsPrec :: Int -> ReadS (Either a b) # readList :: ReadS [Either a b] # readPrec :: ReadPrec (Either a b) # readListPrec :: ReadPrec [Either a b] #
HasResolution a => Read (Fixed a)	Since: base-4.3.0.0
Instance details Defined in Data.Fixed Methods readsPrec :: Int -> ReadS (Fixed a) # readList :: ReadS [Fixed a] # readPrec :: ReadPrec (Fixed a) # readListPrec :: ReadPrec [Fixed a] #
Read (Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods readsPrec :: Int -> ReadS (Proxy t) # readList :: ReadS [Proxy t] # readPrec :: ReadPrec (Proxy t) # readListPrec :: ReadPrec [Proxy t] #
(Read a, Read b) => Read (Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS (Arg a b) # readList :: ReadS [Arg a b] # readPrec :: ReadPrec (Arg a b) # readListPrec :: ReadPrec [Arg a b] #
(Ix a, Read a, Read b) => Read (Array a b)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (Array a b) # readList :: ReadS [Array a b] # readPrec :: ReadPrec (Array a b) # readListPrec :: ReadPrec [Array a b] #
Read (U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (U1 p) # readList :: ReadS [U1 p] # readPrec :: ReadPrec (U1 p) # readListPrec :: ReadPrec [U1 p] #
Read (V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (V1 p) # readList :: ReadS [V1 p] # readPrec :: ReadPrec (V1 p) # readListPrec :: ReadPrec [V1 p] #
(Ord k, Read k, Read e) => Read (Map k e)
Instance details Defined in Data.Map.Internal Methods readsPrec :: Int -> ReadS (Map k e) # readList :: ReadS [Map k e] # readPrec :: ReadPrec (Map k e) # readListPrec :: ReadPrec [Map k e] #
(Read1 f, Read a) => Read (Cofree f a)
Instance details Defined in Control.Comonad.Cofree Methods readsPrec :: Int -> ReadS (Cofree f a) # readList :: ReadS [Cofree f a] # readPrec :: ReadPrec (Cofree f a) # readListPrec :: ReadPrec [Cofree f a] #
(Read1 f, Read a) => Read (Free f a)
Instance details Defined in Control.Monad.Free Methods readsPrec :: Int -> ReadS (Free f a) # readList :: ReadS [Free f a] # readPrec :: ReadPrec (Free f a) # readListPrec :: ReadPrec [Free f a] #
(Functor f, Read (f a)) => Read (Yoneda f a)
Instance details Defined in Data.Functor.Yoneda Methods readsPrec :: Int -> ReadS (Yoneda f a) # readList :: ReadS [Yoneda f a] # readPrec :: ReadPrec (Yoneda f a) # readListPrec :: ReadPrec [Yoneda f a] #
Read v => Read (IntMapOf k v)
Instance details Defined in Data.Semiring Methods readsPrec :: Int -> ReadS (IntMapOf k v) # readList :: ReadS [IntMapOf k v] # readPrec :: ReadPrec (IntMapOf k v) # readListPrec :: ReadPrec [IntMapOf k v] #
(Read a, Read b) => Read (Either a b)
Instance details Defined in Data.Strict.Either Methods readsPrec :: Int -> ReadS (Either a b) # readList :: ReadS [Either a b] # readPrec :: ReadPrec (Either a b) # readListPrec :: ReadPrec [Either a b] #
(Read a, Read b) => Read (These a b)
Instance details Defined in Data.Strict.These Methods readsPrec :: Int -> ReadS (These a b) # readList :: ReadS [These a b] # readPrec :: ReadPrec (These a b) # readListPrec :: ReadPrec [These a b] #
(Read a, Read b) => Read (Pair a b)
Instance details Defined in Data.Strict.Tuple Methods readsPrec :: Int -> ReadS (Pair a b) # readList :: ReadS [Pair a b] # readPrec :: ReadPrec (Pair a b) # readListPrec :: ReadPrec [Pair a b] #
(Read a, Read b) => Read (These a b)
Instance details Defined in Data.These Methods readsPrec :: Int -> ReadS (These a b) # readList :: ReadS [These a b] # readPrec :: ReadPrec (These a b) # readListPrec :: ReadPrec [These a b] #
(Read1 m, Read a) => Read (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods readsPrec :: Int -> ReadS (MaybeT m a) # readList :: ReadS [MaybeT m a] # readPrec :: ReadPrec (MaybeT m a) # readListPrec :: ReadPrec [MaybeT m a] #
(Eq k, Hashable k, Read k, Read e) => Read (HashMap k e)
Instance details Defined in Data.HashMap.Internal Methods readsPrec :: Int -> ReadS (HashMap k e) # readList :: ReadS [HashMap k e] # readPrec :: ReadPrec (HashMap k e) # readListPrec :: ReadPrec [HashMap k e] #
(Read a, Read b) => Read (a, b)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b) # readList :: ReadS [(a, b)] # readPrec :: ReadPrec (a, b) # readListPrec :: ReadPrec [(a, b)] #
(Read a, Read b) :=> (Read (Either a b))
Instance details Defined in Data.Constraint Methods ins :: (Read a, Read b) :- Read (Either a b) #
(Read a, Read b) :=> (Read (a, b))
Instance details Defined in Data.Constraint Methods ins :: (Read a, Read b) :- Read (a, b) #
(Integral a, Read a) :=> (Read (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: (Integral a, Read a) :- Read (Ratio a) #
Read a => Read (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods readsPrec :: Int -> ReadS (Const a b) # readList :: ReadS [Const a b] # readPrec :: ReadPrec (Const a b) # readListPrec :: ReadPrec [Const a b] #
Read (f a) => Read (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS (Ap f a) # readList :: ReadS [Ap f a] # readPrec :: ReadPrec (Ap f a) # readListPrec :: ReadPrec [Ap f a] #
Read (f a) => Read (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS (Alt f a) # readList :: ReadS [Alt f a] # readPrec :: ReadPrec (Alt f a) # readListPrec :: ReadPrec [Alt f a] #
Coercible a b => Read (Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods readsPrec :: Int -> ReadS (Coercion a b) # readList :: ReadS [Coercion a b] # readPrec :: ReadPrec (Coercion a b) # readListPrec :: ReadPrec [Coercion a b] #
a ~ b => Read (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods readsPrec :: Int -> ReadS (a :~: b) # readList :: ReadS [a :~: b] # readPrec :: ReadPrec (a :~: b) # readListPrec :: ReadPrec [a :~: b] #
Read (f p) => Read (Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (Rec1 f p) # readList :: ReadS [Rec1 f p] # readPrec :: ReadPrec (Rec1 f p) # readListPrec :: ReadPrec [Rec1 f p] #
Read (p (Fix p a) a) => Read (Fix p a)
Instance details Defined in Data.Bifunctor.Fix Methods readsPrec :: Int -> ReadS (Fix p a) # readList :: ReadS [Fix p a] # readPrec :: ReadPrec (Fix p a) # readListPrec :: ReadPrec [Fix p a] #
Read (p a a) => Read (Join p a)
Instance details Defined in Data.Bifunctor.Join Methods readsPrec :: Int -> ReadS (Join p a) # readList :: ReadS [Join p a] # readPrec :: ReadPrec (Join p a) # readListPrec :: ReadPrec [Join p a] #
(Read a, Read (f b)) => Read (CofreeF f a b)
Instance details Defined in Control.Comonad.Trans.Cofree Methods readsPrec :: Int -> ReadS (CofreeF f a b) # readList :: ReadS [CofreeF f a b] # readPrec :: ReadPrec (CofreeF f a b) # readListPrec :: ReadPrec [CofreeF f a b] #
Read (w (CofreeF f a (CofreeT f w a))) => Read (CofreeT f w a)
Instance details Defined in Control.Comonad.Trans.Cofree Methods readsPrec :: Int -> ReadS (CofreeT f w a) # readList :: ReadS [CofreeT f w a] # readPrec :: ReadPrec (CofreeT f w a) # readListPrec :: ReadPrec [CofreeT f w a] #
(Read a, Read (f b)) => Read (FreeF f a b)
Instance details Defined in Control.Monad.Trans.Free Methods readsPrec :: Int -> ReadS (FreeF f a b) # readList :: ReadS [FreeF f a b] # readPrec :: ReadPrec (FreeF f a b) # readListPrec :: ReadPrec [FreeF f a b] #
(Read1 f, Read1 m, Read a) => Read (FreeT f m a)
Instance details Defined in Control.Monad.Trans.Free Methods readsPrec :: Int -> ReadS (FreeT f m a) # readList :: ReadS [FreeT f m a] # readPrec :: ReadPrec (FreeT f m a) # readListPrec :: ReadPrec [FreeT f m a] #
Read b => Read (Tagged s b)
Instance details Defined in Data.Tagged Methods readsPrec :: Int -> ReadS (Tagged s b) # readList :: ReadS [Tagged s b] # readPrec :: ReadPrec (Tagged s b) # readListPrec :: ReadPrec [Tagged s b] #
(Read1 f, Read1 g, Read a) => Read (These1 f g a)
Instance details Defined in Data.Functor.These Methods readsPrec :: Int -> ReadS (These1 f g a) # readList :: ReadS [These1 f g a] # readPrec :: ReadPrec (These1 f g a) # readListPrec :: ReadPrec [These1 f g a] #
(Read e, Read1 m, Read a) => Read (ErrorT e m a)
Instance details Defined in Control.Monad.Trans.Error Methods readsPrec :: Int -> ReadS (ErrorT e m a) # readList :: ReadS [ErrorT e m a] # readPrec :: ReadPrec (ErrorT e m a) # readListPrec :: ReadPrec [ErrorT e m a] #
(Read e, Read1 m, Read a) => Read (ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods readsPrec :: Int -> ReadS (ExceptT e m a) # readList :: ReadS [ExceptT e m a] # readPrec :: ReadPrec (ExceptT e m a) # readListPrec :: ReadPrec [ExceptT e m a] #
(Read1 f, Read a) => Read (IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods readsPrec :: Int -> ReadS (IdentityT f a) # readList :: ReadS [IdentityT f a] # readPrec :: ReadPrec (IdentityT f a) # readListPrec :: ReadPrec [IdentityT f a] #
(Read a, Read b, Read c) => Read (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c) # readList :: ReadS [(a, b, c)] # readPrec :: ReadPrec (a, b, c) # readListPrec :: ReadPrec [(a, b, c)] #
(Read1 f, Read1 g, Read a) => Read (Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods readsPrec :: Int -> ReadS (Product f g a) # readList :: ReadS [Product f g a] # readPrec :: ReadPrec (Product f g a) # readListPrec :: ReadPrec [Product f g a] #
(Read1 f, Read1 g, Read a) => Read (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods readsPrec :: Int -> ReadS (Sum f g a) # readList :: ReadS [Sum f g a] # readPrec :: ReadPrec (Sum f g a) # readListPrec :: ReadPrec [Sum f g a] #
a ~~ b => Read (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods readsPrec :: Int -> ReadS (a :~~: b) # readList :: ReadS [a :~~: b] # readPrec :: ReadPrec (a :~~: b) # readListPrec :: ReadPrec [a :~~: b] #
(Read (f p), Read (g p)) => Read ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :: g) p) # readList :: ReadS [(f :: g) p] # readPrec :: ReadPrec ((f :: g) p) # readListPrec :: ReadPrec [(f :: g) p] #
(Read (f p), Read (g p)) => Read ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :+: g) p) # readList :: ReadS [(f :+: g) p] # readPrec :: ReadPrec ((f :+: g) p) # readListPrec :: ReadPrec [(f :+: g) p] #
Read c => Read (K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (K1 i c p) # readList :: ReadS [K1 i c p] # readPrec :: ReadPrec (K1 i c p) # readListPrec :: ReadPrec [K1 i c p] #
(Read a, Read b, Read c, Read d) => Read (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d) # readList :: ReadS [(a, b, c, d)] # readPrec :: ReadPrec (a, b, c, d) # readListPrec :: ReadPrec [(a, b, c, d)] #
(Read1 f, Read1 g, Read a) => Read (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods readsPrec :: Int -> ReadS (Compose f g a) # readList :: ReadS [Compose f g a] # readPrec :: ReadPrec (Compose f g a) # readListPrec :: ReadPrec [Compose f g a] #
Read (f (g p)) => Read ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :.: g) p) # readList :: ReadS [(f :.: g) p] # readPrec :: ReadPrec ((f :.: g) p) # readListPrec :: ReadPrec [(f :.: g) p] #
Read (f p) => Read (M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (M1 i c f p) # readList :: ReadS [M1 i c f p] # readPrec :: ReadPrec (M1 i c f p) # readListPrec :: ReadPrec [M1 i c f p] #
Read (f a) => Read (Clown f a b)
Instance details Defined in Data.Bifunctor.Clown Methods readsPrec :: Int -> ReadS (Clown f a b) # readList :: ReadS [Clown f a b] # readPrec :: ReadPrec (Clown f a b) # readListPrec :: ReadPrec [Clown f a b] #
Read (p b a) => Read (Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Methods readsPrec :: Int -> ReadS (Flip p a b) # readList :: ReadS [Flip p a b] # readPrec :: ReadPrec (Flip p a b) # readListPrec :: ReadPrec [Flip p a b] #
Read (g b) => Read (Joker g a b)
Instance details Defined in Data.Bifunctor.Joker Methods readsPrec :: Int -> ReadS (Joker g a b) # readList :: ReadS [Joker g a b] # readPrec :: ReadPrec (Joker g a b) # readListPrec :: ReadPrec [Joker g a b] #
Read (p a b) => Read (WrappedBifunctor p a b)
Instance details Defined in Data.Bifunctor.Wrapped Methods readsPrec :: Int -> ReadS (WrappedBifunctor p a b) # readList :: ReadS [WrappedBifunctor p a b] # readPrec :: ReadPrec (WrappedBifunctor p a b) # readListPrec :: ReadPrec [WrappedBifunctor p a b] #
(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e) # readList :: ReadS [(a, b, c, d, e)] # readPrec :: ReadPrec (a, b, c, d, e) # readListPrec :: ReadPrec [(a, b, c, d, e)] #
(Read (f a b), Read (g a b)) => Read (Product f g a b)
Instance details Defined in Data.Bifunctor.Product Methods readsPrec :: Int -> ReadS (Product f g a b) # readList :: ReadS [Product f g a b] # readPrec :: ReadPrec (Product f g a b) # readListPrec :: ReadPrec [Product f g a b] #
(Read (p a b), Read (q a b)) => Read (Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Methods readsPrec :: Int -> ReadS (Sum p q a b) # readList :: ReadS [Sum p q a b] # readPrec :: ReadPrec (Sum p q a b) # readListPrec :: ReadPrec [Sum p q a b] #
(Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f) # readList :: ReadS [(a, b, c, d, e, f)] # readPrec :: ReadPrec (a, b, c, d, e, f) # readListPrec :: ReadPrec [(a, b, c, d, e, f)] #
Read (f (p a b)) => Read (Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Methods readsPrec :: Int -> ReadS (Tannen f p a b) # readList :: ReadS [Tannen f p a b] # readPrec :: ReadPrec (Tannen f p a b) # readListPrec :: ReadPrec [Tannen f p a b] #
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g) # readList :: ReadS [(a, b, c, d, e, f, g)] # readPrec :: ReadPrec (a, b, c, d, e, f, g) # readListPrec :: ReadPrec [(a, b, c, d, e, f, g)] #
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h) # readList :: ReadS [(a, b, c, d, e, f, g, h)] # readPrec :: ReadPrec (a, b, c, d, e, f, g, h) # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h)] #
Read (p (f a) (g b)) => Read (Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Methods readsPrec :: Int -> ReadS (Biff p f g a b) # readList :: ReadS [Biff p f g a b] # readPrec :: ReadPrec (Biff p f g a b) # readListPrec :: ReadPrec [Biff p f g a b] #
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i) # readList :: ReadS [(a, b, c, d, e, f, g, h, i)] # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i) # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i)] #
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j)] # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j) # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j)] #
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k)] # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k) # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k)] #
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l)] # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l) # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l)] #
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m)] # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m) # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m)] #
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] #
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] # readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] #

class (Num a, Ord a) => Real a where #

Methods

toRational :: a -> Rational #

the rational equivalent of its real argument with full precision

Instances

Instances details

Real Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int16 -> Rational #
Real Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int32 -> Rational #
Real Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int64 -> Rational #
Real Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int8 -> Rational #
Real Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word16 -> Rational #
Real Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word32 -> Rational #
Real Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word64 -> Rational #
Real F2Poly
Instance details Defined in Data.Bit.F2Poly Methods toRational :: F2Poly -> Rational #
Real Bit
Instance details Defined in Data.Bit.Internal Methods toRational :: Bit -> Rational #
Real TimeSpec
Instance details Defined in System.Clock Methods toRational :: TimeSpec -> Rational #
Real RefId Source #
Instance details Defined in Indigo.Common.Var Methods toRational :: RefId -> Rational #
Real Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods toRational :: Bls12381Fr -> Rational #
Real Scientific	WARNING: `toRational` needs to compute the `Integer` magnitude: `10^e`. If applied to a huge exponent this could fill up all space and crash your program! Avoid applying `toRational` (or `realToFrac`) to scientific numbers coming from an untrusted source and use `toRealFloat` instead. The latter guards against excessive space usage.
Instance details Defined in Data.Scientific Methods toRational :: Scientific -> Rational #
Real NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods toRational :: NominalDiffTime -> Rational #
Real Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word8 -> Rational #
Real Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Integer -> Rational #
Real Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods toRational :: Natural -> Rational #
Real Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Int -> Rational #
Real Word	Since: base-2.1
Instance details Defined in GHC.Real Methods toRational :: Word -> Rational #
() :=> (Real Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Integer #
() :=> (Real Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Natural #
() :=> (Real Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Double #
() :=> (Real Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Float #
() :=> (Real Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Int #
() :=> (Real Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Word #
Real a => Real (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational #
Real a => Real (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods toRational :: Down a -> Rational #
Integral a => Real (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Ratio a -> Rational #
KnownNat p => Real (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods toRational :: Binary p -> Rational #
KnownNat p => Real (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods toRational :: Prime p -> Rational #
Real a => Real (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods toRational :: StringEncode a -> Rational #
Real a => Real (Add a)
Instance details Defined in Data.Semiring Methods toRational :: Add a -> Rational #
Real a => Real (Mul a)
Instance details Defined in Data.Semiring Methods toRational :: Mul a -> Rational #
Real a => Real (WrappedNum a)
Instance details Defined in Data.Semiring Methods toRational :: WrappedNum a -> Rational #
(Real t, KnownSymbol s) => Real (ElField '(s, t))
Instance details Defined in Data.Vinyl.Functor Methods toRational :: ElField '(s, t) -> Rational #
(Integral a) :=> (Real (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Real (Ratio a) #
(Real a) :=> (Real (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Real a :- Real (Const a b) #
(Real a) :=> (Real (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Real a :- Real (Identity a) #
(Real a, Bits a, TypeNum n) => Real (OddWord a n)
Instance details Defined in Data.Word.Odd Methods toRational :: OddWord a n -> Rational #
HasResolution a => Real (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods toRational :: Fixed a -> Rational #
Class (Num a, Ord a) (Real a)
Instance details Defined in Data.Constraint Methods cls :: Real a :- (Num a, Ord a) #
Class (Real a, Enum a) (Integral a)
Instance details Defined in Data.Constraint Methods cls :: Integral a :- (Real a, Enum a) #
Class (Real a, Fractional a) (RealFrac a)
Instance details Defined in Data.Constraint Methods cls :: RealFrac a :- (Real a, Fractional a) #
Real a => Real (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational #
Real a => Real (Tagged s a)
Instance details Defined in Data.Tagged Methods toRational :: Tagged s a -> Rational #

class (Real a, Fractional a) => RealFrac a where #

Extracting components of fractions.

Minimal complete definition

properFraction

Methods

properFraction :: Integral b => a -> (b, a) #

The function properFraction takes a real fractional number x and returns a pair (n,f) such that x = n+f, and:

n is an integral number with the same sign as x; and
f is a fraction with the same type and sign as x, and with absolute value less than 1.

The default definitions of the ceiling, floor, truncate and round functions are in terms of properFraction.

truncate :: Integral b => a -> b #

truncate x returns the integer nearest x between zero and x

round :: Integral b => a -> b #

round x returns the nearest integer to x; the even integer if x is equidistant between two integers

ceiling :: Integral b => a -> b #

ceiling x returns the least integer not less than x

floor :: Integral b => a -> b #

floor x returns the greatest integer not greater than x

Instances

Instances details

RealFrac Scientific	WARNING: the methods of the `RealFrac` instance need to compute the magnitude `10^e`. If applied to a huge exponent this could take a long time. Even worse, when the destination type is unbounded (i.e. `Integer`) it could fill up all space and crash your program!
Instance details Defined in Data.Scientific Methods properFraction :: Integral b => Scientific -> (b, Scientific) # truncate :: Integral b => Scientific -> b # round :: Integral b => Scientific -> b # ceiling :: Integral b => Scientific -> b # floor :: Integral b => Scientific -> b #
RealFrac NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods properFraction :: Integral b => NominalDiffTime -> (b, NominalDiffTime) # truncate :: Integral b => NominalDiffTime -> b # round :: Integral b => NominalDiffTime -> b # ceiling :: Integral b => NominalDiffTime -> b # floor :: Integral b => NominalDiffTime -> b #
() :=> (RealFrac Double)
Instance details Defined in Data.Constraint Methods ins :: () :- RealFrac Double #
() :=> (RealFrac Float)
Instance details Defined in Data.Constraint Methods ins :: () :- RealFrac Float #
RealFrac a => RealFrac (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods properFraction :: Integral b => Identity a -> (b, Identity a) # truncate :: Integral b => Identity a -> b # round :: Integral b => Identity a -> b # ceiling :: Integral b => Identity a -> b # floor :: Integral b => Identity a -> b #
RealFrac a => RealFrac (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods properFraction :: Integral b => Down a -> (b, Down a) # truncate :: Integral b => Down a -> b # round :: Integral b => Down a -> b # ceiling :: Integral b => Down a -> b # floor :: Integral b => Down a -> b #
Integral a => RealFrac (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods properFraction :: Integral b => Ratio a -> (b, Ratio a) # truncate :: Integral b => Ratio a -> b # round :: Integral b => Ratio a -> b # ceiling :: Integral b => Ratio a -> b # floor :: Integral b => Ratio a -> b #
RealFrac a => RealFrac (Add a)
Instance details Defined in Data.Semiring Methods properFraction :: Integral b => Add a -> (b, Add a) # truncate :: Integral b => Add a -> b # round :: Integral b => Add a -> b # ceiling :: Integral b => Add a -> b # floor :: Integral b => Add a -> b #
RealFrac a => RealFrac (Mul a)
Instance details Defined in Data.Semiring Methods properFraction :: Integral b => Mul a -> (b, Mul a) # truncate :: Integral b => Mul a -> b # round :: Integral b => Mul a -> b # ceiling :: Integral b => Mul a -> b # floor :: Integral b => Mul a -> b #
RealFrac a => RealFrac (WrappedNum a)
Instance details Defined in Data.Semiring Methods properFraction :: Integral b => WrappedNum a -> (b, WrappedNum a) # truncate :: Integral b => WrappedNum a -> b # round :: Integral b => WrappedNum a -> b # ceiling :: Integral b => WrappedNum a -> b # floor :: Integral b => WrappedNum a -> b #
(RealFrac t, KnownSymbol s) => RealFrac (ElField '(s, t))
Instance details Defined in Data.Vinyl.Functor Methods properFraction :: Integral b => ElField '(s, t) -> (b, ElField '(s, t)) # truncate :: Integral b => ElField '(s, t) -> b # round :: Integral b => ElField '(s, t) -> b # ceiling :: Integral b => ElField '(s, t) -> b # floor :: Integral b => ElField '(s, t) -> b #
(Integral a) :=> (RealFrac (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- RealFrac (Ratio a) #
(RealFrac a) :=> (RealFrac (Const a b))
Instance details Defined in Data.Constraint Methods ins :: RealFrac a :- RealFrac (Const a b) #
(RealFrac a) :=> (RealFrac (Identity a))
Instance details Defined in Data.Constraint Methods ins :: RealFrac a :- RealFrac (Identity a) #
HasResolution a => RealFrac (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods properFraction :: Integral b => Fixed a -> (b, Fixed a) # truncate :: Integral b => Fixed a -> b # round :: Integral b => Fixed a -> b # ceiling :: Integral b => Fixed a -> b # floor :: Integral b => Fixed a -> b #
Class (Real a, Fractional a) (RealFrac a)
Instance details Defined in Data.Constraint Methods cls :: RealFrac a :- (Real a, Fractional a) #
Class (RealFrac a, Floating a) (RealFloat a)
Instance details Defined in Data.Constraint Methods cls :: RealFloat a :- (RealFrac a, Floating a) #
RealFrac a => RealFrac (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods properFraction :: Integral b0 => Const a b -> (b0, Const a b) # truncate :: Integral b0 => Const a b -> b0 # round :: Integral b0 => Const a b -> b0 # ceiling :: Integral b0 => Const a b -> b0 # floor :: Integral b0 => Const a b -> b0 #
RealFrac a => RealFrac (Tagged s a)
Instance details Defined in Data.Tagged Methods properFraction :: Integral b => Tagged s a -> (b, Tagged s a) # truncate :: Integral b => Tagged s a -> b # round :: Integral b => Tagged s a -> b # ceiling :: Integral b => Tagged s a -> b # floor :: Integral b => Tagged s a -> b #

class Show a #

Conversion of values to readable Strings.

Derived instances of Show have the following properties, which are compatible with derived instances of Read:

The result of show is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.
If the constructor is defined to be an infix operator, then showsPrec will produce infix applications of the constructor.
the representation will be enclosed in parentheses if the precedence of the top-level constructor in x is less than d (associativity is ignored). Thus, if d is 0 then the result is never surrounded in parentheses; if d is 11 it is always surrounded in parentheses, unless it is an atomic expression.
If the constructor is defined using record syntax, then show will produce the record-syntax form, with the fields given in the same order as the original declaration.

For example, given the declarations

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

the derived instance of Show is equivalent to

instance (Show a) => Show (Tree a) where

       showsPrec d (Leaf m) = showParen (d > app_prec) $
            showString "Leaf " . showsPrec (app_prec+1) m
         where app_prec = 10

       showsPrec d (u :^: v) = showParen (d > up_prec) $
            showsPrec (up_prec+1) u .
            showString " :^: "      .
            showsPrec (up_prec+1) v
         where up_prec = 5

Note that right-associativity of :^: is ignored. For example,

show (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".

Minimal complete definition

showsPrec | show

Instances

Instances details

Show CabalSpecVersion
Instance details Defined in Distribution.CabalSpecVersion Methods showsPrec :: Int -> CabalSpecVersion -> ShowS # show :: CabalSpecVersion -> String # showList :: [CabalSpecVersion] -> ShowS #
Show HasCommonStanzas
Instance details Defined in Distribution.CabalSpecVersion Methods showsPrec :: Int -> HasCommonStanzas -> ShowS # show :: HasCommonStanzas -> String # showList :: [HasCommonStanzas] -> ShowS #
Show HasElif
Instance details Defined in Distribution.CabalSpecVersion Methods showsPrec :: Int -> HasElif -> ShowS # show :: HasElif -> String # showList :: [HasElif] -> ShowS #
Show PError
Instance details Defined in Distribution.Parsec.Error Methods showsPrec :: Int -> PError -> ShowS # show :: PError -> String # showList :: [PError] -> ShowS #
Show Position
Instance details Defined in Distribution.Parsec.Position Methods showsPrec :: Int -> Position -> ShowS # show :: Position -> String # showList :: [Position] -> ShowS #
Show PWarnType
Instance details Defined in Distribution.Parsec.Warning Methods showsPrec :: Int -> PWarnType -> ShowS # show :: PWarnType -> String # showList :: [PWarnType] -> ShowS #
Show PWarning
Instance details Defined in Distribution.Parsec.Warning Methods showsPrec :: Int -> PWarning -> ShowS # show :: PWarning -> String # showList :: [PWarning] -> ShowS #
Show Structure
Instance details Defined in Distribution.Utils.Structured Methods showsPrec :: Int -> Structure -> ShowS # show :: Structure -> String # showList :: [Structure] -> ShowS #
Show Extension
Instance details Defined in Language.Haskell.Extension Methods showsPrec :: Int -> Extension -> ShowS # show :: Extension -> String # showList :: [Extension] -> ShowS #
Show KnownExtension
Instance details Defined in Language.Haskell.Extension Methods showsPrec :: Int -> KnownExtension -> ShowS # show :: KnownExtension -> String # showList :: [KnownExtension] -> ShowS #
Show Language
Instance details Defined in Language.Haskell.Extension Methods showsPrec :: Int -> Language -> ShowS # show :: Language -> String # showList :: [Language] -> ShowS #
Show DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> DotNetTime -> ShowS # show :: DotNetTime -> String # showList :: [DotNetTime] -> ShowS #
Show JSONPathElement
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> JSONPathElement -> ShowS # show :: JSONPathElement -> String # showList :: [JSONPathElement] -> ShowS #
Show Options
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Options -> ShowS # show :: Options -> String # showList :: [Options] -> ShowS #
Show SumEncoding
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> SumEncoding -> ShowS # show :: SumEncoding -> String # showList :: [SumEncoding] -> ShowS #
Show Value	Since version 1.5.6.0 version object values are printed in lexicographic key order `>>>` `toJSON $ H.fromList [("a", True), ("z", False)]`Object (fromList [("a",Bool True),("z",Bool False)]) `>>>` `toJSON $ H.fromList [("z", False), ("a", True)]`Object (fromList [("a",Bool True),("z",Bool False)])
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Value -> ShowS # show :: Value -> String # showList :: [Value] -> ShowS #
Show More
Instance details Defined in Data.Attoparsec.Internal.Types Methods showsPrec :: Int -> More -> ShowS # show :: More -> String # showList :: [More] -> ShowS #
Show Pos
Instance details Defined in Data.Attoparsec.Internal.Types Methods showsPrec :: Int -> Pos -> ShowS # show :: Pos -> String # showList :: [Pos] -> ShowS #
Show All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> All -> ShowS # show :: All -> String # showList :: [All] -> ShowS #
Show Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Any -> ShowS # show :: Any -> String # showList :: [Any] -> ShowS #
Show SomeTypeRep	Since: base-4.10.0.0
Instance details Defined in Data.Typeable.Internal Methods showsPrec :: Int -> SomeTypeRep -> ShowS # show :: SomeTypeRep -> String # showList :: [SomeTypeRep] -> ShowS #
Show Version	Since: base-2.1
Instance details Defined in Data.Version Methods showsPrec :: Int -> Version -> ShowS # show :: Version -> String # showList :: [Version] -> ShowS #
Show Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods showsPrec :: Int -> Void -> ShowS # show :: Void -> String # showList :: [Void] -> ShowS #
Show BlockReason	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods showsPrec :: Int -> BlockReason -> ShowS # show :: BlockReason -> String # showList :: [BlockReason] -> ShowS #
Show ThreadId	Since: base-4.2.0.0
Instance details Defined in GHC.Conc.Sync Methods showsPrec :: Int -> ThreadId -> ShowS # show :: ThreadId -> String # showList :: [ThreadId] -> ShowS #
Show ThreadStatus	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods showsPrec :: Int -> ThreadStatus -> ShowS # show :: ThreadStatus -> String # showList :: [ThreadStatus] -> ShowS #
Show ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods showsPrec :: Int -> ErrorCall -> ShowS # show :: ErrorCall -> String # showList :: [ErrorCall] -> ShowS #
Show ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> ArithException -> ShowS # show :: ArithException -> String # showList :: [ArithException] -> ShowS #
Show SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #
Show Fingerprint	Since: base-4.7.0.0
Instance details Defined in GHC.Fingerprint.Type Methods showsPrec :: Int -> Fingerprint -> ShowS # show :: Fingerprint -> String # showList :: [Fingerprint] -> ShowS #
Show Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Associativity -> ShowS # show :: Associativity -> String # showList :: [Associativity] -> ShowS #
Show DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Show Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Show SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Show MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS #
Show AllocationLimitExceeded	Since: base-4.7.1.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AllocationLimitExceeded -> ShowS # show :: AllocationLimitExceeded -> String # showList :: [AllocationLimitExceeded] -> ShowS #
Show ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ArrayException -> ShowS # show :: ArrayException -> String # showList :: [ArrayException] -> ShowS #
Show AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AssertionFailed -> ShowS # show :: AssertionFailed -> String # showList :: [AssertionFailed] -> ShowS #
Show AsyncException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AsyncException -> ShowS # show :: AsyncException -> String # showList :: [AsyncException] -> ShowS #
Show BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS # show :: BlockedIndefinitelyOnMVar -> String # showList :: [BlockedIndefinitelyOnMVar] -> ShowS #
Show BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS # show :: BlockedIndefinitelyOnSTM -> String # showList :: [BlockedIndefinitelyOnSTM] -> ShowS #
Show CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> CompactionFailed -> ShowS # show :: CompactionFailed -> String # showList :: [CompactionFailed] -> ShowS #
Show Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> Deadlock -> ShowS # show :: Deadlock -> String # showList :: [Deadlock] -> ShowS #
Show ExitCode
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ExitCode -> ShowS # show :: ExitCode -> String # showList :: [ExitCode] -> ShowS #
Show FixIOException	Since: base-4.11.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> FixIOException -> ShowS # show :: FixIOException -> String # showList :: [FixIOException] -> ShowS #
Show IOErrorType	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> IOErrorType -> ShowS # show :: IOErrorType -> String # showList :: [IOErrorType] -> ShowS #
Show IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> IOException -> ShowS # show :: IOException -> String # showList :: [IOException] -> ShowS #
Show SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> SomeAsyncException -> ShowS # show :: SomeAsyncException -> String # showList :: [SomeAsyncException] -> ShowS #
Show BufferMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> BufferMode -> ShowS # show :: BufferMode -> String # showList :: [BufferMode] -> ShowS #
Show Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> Handle -> ShowS # show :: Handle -> String # showList :: [Handle] -> ShowS #
Show HandleType	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> HandleType -> ShowS # show :: HandleType -> String # showList :: [HandleType] -> ShowS #
Show Newline	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> Newline -> ShowS # show :: Newline -> String # showList :: [Newline] -> ShowS #
Show NewlineMode	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> NewlineMode -> ShowS # show :: NewlineMode -> String # showList :: [NewlineMode] -> ShowS #
Show IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods showsPrec :: Int -> IOMode -> ShowS # show :: IOMode -> String # showList :: [IOMode] -> ShowS #
Show Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
Show Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Show Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Show Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
Show CCFlags	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> CCFlags -> ShowS # show :: CCFlags -> String # showList :: [CCFlags] -> ShowS #
Show ConcFlags	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> ConcFlags -> ShowS # show :: ConcFlags -> String # showList :: [ConcFlags] -> ShowS #
Show DebugFlags	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> DebugFlags -> ShowS # show :: DebugFlags -> String # showList :: [DebugFlags] -> ShowS #
Show DoCostCentres	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> DoCostCentres -> ShowS # show :: DoCostCentres -> String # showList :: [DoCostCentres] -> ShowS #
Show DoHeapProfile	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> DoHeapProfile -> ShowS # show :: DoHeapProfile -> String # showList :: [DoHeapProfile] -> ShowS #
Show DoTrace	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> DoTrace -> ShowS # show :: DoTrace -> String # showList :: [DoTrace] -> ShowS #
Show GCFlags	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> GCFlags -> ShowS # show :: GCFlags -> String # showList :: [GCFlags] -> ShowS #
Show GiveGCStats	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> GiveGCStats -> ShowS # show :: GiveGCStats -> String # showList :: [GiveGCStats] -> ShowS #
Show IoSubSystem
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> IoSubSystem -> ShowS # show :: IoSubSystem -> String # showList :: [IoSubSystem] -> ShowS #
Show MiscFlags	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> MiscFlags -> ShowS # show :: MiscFlags -> String # showList :: [MiscFlags] -> ShowS #
Show ParFlags	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> ParFlags -> ShowS # show :: ParFlags -> String # showList :: [ParFlags] -> ShowS #
Show ProfFlags	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> ProfFlags -> ShowS # show :: ProfFlags -> String # showList :: [ProfFlags] -> ShowS #
Show RTSFlags	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> RTSFlags -> ShowS # show :: RTSFlags -> String # showList :: [RTSFlags] -> ShowS #
Show TickyFlags	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> TickyFlags -> ShowS # show :: TickyFlags -> String # showList :: [TickyFlags] -> ShowS #
Show TraceFlags	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods showsPrec :: Int -> TraceFlags -> ShowS # show :: TraceFlags -> String # showList :: [TraceFlags] -> ShowS #
Show CallStack	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> CallStack -> ShowS # show :: CallStack -> String # showList :: [CallStack] -> ShowS #
Show SrcLoc	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #
Show GCDetails	Since: base-4.10.0.0
Instance details Defined in GHC.Stats Methods showsPrec :: Int -> GCDetails -> ShowS # show :: GCDetails -> String # showList :: [GCDetails] -> ShowS #
Show RTSStats	Since: base-4.10.0.0
Instance details Defined in GHC.Stats Methods showsPrec :: Int -> RTSStats -> ShowS # show :: RTSStats -> String # showList :: [RTSStats] -> ShowS #
Show SomeSymbol	Since: base-4.7.0.0
Instance details Defined in GHC.TypeLits Methods showsPrec :: Int -> SomeSymbol -> ShowS # show :: SomeSymbol -> String # showList :: [SomeSymbol] -> ShowS #
Show SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods showsPrec :: Int -> SomeNat -> ShowS # show :: SomeNat -> String # showList :: [SomeNat] -> ShowS #
Show GeneralCategory	Since: base-2.1
Instance details Defined in GHC.Unicode Methods showsPrec :: Int -> GeneralCategory -> ShowS # show :: GeneralCategory -> String # showList :: [GeneralCategory] -> ShowS #
Show Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Show Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Show Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Show Alphabet
Instance details Defined in Data.ByteString.Base58.Internal Methods showsPrec :: Int -> Alphabet -> ShowS # show :: Alphabet -> String # showList :: [Alphabet] -> ShowS #
Show Encoding
Instance details Defined in Basement.String Methods showsPrec :: Int -> Encoding -> ShowS # show :: Encoding -> String # showList :: [Encoding] -> ShowS #
Show ASCII7_Invalid
Instance details Defined in Basement.String.Encoding.ASCII7 Methods showsPrec :: Int -> ASCII7_Invalid -> ShowS # show :: ASCII7_Invalid -> String # showList :: [ASCII7_Invalid] -> ShowS #
Show ISO_8859_1_Invalid
Instance details Defined in Basement.String.Encoding.ISO_8859_1 Methods showsPrec :: Int -> ISO_8859_1_Invalid -> ShowS # show :: ISO_8859_1_Invalid -> String # showList :: [ISO_8859_1_Invalid] -> ShowS #
Show UTF16_Invalid
Instance details Defined in Basement.String.Encoding.UTF16 Methods showsPrec :: Int -> UTF16_Invalid -> ShowS # show :: UTF16_Invalid -> String # showList :: [UTF16_Invalid] -> ShowS #
Show UTF32_Invalid
Instance details Defined in Basement.String.Encoding.UTF32 Methods showsPrec :: Int -> UTF32_Invalid -> ShowS # show :: UTF32_Invalid -> String # showList :: [UTF32_Invalid] -> ShowS #
Show AsciiString
Instance details Defined in Basement.Types.AsciiString Methods showsPrec :: Int -> AsciiString -> ShowS # show :: AsciiString -> String # showList :: [AsciiString] -> ShowS #
Show FileSize
Instance details Defined in Basement.Types.OffsetSize Methods showsPrec :: Int -> FileSize -> ShowS # show :: FileSize -> String # showList :: [FileSize] -> ShowS #
Show String
Instance details Defined in Basement.UTF8.Base Methods showsPrec :: Int -> String -> ShowS # show :: String -> String0 # showList :: [String] -> ShowS #
Show BimapException
Instance details Defined in Data.Bimap Methods showsPrec :: Int -> BimapException -> ShowS # show :: BimapException -> String # showList :: [BimapException] -> ShowS #
Show F2Poly
Instance details Defined in Data.Bit.F2Poly Methods showsPrec :: Int -> F2Poly -> ShowS # show :: F2Poly -> String # showList :: [F2Poly] -> ShowS #
Show Bit
Instance details Defined in Data.Bit.Internal Methods showsPrec :: Int -> Bit -> ShowS # show :: Bit -> String # showList :: [Bit] -> ShowS #
Show WithInternals
Instance details Defined in Data.Bit.Internal Methods showsPrec :: Int -> WithInternals -> ShowS # show :: WithInternals -> String # showList :: [WithInternals] -> ShowS #
Show ByteString
Instance details Defined in Data.ByteString.Internal Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
Show ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
Show ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods showsPrec :: Int -> ShortByteString -> ShowS # show :: ShortByteString -> String # showList :: [ShortByteString] -> ShowS #
Show Clock
Instance details Defined in System.Clock Methods showsPrec :: Int -> Clock -> ShowS # show :: Clock -> String # showList :: [Clock] -> ShowS #
Show TimeSpec
Instance details Defined in System.Clock Methods showsPrec :: Int -> TimeSpec -> ShowS # show :: TimeSpec -> String # showList :: [TimeSpec] -> ShowS #
Show IntSet
Instance details Defined in Data.IntSet.Internal Methods showsPrec :: Int -> IntSet -> ShowS # show :: IntSet -> String # showList :: [IntSet] -> ShowS #
Show Relation
Instance details Defined in Data.IntSet.Internal Methods showsPrec :: Int -> Relation -> ShowS # show :: Relation -> String # showList :: [Relation] -> ShowS #
Show CryptoError
Instance details Defined in Crypto.Error.Types Methods showsPrec :: Int -> CryptoError -> ShowS # show :: CryptoError -> String # showList :: [CryptoError] -> ShowS #
Show Blake2b_160
Instance details Defined in Crypto.Hash.Blake2b Methods showsPrec :: Int -> Blake2b_160 -> ShowS # show :: Blake2b_160 -> String # showList :: [Blake2b_160] -> ShowS #
Show Blake2b_224
Instance details Defined in Crypto.Hash.Blake2b Methods showsPrec :: Int -> Blake2b_224 -> ShowS # show :: Blake2b_224 -> String # showList :: [Blake2b_224] -> ShowS #
Show Blake2b_256
Instance details Defined in Crypto.Hash.Blake2b Methods showsPrec :: Int -> Blake2b_256 -> ShowS # show :: Blake2b_256 -> String # showList :: [Blake2b_256] -> ShowS #
Show Blake2b_384
Instance details Defined in Crypto.Hash.Blake2b Methods showsPrec :: Int -> Blake2b_384 -> ShowS # show :: Blake2b_384 -> String # showList :: [Blake2b_384] -> ShowS #
Show Blake2b_512
Instance details Defined in Crypto.Hash.Blake2b Methods showsPrec :: Int -> Blake2b_512 -> ShowS # show :: Blake2b_512 -> String # showList :: [Blake2b_512] -> ShowS #
Show Blake2bp_512
Instance details Defined in Crypto.Hash.Blake2bp Methods showsPrec :: Int -> Blake2bp_512 -> ShowS # show :: Blake2bp_512 -> String # showList :: [Blake2bp_512] -> ShowS #
Show Blake2s_160
Instance details Defined in Crypto.Hash.Blake2s Methods showsPrec :: Int -> Blake2s_160 -> ShowS # show :: Blake2s_160 -> String # showList :: [Blake2s_160] -> ShowS #
Show Blake2s_224
Instance details Defined in Crypto.Hash.Blake2s Methods showsPrec :: Int -> Blake2s_224 -> ShowS # show :: Blake2s_224 -> String # showList :: [Blake2s_224] -> ShowS #
Show Blake2s_256
Instance details Defined in Crypto.Hash.Blake2s Methods showsPrec :: Int -> Blake2s_256 -> ShowS # show :: Blake2s_256 -> String # showList :: [Blake2s_256] -> ShowS #
Show Blake2sp_224
Instance details Defined in Crypto.Hash.Blake2sp Methods showsPrec :: Int -> Blake2sp_224 -> ShowS # show :: Blake2sp_224 -> String # showList :: [Blake2sp_224] -> ShowS #
Show Blake2sp_256
Instance details Defined in Crypto.Hash.Blake2sp Methods showsPrec :: Int -> Blake2sp_256 -> ShowS # show :: Blake2sp_256 -> String # showList :: [Blake2sp_256] -> ShowS #
Show Keccak_224
Instance details Defined in Crypto.Hash.Keccak Methods showsPrec :: Int -> Keccak_224 -> ShowS # show :: Keccak_224 -> String # showList :: [Keccak_224] -> ShowS #
Show Keccak_256
Instance details Defined in Crypto.Hash.Keccak Methods showsPrec :: Int -> Keccak_256 -> ShowS # show :: Keccak_256 -> String # showList :: [Keccak_256] -> ShowS #
Show Keccak_384
Instance details Defined in Crypto.Hash.Keccak Methods showsPrec :: Int -> Keccak_384 -> ShowS # show :: Keccak_384 -> String # showList :: [Keccak_384] -> ShowS #
Show Keccak_512
Instance details Defined in Crypto.Hash.Keccak Methods showsPrec :: Int -> Keccak_512 -> ShowS # show :: Keccak_512 -> String # showList :: [Keccak_512] -> ShowS #
Show MD2
Instance details Defined in Crypto.Hash.MD2 Methods showsPrec :: Int -> MD2 -> ShowS # show :: MD2 -> String # showList :: [MD2] -> ShowS #
Show MD4
Instance details Defined in Crypto.Hash.MD4 Methods showsPrec :: Int -> MD4 -> ShowS # show :: MD4 -> String # showList :: [MD4] -> ShowS #
Show MD5
Instance details Defined in Crypto.Hash.MD5 Methods showsPrec :: Int -> MD5 -> ShowS # show :: MD5 -> String # showList :: [MD5] -> ShowS #
Show RIPEMD160
Instance details Defined in Crypto.Hash.RIPEMD160 Methods showsPrec :: Int -> RIPEMD160 -> ShowS # show :: RIPEMD160 -> String # showList :: [RIPEMD160] -> ShowS #
Show SHA1
Instance details Defined in Crypto.Hash.SHA1 Methods showsPrec :: Int -> SHA1 -> ShowS # show :: SHA1 -> String # showList :: [SHA1] -> ShowS #
Show SHA224
Instance details Defined in Crypto.Hash.SHA224 Methods showsPrec :: Int -> SHA224 -> ShowS # show :: SHA224 -> String # showList :: [SHA224] -> ShowS #
Show SHA256
Instance details Defined in Crypto.Hash.SHA256 Methods showsPrec :: Int -> SHA256 -> ShowS # show :: SHA256 -> String # showList :: [SHA256] -> ShowS #
Show SHA3_224
Instance details Defined in Crypto.Hash.SHA3 Methods showsPrec :: Int -> SHA3_224 -> ShowS # show :: SHA3_224 -> String # showList :: [SHA3_224] -> ShowS #
Show SHA3_256
Instance details Defined in Crypto.Hash.SHA3 Methods showsPrec :: Int -> SHA3_256 -> ShowS # show :: SHA3_256 -> String # showList :: [SHA3_256] -> ShowS #
Show SHA3_384
Instance details Defined in Crypto.Hash.SHA3 Methods showsPrec :: Int -> SHA3_384 -> ShowS # show :: SHA3_384 -> String # showList :: [SHA3_384] -> ShowS #
Show SHA3_512
Instance details Defined in Crypto.Hash.SHA3 Methods showsPrec :: Int -> SHA3_512 -> ShowS # show :: SHA3_512 -> String # showList :: [SHA3_512] -> ShowS #
Show SHA384
Instance details Defined in Crypto.Hash.SHA384 Methods showsPrec :: Int -> SHA384 -> ShowS # show :: SHA384 -> String # showList :: [SHA384] -> ShowS #
Show SHA512
Instance details Defined in Crypto.Hash.SHA512 Methods showsPrec :: Int -> SHA512 -> ShowS # show :: SHA512 -> String # showList :: [SHA512] -> ShowS #
Show SHA512t_224
Instance details Defined in Crypto.Hash.SHA512t Methods showsPrec :: Int -> SHA512t_224 -> ShowS # show :: SHA512t_224 -> String # showList :: [SHA512t_224] -> ShowS #
Show SHA512t_256
Instance details Defined in Crypto.Hash.SHA512t Methods showsPrec :: Int -> SHA512t_256 -> ShowS # show :: SHA512t_256 -> String # showList :: [SHA512t_256] -> ShowS #
Show Skein256_224
Instance details Defined in Crypto.Hash.Skein256 Methods showsPrec :: Int -> Skein256_224 -> ShowS # show :: Skein256_224 -> String # showList :: [Skein256_224] -> ShowS #
Show Skein256_256
Instance details Defined in Crypto.Hash.Skein256 Methods showsPrec :: Int -> Skein256_256 -> ShowS # show :: Skein256_256 -> String # showList :: [Skein256_256] -> ShowS #
Show Skein512_224
Instance details Defined in Crypto.Hash.Skein512 Methods showsPrec :: Int -> Skein512_224 -> ShowS # show :: Skein512_224 -> String # showList :: [Skein512_224] -> ShowS #
Show Skein512_256
Instance details Defined in Crypto.Hash.Skein512 Methods showsPrec :: Int -> Skein512_256 -> ShowS # show :: Skein512_256 -> String # showList :: [Skein512_256] -> ShowS #
Show Skein512_384
Instance details Defined in Crypto.Hash.Skein512 Methods showsPrec :: Int -> Skein512_384 -> ShowS # show :: Skein512_384 -> String # showList :: [Skein512_384] -> ShowS #
Show Skein512_512
Instance details Defined in Crypto.Hash.Skein512 Methods showsPrec :: Int -> Skein512_512 -> ShowS # show :: Skein512_512 -> String # showList :: [Skein512_512] -> ShowS #
Show Tiger
Instance details Defined in Crypto.Hash.Tiger Methods showsPrec :: Int -> Tiger -> ShowS # show :: Tiger -> String # showList :: [Tiger] -> ShowS #
Show Whirlpool
Instance details Defined in Crypto.Hash.Whirlpool Methods showsPrec :: Int -> Whirlpool -> ShowS # show :: Whirlpool -> String # showList :: [Whirlpool] -> ShowS #
Show KeyPair
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods showsPrec :: Int -> KeyPair -> ShowS # show :: KeyPair -> String # showList :: [KeyPair] -> ShowS #
Show PrivateKey
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods showsPrec :: Int -> PrivateKey -> ShowS # show :: PrivateKey -> String # showList :: [PrivateKey] -> ShowS #
Show PublicKey
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods showsPrec :: Int -> PublicKey -> ShowS # show :: PublicKey -> String # showList :: [PublicKey] -> ShowS #
Show Signature
Instance details Defined in Crypto.PubKey.ECC.ECDSA Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
Show PublicKey
Instance details Defined in Crypto.PubKey.Ed25519 Methods showsPrec :: Int -> PublicKey -> ShowS # show :: PublicKey -> String # showList :: [PublicKey] -> ShowS #
Show SecretKey
Instance details Defined in Crypto.PubKey.Ed25519 Methods showsPrec :: Int -> SecretKey -> ShowS # show :: SecretKey -> String # showList :: [SecretKey] -> ShowS #
Show Signature
Instance details Defined in Crypto.PubKey.Ed25519 Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
Show ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Methods showsPrec :: Int -> ForeignSrcLang -> ShowS # show :: ForeignSrcLang -> String # showList :: [ForeignSrcLang] -> ShowS #
Show Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods showsPrec :: Int -> Extension -> ShowS # show :: Extension -> String # showList :: [Extension] -> ShowS #
Show KindRep
Instance details Defined in GHC.Show Methods showsPrec :: Int -> KindRep -> ShowS # show :: KindRep -> String # showList :: [KindRep] -> ShowS #
Show Module	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show Ordering	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Show TrName	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TrName -> ShowS # show :: TrName -> String # showList :: [TrName] -> ShowS #
Show TyCon	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TyCon -> ShowS # show :: TyCon -> String # showList :: [TyCon] -> ShowS #
Show TypeLitSort	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TypeLitSort -> ShowS # show :: TypeLitSort -> String # showList :: [TypeLitSort] -> ShowS #
Show BlstError
Instance details Defined in Crypto.BLST.Internal.Bindings Methods showsPrec :: Int -> BlstError -> ShowS # show :: BlstError -> String # showList :: [BlstError] -> ShowS #
Show EncodeMethod
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods showsPrec :: Int -> EncodeMethod -> ShowS # show :: EncodeMethod -> String # showList :: [EncodeMethod] -> ShowS #
Show Scalar
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods showsPrec :: Int -> Scalar -> ShowS # show :: Scalar -> String # showList :: [Scalar] -> ShowS #
Show SecretKey
Instance details Defined in Crypto.BLST.Internal.Types Methods showsPrec :: Int -> SecretKey -> ShowS # show :: SecretKey -> String # showList :: [SecretKey] -> ShowS #
Show RefId Source #
Instance details Defined in Indigo.Common.Var Methods showsPrec :: Int -> RefId -> ShowS # show :: RefId -> String # showList :: [RefId] -> ShowS #
Show CommentSettings Source #
Instance details Defined in Indigo.Compilation.Hooks Methods showsPrec :: Int -> CommentSettings -> ShowS # show :: CommentSettings -> String # showList :: [CommentSettings] -> ShowS #
Show CommentsVerbosity Source #
Instance details Defined in Indigo.Compilation.Hooks Methods showsPrec :: Int -> CommentsVerbosity -> ShowS # show :: CommentsVerbosity -> String # showList :: [CommentsVerbosity] -> ShowS #
Show ParseLorentzError
Instance details Defined in Lorentz.Base Methods showsPrec :: Int -> ParseLorentzError -> ShowS # show :: ParseLorentzError -> String # showList :: [ParseLorentzError] -> ShowS #
Show EpCallingStep
Instance details Defined in Lorentz.Entrypoints.Core Methods showsPrec :: Int -> EpCallingStep -> ShowS # show :: EpCallingStep -> String # showList :: [EpCallingStep] -> ShowS #
Show EntrypointLookupError
Instance details Defined in Lorentz.UParam Methods showsPrec :: Int -> EntrypointLookupError -> ShowS # show :: EntrypointLookupError -> String # showList :: [EntrypointLookupError] -> ShowS #
Show Never
Instance details Defined in Lorentz.Value Methods showsPrec :: Int -> Never -> ShowS # show :: Never -> String # showList :: [Never] -> ShowS #
Show OpenChest
Instance details Defined in Lorentz.Value Methods showsPrec :: Int -> OpenChest -> ShowS # show :: OpenChest -> String # showList :: [OpenChest] -> ShowS #
Show ViewInterfaceMatchError
Instance details Defined in Lorentz.ViewBase Methods showsPrec :: Int -> ViewInterfaceMatchError -> ShowS # show :: ViewInterfaceMatchError -> String # showList :: [ViewInterfaceMatchError] -> ShowS #
Show ZSNil
Instance details Defined in Lorentz.Zip Methods showsPrec :: Int -> ZSNil -> ShowS # show :: ZSNil -> String # showList :: [ZSNil] -> ShowS #
Show InvalidPosException
Instance details Defined in Text.Megaparsec.Pos Methods showsPrec :: Int -> InvalidPosException -> ShowS # show :: InvalidPosException -> String # showList :: [InvalidPosException] -> ShowS #
Show Pos
Instance details Defined in Text.Megaparsec.Pos Methods showsPrec :: Int -> Pos -> ShowS # show :: Pos -> String # showList :: [Pos] -> ShowS #
Show SourcePos
Instance details Defined in Text.Megaparsec.Pos Methods showsPrec :: Int -> SourcePos -> ShowS # show :: SourcePos -> String # showList :: [SourcePos] -> ShowS #
Show DefName
Instance details Defined in Lens.Micro.TH Methods showsPrec :: Int -> DefName -> ShowS # show :: DefName -> String # showList :: [DefName] -> ShowS #
Show Annotation
Instance details Defined in Morley.Micheline.Expression Methods showsPrec :: Int -> Annotation -> ShowS # show :: Annotation -> String # showList :: [Annotation] -> ShowS #
Show MichelinePrimitive
Instance details Defined in Morley.Micheline.Expression Methods showsPrec :: Int -> MichelinePrimitive -> ShowS # show :: MichelinePrimitive -> String # showList :: [MichelinePrimitive] -> ShowS #
Show TezosMutez
Instance details Defined in Morley.Micheline.Json Methods showsPrec :: Int -> TezosMutez -> ShowS # show :: TezosMutez -> String # showList :: [TezosMutez] -> ShowS #
Show AnalyzerRes
Instance details Defined in Morley.Michelson.Analyzer Methods showsPrec :: Int -> AnalyzerRes -> ShowS # show :: AnalyzerRes -> String # showList :: [AnalyzerRes] -> ShowS #
Show DocGrouping	To automatically derive `instance Show Morley.Michelson.Typed.Instr` later.
Instance details Defined in Morley.Michelson.Doc Methods showsPrec :: Int -> DocGrouping -> ShowS # show :: DocGrouping -> String # showList :: [DocGrouping] -> ShowS #
Show DocItemId
Instance details Defined in Morley.Michelson.Doc Methods showsPrec :: Int -> DocItemId -> ShowS # show :: DocItemId -> String # showList :: [DocItemId] -> ShowS #
Show DocItemPos
Instance details Defined in Morley.Michelson.Doc Methods showsPrec :: Int -> DocItemPos -> ShowS # show :: DocItemPos -> String # showList :: [DocItemPos] -> ShowS #
Show SomeDocItem	To automatically derive `instance Show Morley.Michelson.Typed.Instr` later.
Instance details Defined in Morley.Michelson.Doc Methods showsPrec :: Int -> SomeDocItem -> ShowS # show :: SomeDocItem -> String # showList :: [SomeDocItem] -> ShowS #
Show ErrorSrcPos
Instance details Defined in Morley.Michelson.ErrorPos Methods showsPrec :: Int -> ErrorSrcPos -> ShowS # show :: ErrorSrcPos -> String # showList :: [ErrorSrcPos] -> ShowS #
Show Pos
Instance details Defined in Morley.Michelson.ErrorPos Methods showsPrec :: Int -> Pos -> ShowS # show :: Pos -> String # showList :: [Pos] -> ShowS #
Show SrcPos
Instance details Defined in Morley.Michelson.ErrorPos Methods showsPrec :: Int -> SrcPos -> ShowS # show :: SrcPos -> String # showList :: [SrcPos] -> ShowS #
Show BadViewNameError
Instance details Defined in Morley.Michelson.Internal.ViewName Methods showsPrec :: Int -> BadViewNameError -> ShowS # show :: BadViewNameError -> String # showList :: [BadViewNameError] -> ShowS #
Show ViewName
Instance details Defined in Morley.Michelson.Internal.ViewName Methods showsPrec :: Int -> ViewName -> ShowS # show :: ViewName -> String # showList :: [ViewName] -> ShowS #
Show ViewsSetError
Instance details Defined in Morley.Michelson.Internal.ViewsSet Methods showsPrec :: Int -> ViewsSetError -> ShowS # show :: ViewsSetError -> String # showList :: [ViewsSetError] -> ShowS #
Show InterpreterState
Instance details Defined in Morley.Michelson.Interpret Methods showsPrec :: Int -> InterpreterState -> ShowS # show :: InterpreterState -> String # showList :: [InterpreterState] -> ShowS #
Show MorleyLogs
Instance details Defined in Morley.Michelson.Interpret Methods showsPrec :: Int -> MorleyLogs -> ShowS # show :: MorleyLogs -> String # showList :: [MorleyLogs] -> ShowS #
Show RemainingSteps
Instance details Defined in Morley.Michelson.Interpret Methods showsPrec :: Int -> RemainingSteps -> ShowS # show :: RemainingSteps -> String # showList :: [RemainingSteps] -> ShowS #
Show ViewLookupError
Instance details Defined in Morley.Michelson.Interpret Methods showsPrec :: Int -> ViewLookupError -> ShowS # show :: ViewLookupError -> String # showList :: [ViewLookupError] -> ShowS #
Show CadrStruct
Instance details Defined in Morley.Michelson.Macro Methods showsPrec :: Int -> CadrStruct -> ShowS # show :: CadrStruct -> String # showList :: [CadrStruct] -> ShowS #
Show Macro
Instance details Defined in Morley.Michelson.Macro Methods showsPrec :: Int -> Macro -> ShowS # show :: Macro -> String # showList :: [Macro] -> ShowS #
Show PairStruct
Instance details Defined in Morley.Michelson.Macro Methods showsPrec :: Int -> PairStruct -> ShowS # show :: PairStruct -> String # showList :: [PairStruct] -> ShowS #
Show ParsedOp
Instance details Defined in Morley.Michelson.Macro Methods showsPrec :: Int -> ParsedOp -> ShowS # show :: ParsedOp -> String # showList :: [ParsedOp] -> ShowS #
Show UnpairStruct
Instance details Defined in Morley.Michelson.Macro Methods showsPrec :: Int -> UnpairStruct -> ShowS # show :: UnpairStruct -> String # showList :: [UnpairStruct] -> ShowS #
Show CustomParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods showsPrec :: Int -> CustomParserException -> ShowS # show :: CustomParserException -> String # showList :: [CustomParserException] -> ShowS #
Show ParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods showsPrec :: Int -> ParserException -> ShowS # show :: ParserException -> String # showList :: [ParserException] -> ShowS #
Show StringLiteralParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods showsPrec :: Int -> StringLiteralParserException -> ShowS # show :: StringLiteralParserException -> String # showList :: [StringLiteralParserException] -> ShowS #
Show MichelsonSource
Instance details Defined in Morley.Michelson.Parser.Types Methods showsPrec :: Int -> MichelsonSource -> ShowS # show :: MichelsonSource -> String # showList :: [MichelsonSource] -> ShowS #
Show ParserOptions
Instance details Defined in Morley.Michelson.Parser.Types Methods showsPrec :: Int -> ParserOptions -> ShowS # show :: ParserOptions -> String # showList :: [ParserOptions] -> ShowS #
Show BigMapCounter
Instance details Defined in Morley.Michelson.Runtime.GState Methods showsPrec :: Int -> BigMapCounter -> ShowS # show :: BigMapCounter -> String # showList :: [BigMapCounter] -> ShowS #
Show ContractState
Instance details Defined in Morley.Michelson.Runtime.GState Methods showsPrec :: Int -> ContractState -> ShowS # show :: ContractState -> String # showList :: [ContractState] -> ShowS #
Show GState
Instance details Defined in Morley.Michelson.Runtime.GState Methods showsPrec :: Int -> GState -> ShowS # show :: GState -> String # showList :: [GState] -> ShowS #
Show GStateParseError
Instance details Defined in Morley.Michelson.Runtime.GState Methods showsPrec :: Int -> GStateParseError -> ShowS # show :: GStateParseError -> String # showList :: [GStateParseError] -> ShowS #
Show GStateUpdate
Instance details Defined in Morley.Michelson.Runtime.GState Methods showsPrec :: Int -> GStateUpdate -> ShowS # show :: GStateUpdate -> String # showList :: [GStateUpdate] -> ShowS #
Show GStateUpdateError
Instance details Defined in Morley.Michelson.Runtime.GState Methods showsPrec :: Int -> GStateUpdateError -> ShowS # show :: GStateUpdateError -> String # showList :: [GStateUpdateError] -> ShowS #
Show ImplicitState
Instance details Defined in Morley.Michelson.Runtime.GState Methods showsPrec :: Int -> ImplicitState -> ShowS # show :: ImplicitState -> String # showList :: [ImplicitState] -> ShowS #
Show TicketKey
Instance details Defined in Morley.Michelson.Runtime.GState Methods showsPrec :: Int -> TicketKey -> ShowS # show :: TicketKey -> String # showList :: [TicketKey] -> ShowS #
Show VotingPowers
Instance details Defined in Morley.Michelson.Runtime.GState Methods showsPrec :: Int -> VotingPowers -> ShowS # show :: VotingPowers -> String # showList :: [VotingPowers] -> ShowS #
Show MText
Instance details Defined in Morley.Michelson.Text Methods showsPrec :: Int -> MText -> ShowS # show :: MText -> String # showList :: [MText] -> ShowS #
Show ExtError
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods showsPrec :: Int -> ExtError -> ShowS # show :: ExtError -> String # showList :: [ExtError] -> ShowS #
Show StackSize
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods showsPrec :: Int -> StackSize -> ShowS # show :: StackSize -> String # showList :: [StackSize] -> ShowS #
Show TcTypeError
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods showsPrec :: Int -> TcTypeError -> ShowS # show :: TcTypeError -> String # showList :: [TcTypeError] -> ShowS #
Show TopLevelType
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods showsPrec :: Int -> TopLevelType -> ShowS # show :: TopLevelType -> String # showList :: [TopLevelType] -> ShowS #
Show TypeContext
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods showsPrec :: Int -> TypeContext -> ShowS # show :: TypeContext -> String # showList :: [TypeContext] -> ShowS #
Show SomeHST
Instance details Defined in Morley.Michelson.TypeCheck.Types Methods showsPrec :: Int -> SomeHST -> ShowS # show :: SomeHST -> String # showList :: [SomeHST] -> ShowS #
Show MutezArithErrorType
Instance details Defined in Morley.Michelson.Typed.Arith Methods showsPrec :: Int -> MutezArithErrorType -> ShowS # show :: MutezArithErrorType -> String # showList :: [MutezArithErrorType] -> ShowS #
Show ShiftArithErrorType
Instance details Defined in Morley.Michelson.Typed.Arith Methods showsPrec :: Int -> ShiftArithErrorType -> ShowS # show :: ShiftArithErrorType -> String # showList :: [ShiftArithErrorType] -> ShowS #
Show FailureType
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods showsPrec :: Int -> FailureType -> ShowS # show :: FailureType -> String # showList :: [FailureType] -> ShowS #
Show HasAnns
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods showsPrec :: Int -> HasAnns -> ShowS # show :: HasAnns -> String # showList :: [HasAnns] -> ShowS #
Show IsMichelson
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods showsPrec :: Int -> IsMichelson -> ShowS # show :: IsMichelson -> String # showList :: [IsMichelson] -> ShowS #
Show NumChildren
Instance details Defined in Morley.Michelson.Typed.ClassifiedInstr.Internal.Types Methods showsPrec :: Int -> NumChildren -> ShowS # show :: NumChildren -> String # showList :: [NumChildren] -> ShowS #
Show UntypingOptions
Instance details Defined in Morley.Michelson.Typed.Convert Methods showsPrec :: Int -> UntypingOptions -> ShowS # show :: UntypingOptions -> String # showList :: [UntypingOptions] -> ShowS #
Show ArmCoord
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> ArmCoord -> ShowS # show :: ArmCoord -> String # showList :: [ArmCoord] -> ShowS #
Show EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> EpAddress -> ShowS # show :: EpAddress -> String # showList :: [EpAddress] -> ShowS #
Show ParamEpError
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> ParamEpError -> ShowS # show :: ParamEpError -> String # showList :: [ParamEpError] -> ShowS #
Show ParseEpAddressError
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> ParseEpAddressError -> ShowS # show :: ParseEpAddressError -> String # showList :: [ParseEpAddressError] -> ShowS #
Show SomeContract
Instance details Defined in Morley.Michelson.Typed.Existential Methods showsPrec :: Int -> SomeContract -> ShowS # show :: SomeContract -> String # showList :: [SomeContract] -> ShowS #
Show SomeContractAndStorage
Instance details Defined in Morley.Michelson.Typed.Existential Methods showsPrec :: Int -> SomeContractAndStorage -> ShowS # show :: SomeContractAndStorage -> String # showList :: [SomeContractAndStorage] -> ShowS #
Show CommentType
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> CommentType -> ShowS # show :: CommentType -> String # showList :: [CommentType] -> ShowS #
Show SomeMeta
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> SomeMeta -> ShowS # show :: SomeMeta -> String # showList :: [SomeMeta] -> ShowS #
Show EmitOperation
Instance details Defined in Morley.Michelson.Typed.Operation Methods showsPrec :: Int -> EmitOperation -> ShowS # show :: EmitOperation -> String # showList :: [EmitOperation] -> ShowS #
Show OperationHash
Instance details Defined in Morley.Michelson.Typed.Operation Methods showsPrec :: Int -> OperationHash -> ShowS # show :: OperationHash -> String # showList :: [OperationHash] -> ShowS #
Show OriginationOperation
Instance details Defined in Morley.Michelson.Typed.Operation Methods showsPrec :: Int -> OriginationOperation -> ShowS # show :: OriginationOperation -> String # showList :: [OriginationOperation] -> ShowS #
Show SetDelegateOperation
Instance details Defined in Morley.Michelson.Typed.Operation Methods showsPrec :: Int -> SetDelegateOperation -> ShowS # show :: SetDelegateOperation -> String # showList :: [SetDelegateOperation] -> ShowS #
Show TransferOperation
Instance details Defined in Morley.Michelson.Typed.Operation Methods showsPrec :: Int -> TransferOperation -> ShowS # show :: TransferOperation -> String # showList :: [TransferOperation] -> ShowS #
Show BadTypeForScope
Instance details Defined in Morley.Michelson.Typed.Scope Methods showsPrec :: Int -> BadTypeForScope -> ShowS # show :: BadTypeForScope -> String # showList :: [BadTypeForScope] -> ShowS #
Show T
Instance details Defined in Morley.Michelson.Typed.T Methods showsPrec :: Int -> T -> ShowS # show :: T -> String # showList :: [T] -> ShowS #
Show SetDelegate
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> SetDelegate -> ShowS # show :: SetDelegate -> String # showList :: [SetDelegate] -> ShowS #
Show AnnotationSet
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods showsPrec :: Int -> AnnotationSet -> ShowS # show :: AnnotationSet -> String # showList :: [AnnotationSet] -> ShowS #
Show AnyAnn
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods showsPrec :: Int -> AnyAnn -> ShowS # show :: AnyAnn -> String # showList :: [AnyAnn] -> ShowS #
Show VarAnns
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods showsPrec :: Int -> VarAnns -> ShowS # show :: VarAnns -> String # showList :: [VarAnns] -> ShowS #
Show EntriesOrder
Instance details Defined in Morley.Michelson.Untyped.Contract Methods showsPrec :: Int -> EntriesOrder -> ShowS # show :: EntriesOrder -> String # showList :: [EntriesOrder] -> ShowS #
Show Entry
Instance details Defined in Morley.Michelson.Untyped.Contract Methods showsPrec :: Int -> Entry -> ShowS # show :: Entry -> String # showList :: [Entry] -> ShowS #
Show EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods showsPrec :: Int -> EpName -> ShowS # show :: EpName -> String # showList :: [EpName] -> ShowS #
Show EpNameFromRefAnnError
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods showsPrec :: Int -> EpNameFromRefAnnError -> ShowS # show :: EpNameFromRefAnnError -> String # showList :: [EpNameFromRefAnnError] -> ShowS #
Show HandleImplicitDefaultEp
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods showsPrec :: Int -> HandleImplicitDefaultEp -> ShowS # show :: HandleImplicitDefaultEp -> String # showList :: [HandleImplicitDefaultEp] -> ShowS #
Show PrintComment
Instance details Defined in Morley.Michelson.Untyped.Ext Methods showsPrec :: Int -> PrintComment -> ShowS # show :: PrintComment -> String # showList :: [PrintComment] -> ShowS #
Show StackRef
Instance details Defined in Morley.Michelson.Untyped.Ext Methods showsPrec :: Int -> StackRef -> ShowS # show :: StackRef -> String # showList :: [StackRef] -> ShowS #
Show StackTypePattern
Instance details Defined in Morley.Michelson.Untyped.Ext Methods showsPrec :: Int -> StackTypePattern -> ShowS # show :: StackTypePattern -> String # showList :: [StackTypePattern] -> ShowS #
Show TyVar
Instance details Defined in Morley.Michelson.Untyped.Ext Methods showsPrec :: Int -> TyVar -> ShowS # show :: TyVar -> String # showList :: [TyVar] -> ShowS #
Show Var
Instance details Defined in Morley.Michelson.Untyped.Ext Methods showsPrec :: Int -> Var -> ShowS # show :: Var -> String # showList :: [Var] -> ShowS #
Show ExpandedOp
Instance details Defined in Morley.Michelson.Untyped.Instr Methods showsPrec :: Int -> ExpandedOp -> ShowS # show :: ExpandedOp -> String # showList :: [ExpandedOp] -> ShowS #
Show ParameterType
Instance details Defined in Morley.Michelson.Untyped.Type Methods showsPrec :: Int -> ParameterType -> ShowS # show :: ParameterType -> String # showList :: [ParameterType] -> ShowS #
Show T
Instance details Defined in Morley.Michelson.Untyped.Type Methods showsPrec :: Int -> T -> ShowS # show :: T -> String # showList :: [T] -> ShowS #
Show Ty
Instance details Defined in Morley.Michelson.Untyped.Type Methods showsPrec :: Int -> Ty -> ShowS # show :: Ty -> String # showList :: [Ty] -> ShowS #
Show InternalByteString
Instance details Defined in Morley.Michelson.Untyped.Value Methods showsPrec :: Int -> InternalByteString -> ShowS # show :: InternalByteString -> String # showList :: [InternalByteString] -> ShowS #
Show GlobalCounter
Instance details Defined in Morley.Tezos.Address Methods showsPrec :: Int -> GlobalCounter -> ShowS # show :: GlobalCounter -> String # showList :: [GlobalCounter] -> ShowS #
Show ParseAddressError
Instance details Defined in Morley.Tezos.Address Methods showsPrec :: Int -> ParseAddressError -> ShowS # show :: ParseAddressError -> String # showList :: [ParseAddressError] -> ShowS #
Show ParseAddressRawError
Instance details Defined in Morley.Tezos.Address Methods showsPrec :: Int -> ParseAddressRawError -> ShowS # show :: ParseAddressRawError -> String # showList :: [ParseAddressRawError] -> ShowS #
Show SomeAddressOrAlias
Instance details Defined in Morley.Tezos.Address.Alias Methods showsPrec :: Int -> SomeAddressOrAlias -> ShowS # show :: SomeAddressOrAlias -> String # showList :: [SomeAddressOrAlias] -> ShowS #
Show AddressKind
Instance details Defined in Morley.Tezos.Address.Kinds Methods showsPrec :: Int -> AddressKind -> ShowS # show :: AddressKind -> String # showList :: [AddressKind] -> ShowS #
Show ChainId
Instance details Defined in Morley.Tezos.Core Methods showsPrec :: Int -> ChainId -> ShowS # show :: ChainId -> String # showList :: [ChainId] -> ShowS #
Show Mutez
Instance details Defined in Morley.Tezos.Core Methods showsPrec :: Int -> Mutez -> ShowS # show :: Mutez -> String # showList :: [Mutez] -> ShowS #
Show ParseChainIdError
Instance details Defined in Morley.Tezos.Core Methods showsPrec :: Int -> ParseChainIdError -> ShowS # show :: ParseChainIdError -> String # showList :: [ParseChainIdError] -> ShowS #
Show Timestamp
Instance details Defined in Morley.Tezos.Core Methods showsPrec :: Int -> Timestamp -> ShowS # show :: Timestamp -> String # showList :: [Timestamp] -> ShowS #
Show KeyType
Instance details Defined in Morley.Tezos.Crypto Methods showsPrec :: Int -> KeyType -> ShowS # show :: KeyType -> String # showList :: [KeyType] -> ShowS #
Show ParseSignatureRawError
Instance details Defined in Morley.Tezos.Crypto Methods showsPrec :: Int -> ParseSignatureRawError -> ShowS # show :: ParseSignatureRawError -> String # showList :: [ParseSignatureRawError] -> ShowS #
Show PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods showsPrec :: Int -> PublicKey -> ShowS # show :: PublicKey -> String # showList :: [PublicKey] -> ShowS #
Show SecretKey
Instance details Defined in Morley.Tezos.Crypto Methods showsPrec :: Int -> SecretKey -> ShowS # show :: SecretKey -> String # showList :: [SecretKey] -> ShowS #
Show Signature
Instance details Defined in Morley.Tezos.Crypto Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
Show PublicKey
Instance details Defined in Morley.Tezos.Crypto.BLS Methods showsPrec :: Int -> PublicKey -> ShowS # show :: PublicKey -> String # showList :: [PublicKey] -> ShowS #
Show SecretKey
Instance details Defined in Morley.Tezos.Crypto.BLS Methods showsPrec :: Int -> SecretKey -> ShowS # show :: SecretKey -> String # showList :: [SecretKey] -> ShowS #
Show Signature
Instance details Defined in Morley.Tezos.Crypto.BLS Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
Show Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods showsPrec :: Int -> Bls12381Fr -> ShowS # show :: Bls12381Fr -> String # showList :: [Bls12381Fr] -> ShowS #
Show Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods showsPrec :: Int -> Bls12381G1 -> ShowS # show :: Bls12381G1 -> String # showList :: [Bls12381G1] -> ShowS #
Show Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods showsPrec :: Int -> Bls12381G2 -> ShowS # show :: Bls12381G2 -> String # showList :: [Bls12381G2] -> ShowS #
Show DeserializationError
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods showsPrec :: Int -> DeserializationError -> ShowS # show :: DeserializationError -> String # showList :: [DeserializationError] -> ShowS #
Show PublicKey
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Methods showsPrec :: Int -> PublicKey -> ShowS # show :: PublicKey -> String # showList :: [PublicKey] -> ShowS #
Show SecretKey
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Methods showsPrec :: Int -> SecretKey -> ShowS # show :: SecretKey -> String # showList :: [SecretKey] -> ShowS #
Show Signature
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
Show PublicKey
Instance details Defined in Morley.Tezos.Crypto.P256 Methods showsPrec :: Int -> PublicKey -> ShowS # show :: PublicKey -> String # showList :: [PublicKey] -> ShowS #
Show SecretKey
Instance details Defined in Morley.Tezos.Crypto.P256 Methods showsPrec :: Int -> SecretKey -> ShowS # show :: SecretKey -> String # showList :: [SecretKey] -> ShowS #
Show Signature
Instance details Defined in Morley.Tezos.Crypto.P256 Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
Show PublicKey
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Methods showsPrec :: Int -> PublicKey -> ShowS # show :: PublicKey -> String # showList :: [PublicKey] -> ShowS #
Show SecretKey
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Methods showsPrec :: Int -> SecretKey -> ShowS # show :: SecretKey -> String # showList :: [SecretKey] -> ShowS #
Show Signature
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
Show Chest
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> Chest -> ShowS # show :: Chest -> String # showList :: [Chest] -> ShowS #
Show ChestKey
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> ChestKey -> ShowS # show :: ChestKey -> String # showList :: [ChestKey] -> ShowS #
Show Ciphertext
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> Ciphertext -> ShowS # show :: Ciphertext -> String # showList :: [Ciphertext] -> ShowS #
Show Locked
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> Locked -> ShowS # show :: Locked -> String # showList :: [Locked] -> ShowS #
Show Nonce
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> Nonce -> ShowS # show :: Nonce -> String # showList :: [Nonce] -> ShowS #
Show OpeningResult
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> OpeningResult -> ShowS # show :: OpeningResult -> String # showList :: [OpeningResult] -> ShowS #
Show Proof
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> Proof -> ShowS # show :: Proof -> String # showList :: [Proof] -> ShowS #
Show PublicModulus
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> PublicModulus -> ShowS # show :: PublicModulus -> String # showList :: [PublicModulus] -> ShowS #
Show RSAFactors
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> RSAFactors -> ShowS # show :: RSAFactors -> String # showList :: [RSAFactors] -> ShowS #
Show SymmetricKey
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> SymmetricKey -> ShowS # show :: SymmetricKey -> String # showList :: [SymmetricKey] -> ShowS #
Show TLTime
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> TLTime -> ShowS # show :: TLTime -> String # showList :: [TLTime] -> ShowS #
Show Unlocked
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> Unlocked -> ShowS # show :: Unlocked -> String # showList :: [Unlocked] -> ShowS #
Show B58CheckWithPrefixError
Instance details Defined in Morley.Tezos.Crypto.Util Methods showsPrec :: Int -> B58CheckWithPrefixError -> ShowS # show :: B58CheckWithPrefixError -> String # showList :: [B58CheckWithPrefixError] -> ShowS #
Show CryptoParseError
Instance details Defined in Morley.Tezos.Crypto.Util Methods showsPrec :: Int -> CryptoParseError -> ShowS # show :: CryptoParseError -> String # showList :: [CryptoParseError] -> ShowS #
Show UnpackError
Instance details Defined in Morley.Util.Binary Methods showsPrec :: Int -> UnpackError -> ShowS # show :: UnpackError -> String # showList :: [UnpackError] -> ShowS #
Show HexJSONByteString
Instance details Defined in Morley.Util.ByteString Methods showsPrec :: Int -> HexJSONByteString -> ShowS # show :: HexJSONByteString -> String # showList :: [HexJSONByteString] -> ShowS #
Show Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Mode -> ShowS # show :: Mode -> String # showList :: [Mode] -> ShowS #
Show Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Style -> ShowS # show :: Style -> String # showList :: [Style] -> ShowS #
Show TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> TextDetails -> ShowS # show :: TextDetails -> String # showList :: [TextDetails] -> ShowS #
Show Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods showsPrec :: Int -> Doc -> ShowS # show :: Doc -> String # showList :: [Doc] -> ShowS #
Show ByteArray	Behavior changed in 0.7.2.0. Before 0.7.2.0, this instance rendered 8-bit words less than 16 as a single hexadecimal digit (e.g. 13 was `0xD`). Starting with 0.7.2.0, all 8-bit words are represented as two digits (e.g. 13 is `0x0D`). Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.ByteArray Methods showsPrec :: Int -> ByteArray -> ShowS # show :: ByteArray -> String # showList :: [ByteArray] -> ShowS #
Show StdGen
Instance details Defined in System.Random.Internal Methods showsPrec :: Int -> StdGen -> ShowS # show :: StdGen -> String # showList :: [StdGen] -> ShowS #
Show AsyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods showsPrec :: Int -> AsyncExceptionWrapper -> ShowS # show :: AsyncExceptionWrapper -> String # showList :: [AsyncExceptionWrapper] -> ShowS #
Show StringException
Instance details Defined in Control.Exception.Safe Methods showsPrec :: Int -> StringException -> ShowS # show :: StringException -> String # showList :: [StringException] -> ShowS #
Show SyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods showsPrec :: Int -> SyncExceptionWrapper -> ShowS # show :: SyncExceptionWrapper -> String # showList :: [SyncExceptionWrapper] -> ShowS #
Show Scientific	See `formatScientific` if you need more control over the rendering.
Instance details Defined in Data.Scientific Methods showsPrec :: Int -> Scientific -> ShowS # show :: Scientific -> String # showList :: [Scientific] -> ShowS #
Show Mod2
Instance details Defined in Data.Semiring Methods showsPrec :: Int -> Mod2 -> ShowS # show :: Mod2 -> String # showList :: [Mod2] -> ShowS #
Show DependencyType
Instance details Defined in Test.Tasty.Core Methods showsPrec :: Int -> DependencyType -> ShowS # show :: DependencyType -> String # showList :: [DependencyType] -> ShowS #
Show FailureReason
Instance details Defined in Test.Tasty.Core Methods showsPrec :: Int -> FailureReason -> ShowS # show :: FailureReason -> String # showList :: [FailureReason] -> ShowS #
Show Outcome
Instance details Defined in Test.Tasty.Core Methods showsPrec :: Int -> Outcome -> ShowS # show :: Outcome -> String # showList :: [Outcome] -> ShowS #
Show Progress
Instance details Defined in Test.Tasty.Core Methods showsPrec :: Int -> Progress -> ShowS # show :: Progress -> String # showList :: [Progress] -> ShowS #
Show ResourceError
Instance details Defined in Test.Tasty.Core Methods showsPrec :: Int -> ResourceError -> ShowS # show :: ResourceError -> String # showList :: [ResourceError] -> ShowS #
Show Result
Instance details Defined in Test.Tasty.Core Methods showsPrec :: Int -> Result -> ShowS # show :: Result -> String # showList :: [Result] -> ShowS #
Show Expr
Instance details Defined in Test.Tasty.Patterns.Types Methods showsPrec :: Int -> Expr -> ShowS # show :: Expr -> String # showList :: [Expr] -> ShowS #
Show ForallVisFlag
Instance details Defined in Language.Haskell.TH.Ppr Methods showsPrec :: Int -> ForallVisFlag -> ShowS # show :: ForallVisFlag -> String # showList :: [ForallVisFlag] -> ShowS #
Show Doc
Instance details Defined in Language.Haskell.TH.PprLib Methods showsPrec :: Int -> Doc -> ShowS # show :: Doc -> String # showList :: [Doc] -> ShowS #
Show AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> AnnLookup -> ShowS # show :: AnnLookup -> String # showList :: [AnnLookup] -> ShowS #
Show AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> AnnTarget -> ShowS # show :: AnnTarget -> String # showList :: [AnnTarget] -> ShowS #
Show Bang
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Bang -> ShowS # show :: Bang -> String # showList :: [Bang] -> ShowS #
Show Body
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Body -> ShowS # show :: Body -> String # showList :: [Body] -> ShowS #
Show Bytes
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Bytes -> ShowS # show :: Bytes -> String # showList :: [Bytes] -> ShowS #
Show Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Callconv -> ShowS # show :: Callconv -> String # showList :: [Callconv] -> ShowS #
Show Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Clause -> ShowS # show :: Clause -> String # showList :: [Clause] -> ShowS #
Show Con
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Con -> ShowS # show :: Con -> String # showList :: [Con] -> ShowS #
Show Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Dec -> ShowS # show :: Dec -> String # showList :: [Dec] -> ShowS #
Show DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Show DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DerivClause -> ShowS # show :: DerivClause -> String # showList :: [DerivClause] -> ShowS #
Show DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DerivStrategy -> ShowS # show :: DerivStrategy -> String # showList :: [DerivStrategy] -> ShowS #
Show Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Exp -> ShowS # show :: Exp -> String # showList :: [Exp] -> ShowS #
Show FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FamilyResultSig -> ShowS # show :: FamilyResultSig -> String # showList :: [FamilyResultSig] -> ShowS #
Show Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FixityDirection -> ShowS # show :: FixityDirection -> String # showList :: [FixityDirection] -> ShowS #
Show Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Foreign -> ShowS # show :: Foreign -> String # showList :: [Foreign] -> ShowS #
Show FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FunDep -> ShowS # show :: FunDep -> String # showList :: [FunDep] -> ShowS #
Show Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Guard -> ShowS # show :: Guard -> String # showList :: [Guard] -> ShowS #
Show Info
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Info -> ShowS # show :: Info -> String # showList :: [Info] -> ShowS #
Show InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> InjectivityAnn -> ShowS # show :: InjectivityAnn -> String # showList :: [InjectivityAnn] -> ShowS #
Show Inline
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Inline -> ShowS # show :: Inline -> String # showList :: [Inline] -> ShowS #
Show Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Lit -> ShowS # show :: Lit -> String # showList :: [Lit] -> ShowS #
Show Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Loc -> ShowS # show :: Loc -> String # showList :: [Loc] -> ShowS #
Show Match
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Match -> ShowS # show :: Match -> String # showList :: [Match] -> ShowS #
Show ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> ModName -> ShowS # show :: ModName -> String # showList :: [ModName] -> ShowS #
Show Module
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> ModuleInfo -> ShowS # show :: ModuleInfo -> String # showList :: [ModuleInfo] -> ShowS #
Show Name
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Name -> ShowS # show :: Name -> String # showList :: [Name] -> ShowS #
Show NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NameFlavour -> ShowS # show :: NameFlavour -> String # showList :: [NameFlavour] -> ShowS #
Show NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NameSpace -> ShowS # show :: NameSpace -> String # showList :: [NameSpace] -> ShowS #
Show OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> OccName -> ShowS # show :: OccName -> String # showList :: [OccName] -> ShowS #
Show Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Overlap -> ShowS # show :: Overlap -> String # showList :: [Overlap] -> ShowS #
Show Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Pat -> ShowS # show :: Pat -> String # showList :: [Pat] -> ShowS #
Show PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynArgs -> ShowS # show :: PatSynArgs -> String # showList :: [PatSynArgs] -> ShowS #
Show PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynDir -> ShowS # show :: PatSynDir -> String # showList :: [PatSynDir] -> ShowS #
Show Phases
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Phases -> ShowS # show :: Phases -> String # showList :: [Phases] -> ShowS #
Show PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PkgName -> ShowS # show :: PkgName -> String # showList :: [PkgName] -> ShowS #
Show Pragma
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Pragma -> ShowS # show :: Pragma -> String # showList :: [Pragma] -> ShowS #
Show Range
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Range -> ShowS # show :: Range -> String # showList :: [Range] -> ShowS #
Show Role
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Role -> ShowS # show :: Role -> String # showList :: [Role] -> ShowS #
Show RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> RuleBndr -> ShowS # show :: RuleBndr -> String # showList :: [RuleBndr] -> ShowS #
Show RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> RuleMatch -> ShowS # show :: RuleMatch -> String # showList :: [RuleMatch] -> ShowS #
Show Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Safety -> ShowS # show :: Safety -> String # showList :: [Safety] -> ShowS #
Show SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Show SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Show Specificity
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Specificity -> ShowS # show :: Specificity -> String # showList :: [Specificity] -> ShowS #
Show Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Stmt -> ShowS # show :: Stmt -> String # showList :: [Stmt] -> ShowS #
Show TyLit
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TyLit -> ShowS # show :: TyLit -> String # showList :: [TyLit] -> ShowS #
Show TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TySynEqn -> ShowS # show :: TySynEqn -> String # showList :: [TySynEqn] -> ShowS #
Show Type
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Type -> ShowS # show :: Type -> String # showList :: [Type] -> ShowS #
Show TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TypeFamilyHead -> ShowS # show :: TypeFamilyHead -> String # showList :: [TypeFamilyHead] -> ShowS #
Show CodePoint
Instance details Defined in Data.Text.Encoding Methods showsPrec :: Int -> CodePoint -> ShowS # show :: CodePoint -> String # showList :: [CodePoint] -> ShowS #
Show DecoderState
Instance details Defined in Data.Text.Encoding Methods showsPrec :: Int -> DecoderState -> ShowS # show :: DecoderState -> String # showList :: [DecoderState] -> ShowS #
Show Decoding
Instance details Defined in Data.Text.Encoding Methods showsPrec :: Int -> Decoding -> ShowS # show :: Decoding -> String # showList :: [Decoding] -> ShowS #
Show UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods showsPrec :: Int -> UnicodeException -> ShowS # show :: UnicodeException -> String # showList :: [UnicodeException] -> ShowS #
Show Builder
Instance details Defined in Data.Text.Internal.Builder Methods showsPrec :: Int -> Builder -> ShowS # show :: Builder -> String # showList :: [Builder] -> ShowS #
Show ShortText
Instance details Defined in Data.Text.Short.Internal Methods showsPrec :: Int -> ShortText -> ShowS # show :: ShortText -> String # showList :: [ShortText] -> ShowS #
Show ConstructorInfo
Instance details Defined in Language.Haskell.TH.Datatype Methods showsPrec :: Int -> ConstructorInfo -> ShowS # show :: ConstructorInfo -> String # showList :: [ConstructorInfo] -> ShowS #
Show ConstructorVariant
Instance details Defined in Language.Haskell.TH.Datatype Methods showsPrec :: Int -> ConstructorVariant -> ShowS # show :: ConstructorVariant -> String # showList :: [ConstructorVariant] -> ShowS #
Show DatatypeInfo
Instance details Defined in Language.Haskell.TH.Datatype Methods showsPrec :: Int -> DatatypeInfo -> ShowS # show :: DatatypeInfo -> String # showList :: [DatatypeInfo] -> ShowS #
Show DatatypeVariant
Instance details Defined in Language.Haskell.TH.Datatype Methods showsPrec :: Int -> DatatypeVariant -> ShowS # show :: DatatypeVariant -> String # showList :: [DatatypeVariant] -> ShowS #
Show FieldStrictness
Instance details Defined in Language.Haskell.TH.Datatype Methods showsPrec :: Int -> FieldStrictness -> ShowS # show :: FieldStrictness -> String # showList :: [FieldStrictness] -> ShowS #
Show Strictness
Instance details Defined in Language.Haskell.TH.Datatype Methods showsPrec :: Int -> Strictness -> ShowS # show :: Strictness -> String # showList :: [Strictness] -> ShowS #
Show Unpackedness
Instance details Defined in Language.Haskell.TH.Datatype Methods showsPrec :: Int -> Unpackedness -> ShowS # show :: Unpackedness -> String # showList :: [Unpackedness] -> ShowS #
Show DClause
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DClause -> ShowS # show :: DClause -> String # showList :: [DClause] -> ShowS #
Show DCon
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DCon -> ShowS # show :: DCon -> String # showList :: [DCon] -> ShowS #
Show DConFields
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DConFields -> ShowS # show :: DConFields -> String # showList :: [DConFields] -> ShowS #
Show DDec
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DDec -> ShowS # show :: DDec -> String # showList :: [DDec] -> ShowS #
Show DDerivClause
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DDerivClause -> ShowS # show :: DDerivClause -> String # showList :: [DDerivClause] -> ShowS #
Show DDerivStrategy
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DDerivStrategy -> ShowS # show :: DDerivStrategy -> String # showList :: [DDerivStrategy] -> ShowS #
Show DExp
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DExp -> ShowS # show :: DExp -> String # showList :: [DExp] -> ShowS #
Show DFamilyResultSig
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DFamilyResultSig -> ShowS # show :: DFamilyResultSig -> String # showList :: [DFamilyResultSig] -> ShowS #
Show DForallTelescope
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DForallTelescope -> ShowS # show :: DForallTelescope -> String # showList :: [DForallTelescope] -> ShowS #
Show DForeign
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DForeign -> ShowS # show :: DForeign -> String # showList :: [DForeign] -> ShowS #
Show DInfo
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DInfo -> ShowS # show :: DInfo -> String # showList :: [DInfo] -> ShowS #
Show DLetDec
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DLetDec -> ShowS # show :: DLetDec -> String # showList :: [DLetDec] -> ShowS #
Show DMatch
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DMatch -> ShowS # show :: DMatch -> String # showList :: [DMatch] -> ShowS #
Show DPat
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DPat -> ShowS # show :: DPat -> String # showList :: [DPat] -> ShowS #
Show DPatSynDir
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DPatSynDir -> ShowS # show :: DPatSynDir -> String # showList :: [DPatSynDir] -> ShowS #
Show DPragma
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DPragma -> ShowS # show :: DPragma -> String # showList :: [DPragma] -> ShowS #
Show DRuleBndr
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DRuleBndr -> ShowS # show :: DRuleBndr -> String # showList :: [DRuleBndr] -> ShowS #
Show DTySynEqn
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DTySynEqn -> ShowS # show :: DTySynEqn -> String # showList :: [DTySynEqn] -> ShowS #
Show DType
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DType -> ShowS # show :: DType -> String # showList :: [DType] -> ShowS #
Show DTypeFamilyHead
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DTypeFamilyHead -> ShowS # show :: DTypeFamilyHead -> String # showList :: [DTypeFamilyHead] -> ShowS #
Show NewOrData
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> NewOrData -> ShowS # show :: NewOrData -> String # showList :: [NewOrData] -> ShowS #
Show DFunArgs
Instance details Defined in Language.Haskell.TH.Desugar.Core Methods showsPrec :: Int -> DFunArgs -> ShowS # show :: DFunArgs -> String # showList :: [DFunArgs] -> ShowS #
Show DTypeArg
Instance details Defined in Language.Haskell.TH.Desugar.Core Methods showsPrec :: Int -> DTypeArg -> ShowS # show :: DTypeArg -> String # showList :: [DTypeArg] -> ShowS #
Show DVisFunArg
Instance details Defined in Language.Haskell.TH.Desugar.Core Methods showsPrec :: Int -> DVisFunArg -> ShowS # show :: DVisFunArg -> String # showList :: [DVisFunArg] -> ShowS #
Show NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods showsPrec :: Int -> NominalDiffTime -> ShowS # show :: NominalDiffTime -> String # showList :: [NominalDiffTime] -> ShowS #
Show LocalTime
Instance details Defined in Data.Time.LocalTime.Internal.LocalTime Methods showsPrec :: Int -> LocalTime -> ShowS # show :: LocalTime -> String # showList :: [LocalTime] -> ShowS #
Show ZonedTime
Instance details Defined in Data.Time.LocalTime.Internal.ZonedTime Methods showsPrec :: Int -> ZonedTime -> ShowS # show :: ZonedTime -> String # showList :: [ZonedTime] -> ShowS #
Show Undefined
Instance details Defined in Universum.Debug Methods showsPrec :: Int -> Undefined -> ShowS # show :: Undefined -> String # showList :: [Undefined] -> ShowS #
Show Bug
Instance details Defined in Universum.Exception Methods showsPrec :: Int -> Bug -> ShowS # show :: Bug -> String # showList :: [Bug] -> ShowS #
Show UUID	Pretty prints a `UUID` (without quotation marks). See also `toString`. `>>>` `show nil`"00000000-0000-0000-0000-000000000000"
Instance details Defined in Data.UUID.Types.Internal Methods showsPrec :: Int -> UUID -> ShowS # show :: UUID -> String # showList :: [UUID] -> ShowS #
Show UnpackedUUID
Instance details Defined in Data.UUID.Types.Internal Methods showsPrec :: Int -> UnpackedUUID -> ShowS # show :: UnpackedUUID -> String # showList :: [UnpackedUUID] -> ShowS #
Show Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Show Integer	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Show Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Show ()	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> () -> ShowS # show :: () -> String # showList :: [()] -> ShowS #
Show Bool	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Show Char	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Show Int	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Show RuntimeRep	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> RuntimeRep -> ShowS # show :: RuntimeRep -> String # showList :: [RuntimeRep] -> ShowS #
Show VecCount	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> VecCount -> ShowS # show :: VecCount -> String # showList :: [VecCount] -> ShowS #
Show VecElem	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> VecElem -> ShowS # show :: VecElem -> String # showList :: [VecElem] -> ShowS #
Show Word	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
() :=> (Show (a :- b))
Instance details Defined in Data.Constraint Methods ins :: () :- Show (a :- b) #
() :=> (Show (Dict a))
Instance details Defined in Data.Constraint Methods ins :: () :- Show (Dict a) #
() :=> (Show Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Ordering #
() :=> (Show Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Natural #
() :=> (Show ())
Instance details Defined in Data.Constraint Methods ins :: () :- Show () #
() :=> (Show Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Bool #
() :=> (Show Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Char #
() :=> (Show Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Int #
() :=> (Show Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Word #
Class () (Show a)
Instance details Defined in Data.Constraint Methods cls :: Show a :- () #
Show a => Show (First' a)
Instance details Defined in Distribution.Compat.Semigroup Methods showsPrec :: Int -> First' a -> ShowS # show :: First' a -> String # showList :: [First' a] -> ShowS #
Show a => Show (Last' a)
Instance details Defined in Distribution.Compat.Semigroup Methods showsPrec :: Int -> Last' a -> ShowS # show :: Last' a -> String # showList :: [Last' a] -> ShowS #
Show a => Show (Option' a)
Instance details Defined in Distribution.Compat.Semigroup Methods showsPrec :: Int -> Option' a -> ShowS # show :: Option' a -> String # showList :: [Option' a] -> ShowS #
Show v => Show (KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods showsPrec :: Int -> KeyMap v -> ShowS # show :: KeyMap v -> String # showList :: [KeyMap v] -> ShowS #
Show a => Show (IResult a)
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> IResult a -> ShowS # show :: IResult a -> String # showList :: [IResult a] -> ShowS #
Show a => Show (Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods showsPrec :: Int -> Result a -> ShowS # show :: Result a -> String # showList :: [Result a] -> ShowS #
Show a => Show (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods showsPrec :: Int -> ZipList a -> ShowS # show :: ZipList a -> String # showList :: [ZipList a] -> ShowS #
Show a => Show (Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods showsPrec :: Int -> Complex a -> ShowS # show :: Complex a -> String # showList :: [Complex a] -> ShowS #
Show a => Show (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Show a => Show (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Show a => Show (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Show a => Show (Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods showsPrec :: Int -> Down a -> ShowS # show :: Down a -> String # showList :: [Down a] -> ShowS #
Show a => Show (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Show a => Show (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Show a => Show (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Max a -> ShowS # show :: Max a -> String # showList :: [Max a] -> ShowS #
Show a => Show (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Min a -> ShowS # show :: Min a -> String # showList :: [Min a] -> ShowS #
Show a => Show (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Option a -> ShowS # show :: Option a -> String # showList :: [Option a] -> ShowS #
Show m => Show (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> WrappedMonoid m -> ShowS # show :: WrappedMonoid m -> String # showList :: [WrappedMonoid m] -> ShowS #
Show a => Show (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Dual a -> ShowS # show :: Dual a -> String # showList :: [Dual a] -> ShowS #
Show a => Show (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Product a -> ShowS # show :: Product a -> String # showList :: [Product a] -> ShowS #
Show a => Show (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Sum a -> ShowS # show :: Sum a -> String # showList :: [Sum a] -> ShowS #
Show a => Show (NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
Show (ForeignPtr a)	Since: base-2.1
Instance details Defined in GHC.ForeignPtr Methods showsPrec :: Int -> ForeignPtr a -> ShowS # show :: ForeignPtr a -> String # showList :: [ForeignPtr a] -> ShowS #
Show p => Show (Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Par1 p -> ShowS # show :: Par1 p -> String # showList :: [Par1 p] -> ShowS #
Show (FunPtr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> FunPtr a -> ShowS # show :: FunPtr a -> String # showList :: [FunPtr a] -> ShowS #
Show (Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> Ptr a -> ShowS # show :: Ptr a -> String # showList :: [Ptr a] -> ShowS #
Show a => Show (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods showsPrec :: Int -> Ratio a -> ShowS # show :: Ratio a -> String # showList :: [Ratio a] -> ShowS #
Show (Bits n)
Instance details Defined in Basement.Bits Methods showsPrec :: Int -> Bits n -> ShowS # show :: Bits n -> String # showList :: [Bits n] -> ShowS #
(PrimType ty, Show ty) => Show (Block ty)
Instance details Defined in Basement.Block.Base Methods showsPrec :: Int -> Block ty -> ShowS # show :: Block ty -> String # showList :: [Block ty] -> ShowS #
Show (Zn n)
Instance details Defined in Basement.Bounded Methods showsPrec :: Int -> Zn n -> ShowS # show :: Zn n -> String # showList :: [Zn n] -> ShowS #
Show (Zn64 n)
Instance details Defined in Basement.Bounded Methods showsPrec :: Int -> Zn64 n -> ShowS # show :: Zn64 n -> String # showList :: [Zn64 n] -> ShowS #
Show a => Show (Array a)
Instance details Defined in Basement.BoxedArray Methods showsPrec :: Int -> Array a -> ShowS # show :: Array a -> String # showList :: [Array a] -> ShowS #
Show a => Show (NonEmpty a)
Instance details Defined in Basement.NonEmpty Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
Show (CountOf ty)
Instance details Defined in Basement.Types.OffsetSize Methods showsPrec :: Int -> CountOf ty -> ShowS # show :: CountOf ty -> String # showList :: [CountOf ty] -> ShowS #
Show (Offset ty)
Instance details Defined in Basement.Types.OffsetSize Methods showsPrec :: Int -> Offset ty -> ShowS # show :: Offset ty -> String # showList :: [Offset ty] -> ShowS #
(PrimType ty, Show ty) => Show (UArray ty)
Instance details Defined in Basement.UArray.Base Methods showsPrec :: Int -> UArray ty -> ShowS # show :: UArray ty -> String # showList :: [UArray ty] -> ShowS #
Show a => Show (Identifier a)
Instance details Defined in Text.Casing Methods showsPrec :: Int -> Identifier a -> ShowS # show :: Identifier a -> String # showList :: [Identifier a] -> ShowS #
Show (Dict a)
Instance details Defined in Data.Constraint Methods showsPrec :: Int -> Dict a -> ShowS # show :: Dict a -> String # showList :: [Dict a] -> ShowS #
Show vertex => Show (SCC vertex)	Since: containers-0.5.9
Instance details Defined in Data.Graph Methods showsPrec :: Int -> SCC vertex -> ShowS # show :: SCC vertex -> String # showList :: [SCC vertex] -> ShowS #
Show a => Show (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods showsPrec :: Int -> IntMap a -> ShowS # show :: IntMap a -> String # showList :: [IntMap a] -> ShowS #
Show a => Show (Seq a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> Seq a -> ShowS # show :: Seq a -> String # showList :: [Seq a] -> ShowS #
Show a => Show (ViewL a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> ViewL a -> ShowS # show :: ViewL a -> String # showList :: [ViewL a] -> ShowS #
Show a => Show (ViewR a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> ViewR a -> ShowS # show :: ViewR a -> String # showList :: [ViewR a] -> ShowS #
Show a => Show (Set a)
Instance details Defined in Data.Set.Internal Methods showsPrec :: Int -> Set a -> ShowS # show :: Set a -> String # showList :: [Set a] -> ShowS #
Show a => Show (Tree a)
Instance details Defined in Data.Tree Methods showsPrec :: Int -> Tree a -> ShowS # show :: Tree a -> String # showList :: [Tree a] -> ShowS #
Show a => Show (CryptoFailable a)
Instance details Defined in Crypto.Error.Types Methods showsPrec :: Int -> CryptoFailable a -> ShowS # show :: CryptoFailable a -> String # showList :: [CryptoFailable a] -> ShowS #
Show (Blake2b bitlen)
Instance details Defined in Crypto.Hash.Blake2 Methods showsPrec :: Int -> Blake2b bitlen -> ShowS # show :: Blake2b bitlen -> String # showList :: [Blake2b bitlen] -> ShowS #
Show (Blake2bp bitlen)
Instance details Defined in Crypto.Hash.Blake2 Methods showsPrec :: Int -> Blake2bp bitlen -> ShowS # show :: Blake2bp bitlen -> String # showList :: [Blake2bp bitlen] -> ShowS #
Show (Blake2s bitlen)
Instance details Defined in Crypto.Hash.Blake2 Methods showsPrec :: Int -> Blake2s bitlen -> ShowS # show :: Blake2s bitlen -> String # showList :: [Blake2s bitlen] -> ShowS #
Show (Blake2sp bitlen)
Instance details Defined in Crypto.Hash.Blake2 Methods showsPrec :: Int -> Blake2sp bitlen -> ShowS # show :: Blake2sp bitlen -> String # showList :: [Blake2sp bitlen] -> ShowS #
Show (SHAKE128 bitlen)
Instance details Defined in Crypto.Hash.SHAKE Methods showsPrec :: Int -> SHAKE128 bitlen -> ShowS # show :: SHAKE128 bitlen -> String # showList :: [SHAKE128 bitlen] -> ShowS #
Show (SHAKE256 bitlen)
Instance details Defined in Crypto.Hash.SHAKE Methods showsPrec :: Int -> SHAKE256 bitlen -> ShowS # show :: SHAKE256 bitlen -> String # showList :: [SHAKE256 bitlen] -> ShowS #
Show1 f => Show (Fix f)
Instance details Defined in Data.Fix Methods showsPrec :: Int -> Fix f -> ShowS # show :: Fix f -> String # showList :: [Fix f] -> ShowS #
(Functor f, Show1 f) => Show (Mu f)
Instance details Defined in Data.Fix Methods showsPrec :: Int -> Mu f -> ShowS # show :: Mu f -> String # showList :: [Mu f] -> ShowS #
(Functor f, Show1 f) => Show (Nu f)
Instance details Defined in Data.Fix Methods showsPrec :: Int -> Nu f -> ShowS # show :: Nu f -> String # showList :: [Nu f] -> ShowS #
Show a => Show (DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods showsPrec :: Int -> DNonEmpty a -> ShowS # show :: DNonEmpty a -> String # showList :: [DNonEmpty a] -> ShowS #
Show a => Show (DList a)
Instance details Defined in Data.DList.Internal Methods showsPrec :: Int -> DList a -> ShowS # show :: DList a -> String # showList :: [DList a] -> ShowS #
Show a => Show (ExitCase a)
Instance details Defined in Control.Monad.Catch Methods showsPrec :: Int -> ExitCase a -> ShowS # show :: ExitCase a -> String # showList :: [ExitCase a] -> ShowS #
Show (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods showsPrec :: Int -> Binary p -> ShowS # show :: Binary p -> String # showList :: [Binary p] -> ShowS #
KnownNat p => Show (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods showsPrec :: Int -> Prime p -> ShowS # show :: Prime p -> String # showList :: [Prime p] -> ShowS #
Show a => Show (Hashed a)
Instance details Defined in Data.Hashable.Class Methods showsPrec :: Int -> Hashed a -> ShowS # show :: Hashed a -> String # showList :: [Hashed a] -> ShowS #
Show (Affine a)
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods showsPrec :: Int -> Affine a -> ShowS # show :: Affine a -> String # showList :: [Affine a] -> ShowS #
Show (Point a)
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods showsPrec :: Int -> Point a -> ShowS # show :: Point a -> String # showList :: [Point a] -> ShowS #
Show (PublicKey c)
Instance details Defined in Crypto.BLST.Internal.Types Methods showsPrec :: Int -> PublicKey c -> ShowS # show :: PublicKey c -> String # showList :: [PublicKey c] -> ShowS #
Show a => Show (OpenChestT a)
Instance details Defined in Lorentz.Bytes Methods showsPrec :: Int -> OpenChestT a -> ShowS # show :: OpenChestT a -> String # showList :: [OpenChestT a] -> ShowS #
Show (Packed a)
Instance details Defined in Lorentz.Bytes Methods showsPrec :: Int -> Packed a -> ShowS # show :: Packed a -> String # showList :: [Packed a] -> ShowS #
Show (TSignature a)
Instance details Defined in Lorentz.Bytes Methods showsPrec :: Int -> TSignature a -> ShowS # show :: TSignature a -> String # showList :: [TSignature a] -> ShowS #
Show (EpCallingDesc info)
Instance details Defined in Lorentz.Entrypoints.Core Methods showsPrec :: Int -> EpCallingDesc info -> ShowS # show :: EpCallingDesc info -> String # showList :: [EpCallingDesc info] -> ShowS #
Show (CustomErrorRep tag) => Show (CustomError tag)
Instance details Defined in Lorentz.Errors Methods showsPrec :: Int -> CustomError tag -> ShowS # show :: CustomError tag -> String # showList :: [CustomError tag] -> ShowS #
Show (ConstrainedSome Show)
Instance details Defined in Lorentz.UParam Methods showsPrec :: Int -> ConstrainedSome Show -> ShowS # show :: ConstrainedSome Show -> String # showList :: [ConstrainedSome Show] -> ShowS #
Show (UParam entries)
Instance details Defined in Lorentz.UParam Methods showsPrec :: Int -> UParam entries -> ShowS # show :: UParam entries -> String # showList :: [UParam entries] -> ShowS #
Show a => Show (ReadTicket a)
Instance details Defined in Lorentz.Value Methods showsPrec :: Int -> ReadTicket a -> ShowS # show :: ReadTicket a -> String # showList :: [ReadTicket a] -> ShowS #
Show e => Show (ErrorFancy e)
Instance details Defined in Text.Megaparsec.Error Methods showsPrec :: Int -> ErrorFancy e -> ShowS # show :: ErrorFancy e -> String # showList :: [ErrorFancy e] -> ShowS #
Show t => Show (ErrorItem t)
Instance details Defined in Text.Megaparsec.Error Methods showsPrec :: Int -> ErrorItem t -> ShowS # show :: ErrorItem t -> String # showList :: [ErrorItem t] -> ShowS #
Show s => Show (PosState s)
Instance details Defined in Text.Megaparsec.State Methods showsPrec :: Int -> PosState s -> ShowS # show :: PosState s -> String # showList :: [PosState s] -> ShowS #
KnownNat m => Show (Mod m)
Instance details Defined in Data.Mod Methods showsPrec :: Int -> Mod m -> ShowS # show :: Mod m -> String # showList :: [Mod m] -> ShowS #
ExpAllExtrasConstrainted Show x => Show (Exp x)
Instance details Defined in Morley.Micheline.Expression Methods showsPrec :: Int -> Exp x -> ShowS # show :: Exp x -> String # showList :: [Exp x] -> ShowS #
Show (Exp x) => Show (MichelinePrimAp x)
Instance details Defined in Morley.Micheline.Expression Methods showsPrec :: Int -> MichelinePrimAp x -> ShowS # show :: MichelinePrimAp x -> String # showList :: [MichelinePrimAp x] -> ShowS #
Show a => Show (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods showsPrec :: Int -> StringEncode a -> ShowS # show :: StringEncode a -> String # showList :: [StringEncode a] -> ShowS #
Show a => Show (ViewsSetF a)
Instance details Defined in Morley.Michelson.Internal.ViewsSet Methods showsPrec :: Int -> ViewsSetF a -> ShowS # show :: ViewsSetF a -> String # showList :: [ViewsSetF a] -> ShowS #
Show ext => Show (InterpretError ext)
Instance details Defined in Morley.Michelson.Interpret Methods showsPrec :: Int -> InterpretError ext -> ShowS # show :: InterpretError ext -> String # showList :: [InterpretError ext] -> ShowS #
Show ext => Show (MichelsonFailed ext)
Instance details Defined in Morley.Michelson.Interpret Methods showsPrec :: Int -> MichelsonFailed ext -> ShowS # show :: MichelsonFailed ext -> String # showList :: [MichelsonFailed ext] -> ShowS #
Show ext => Show (MichelsonFailureWithStack ext)
Instance details Defined in Morley.Michelson.Interpret Methods showsPrec :: Int -> MichelsonFailureWithStack ext -> ShowS # show :: MichelsonFailureWithStack ext -> String # showList :: [MichelsonFailureWithStack ext] -> ShowS #
Show res => Show (ResultStateLogs res)
Instance details Defined in Morley.Michelson.Interpret Methods showsPrec :: Int -> ResultStateLogs res -> ShowS # show :: ResultStateLogs res -> String # showList :: [ResultStateLogs res] -> ShowS #
Show (StkEl t)
Instance details Defined in Morley.Michelson.Interpret Methods showsPrec :: Int -> StkEl t -> ShowS # show :: StkEl t -> String # showList :: [StkEl t] -> ShowS #
Show op => Show (TcError' op)
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods showsPrec :: Int -> TcError' op -> ShowS # show :: TcError' op -> String # showList :: [TcError' op] -> ShowS #
Show op => Show (IllTypedInstr op)
Instance details Defined in Morley.Michelson.TypeCheck.TypeCheckedOp Methods showsPrec :: Int -> IllTypedInstr op -> ShowS # show :: IllTypedInstr op -> String # showList :: [IllTypedInstr op] -> ShowS #
Show op => Show (TypeCheckedOp op)
Instance details Defined in Morley.Michelson.TypeCheck.TypeCheckedOp Methods showsPrec :: Int -> TypeCheckedOp op -> ShowS # show :: TypeCheckedOp op -> String # showList :: [TypeCheckedOp op] -> ShowS #
Show (HST ts)
Instance details Defined in Morley.Michelson.TypeCheck.Types Methods showsPrec :: Int -> HST ts -> ShowS # show :: HST ts -> String # showList :: [HST ts] -> ShowS #
Show (SomeTcInstr inp)
Instance details Defined in Morley.Michelson.TypeCheck.Types Methods showsPrec :: Int -> SomeTcInstr inp -> ShowS # show :: SomeTcInstr inp -> String # showList :: [SomeTcInstr inp] -> ShowS #
Show (SomeTcInstrOut inp)
Instance details Defined in Morley.Michelson.TypeCheck.Types Methods showsPrec :: Int -> SomeTcInstrOut inp -> ShowS # show :: SomeTcInstrOut inp -> String # showList :: [SomeTcInstrOut inp] -> ShowS #
Each '[Show] rs => Show (Anns rs)
Instance details Defined in Morley.Michelson.Typed.Annotation Methods showsPrec :: Int -> Anns rs -> ShowS # show :: Anns rs -> String # showList :: [Anns rs] -> ShowS #
Show (Notes t)
Instance details Defined in Morley.Michelson.Typed.Annotation Methods showsPrec :: Int -> Notes t -> ShowS # show :: Notes t -> String # showList :: [Notes t] -> ShowS #
Show (ParamNotes t)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> ParamNotes t -> ShowS # show :: ParamNotes t -> String # showList :: [ParamNotes t] -> ShowS #
Show (SomeEntrypointCallT arg)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> SomeEntrypointCallT arg -> ShowS # show :: SomeEntrypointCallT arg -> String # showList :: [SomeEntrypointCallT arg] -> ShowS #
Show (ContractRef arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> ContractRef arg -> ShowS # show :: ContractRef arg -> String # showList :: [ContractRef arg] -> ShowS #
Show arg => Show (Ticket arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> Ticket arg -> ShowS # show :: Ticket arg -> String # showList :: [Ticket arg] -> ShowS #
Show (ExtInstr s)
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> ExtInstr s -> ShowS # show :: ExtInstr s -> String # showList :: [ExtInstr s] -> ShowS #
Show (PrintComment st)
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> PrintComment st -> ShowS # show :: PrintComment st -> String # showList :: [PrintComment st] -> ShowS #
Show (StackRef st)
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> StackRef st -> ShowS # show :: StackRef st -> String # showList :: [StackRef st] -> ShowS #
Show (TestAssert s)
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> TestAssert s -> ShowS # show :: TestAssert s -> String # showList :: [TestAssert s] -> ShowS #
Show (SingT x)
Instance details Defined in Morley.Michelson.Typed.Sing Methods showsPrec :: Int -> SingT x -> ShowS # show :: SingT x -> String # showList :: [SingT x] -> ShowS #
Show (Operation' instr)
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> Operation' instr -> ShowS # show :: Operation' instr -> String # showList :: [Operation' instr] -> ShowS #
(forall (i :: [T]) (o :: [T]). Show (instr i o)) => Show (SomeViewsSet' instr)
Instance details Defined in Morley.Michelson.Typed.View Methods showsPrec :: Int -> SomeViewsSet' instr -> ShowS # show :: SomeViewsSet' instr -> String # showList :: [SomeViewsSet' instr] -> ShowS #
Show op => Show (Contract' op)
Instance details Defined in Morley.Michelson.Untyped.Contract Methods showsPrec :: Int -> Contract' op -> ShowS # show :: Contract' op -> String # showList :: [Contract' op] -> ShowS #
Show op => Show (ContractBlock op)
Instance details Defined in Morley.Michelson.Untyped.Contract Methods showsPrec :: Int -> ContractBlock op -> ShowS # show :: ContractBlock op -> String # showList :: [ContractBlock op] -> ShowS #
Show op => Show (ExtInstrAbstract op)
Instance details Defined in Morley.Michelson.Untyped.Ext Methods showsPrec :: Int -> ExtInstrAbstract op -> ShowS # show :: ExtInstrAbstract op -> String # showList :: [ExtInstrAbstract op] -> ShowS #
Show op => Show (TestAssert op)
Instance details Defined in Morley.Michelson.Untyped.Ext Methods showsPrec :: Int -> TestAssert op -> ShowS # show :: TestAssert op -> String # showList :: [TestAssert op] -> ShowS #
Show op => Show (InstrAbstract op)
Instance details Defined in Morley.Michelson.Untyped.Instr Methods showsPrec :: Int -> InstrAbstract op -> ShowS # show :: InstrAbstract op -> String # showList :: [InstrAbstract op] -> ShowS #
Show op => Show (Elt op)
Instance details Defined in Morley.Michelson.Untyped.Value Methods showsPrec :: Int -> Elt op -> ShowS # show :: Elt op -> String # showList :: [Elt op] -> ShowS #
Show op => Show (Value' op)
Instance details Defined in Morley.Michelson.Untyped.Value Methods showsPrec :: Int -> Value' op -> ShowS # show :: Value' op -> String # showList :: [Value' op] -> ShowS #
Show op => Show (View' op)
Instance details Defined in Morley.Michelson.Untyped.View Methods showsPrec :: Int -> View' op -> ShowS # show :: View' op -> String # showList :: [View' op] -> ShowS #
Show instr => Show (ViewsSet instr)
Instance details Defined in Morley.Michelson.Untyped.View Methods showsPrec :: Int -> ViewsSet instr -> ShowS # show :: ViewsSet instr -> String # showList :: [ViewsSet instr] -> ShowS #
Show (KindedAddress kind)
Instance details Defined in Morley.Tezos.Address Methods showsPrec :: Int -> KindedAddress kind -> ShowS # show :: KindedAddress kind -> String # showList :: [KindedAddress kind] -> ShowS #
Show (AddressOrAlias kind)
Instance details Defined in Morley.Tezos.Address.Alias Methods showsPrec :: Int -> AddressOrAlias kind -> ShowS # show :: AddressOrAlias kind -> String # showList :: [AddressOrAlias kind] -> ShowS #
Show (Alias kind)
Instance details Defined in Morley.Tezos.Address.Alias Methods showsPrec :: Int -> Alias kind -> ShowS # show :: Alias kind -> String # showList :: [Alias kind] -> ShowS #
Show (Hash kind)
Instance details Defined in Morley.Tezos.Crypto Methods showsPrec :: Int -> Hash kind -> ShowS # show :: Hash kind -> String # showList :: [Hash kind] -> ShowS #
Show (HashTag kind)
Instance details Defined in Morley.Tezos.Crypto Methods showsPrec :: Int -> HashTag kind -> ShowS # show :: HashTag kind -> String # showList :: [HashTag kind] -> ShowS #
Show (Label name)
Instance details Defined in Morley.Util.Label Methods showsPrec :: Int -> Label name -> ShowS # show :: Label name -> String # showList :: [Label name] -> ShowS #
Show a => Show (MismatchError a)
Instance details Defined in Morley.Util.MismatchError Methods showsPrec :: Int -> MismatchError a -> ShowS # show :: MismatchError a -> String # showList :: [MismatchError a] -> ShowS #
Show (SingNat n)
Instance details Defined in Morley.Util.Peano Methods showsPrec :: Int -> SingNat n -> ShowS # show :: SingNat n -> String # showList :: [SingNat n] -> ShowS #
Show (PeanoNatural n)
Instance details Defined in Morley.Util.PeanoNatural Methods showsPrec :: Int -> PeanoNatural n -> ShowS # show :: PeanoNatural n -> String # showList :: [PeanoNatural n] -> ShowS #
Show a => Show (SomeSizedList a)
Instance details Defined in Morley.Util.SizedList Methods showsPrec :: Int -> SomeSizedList a -> ShowS # show :: SomeSizedList a -> String # showList :: [SomeSizedList a] -> ShowS #
Show a => Show (All a)
Instance details Defined in Morley.Prelude.Boolean Methods showsPrec :: Int -> All a -> ShowS # show :: All a -> String # showList :: [All a] -> ShowS #
Show a => Show (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods showsPrec :: Int -> Any a -> ShowS # show :: Any a -> String # showList :: [Any a] -> ShowS #
Show a => Show (AnnotDetails a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> AnnotDetails a -> ShowS # show :: AnnotDetails a -> String # showList :: [AnnotDetails a] -> ShowS #
Show (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Doc a -> ShowS # show :: Doc a -> String # showList :: [Doc a] -> ShowS #
Show a => Show (Span a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Span a -> ShowS # show :: Span a -> String # showList :: [Span a] -> ShowS #
Show a => Show (Array a)
Instance details Defined in Data.Primitive.Array Methods showsPrec :: Int -> Array a -> ShowS # show :: Array a -> String # showList :: [Array a] -> ShowS #
(Show a, Prim a) => Show (PrimArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods showsPrec :: Int -> PrimArray a -> ShowS # show :: PrimArray a -> String # showList :: [PrimArray a] -> ShowS #
Show a => Show (SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods showsPrec :: Int -> SmallArray a -> ShowS # show :: SmallArray a -> String # showList :: [SmallArray a] -> ShowS #
Show g => Show (StateGen g)
Instance details Defined in System.Random.Internal Methods showsPrec :: Int -> StateGen g -> ShowS # show :: StateGen g -> String # showList :: [StateGen g] -> ShowS #
Show g => Show (AtomicGen g)
Instance details Defined in System.Random.Stateful Methods showsPrec :: Int -> AtomicGen g -> ShowS # show :: AtomicGen g -> String # showList :: [AtomicGen g] -> ShowS #
Show g => Show (IOGen g)
Instance details Defined in System.Random.Stateful Methods showsPrec :: Int -> IOGen g -> ShowS # show :: IOGen g -> String # showList :: [IOGen g] -> ShowS #
Show g => Show (STGen g)
Instance details Defined in System.Random.Stateful Methods showsPrec :: Int -> STGen g -> ShowS # show :: STGen g -> String # showList :: [STGen g] -> ShowS #
Show g => Show (TGen g)
Instance details Defined in System.Random.Stateful Methods showsPrec :: Int -> TGen g -> ShowS # show :: TGen g -> String # showList :: [TGen g] -> ShowS #
Show a => Show (Add a)
Instance details Defined in Data.Semiring Methods showsPrec :: Int -> Add a -> ShowS # show :: Add a -> String # showList :: [Add a] -> ShowS #
Show (IntSetOf a)
Instance details Defined in Data.Semiring Methods showsPrec :: Int -> IntSetOf a -> ShowS # show :: IntSetOf a -> String # showList :: [IntSetOf a] -> ShowS #
Show a => Show (Mul a)
Instance details Defined in Data.Semiring Methods showsPrec :: Int -> Mul a -> ShowS # show :: Mul a -> String # showList :: [Mul a] -> ShowS #
Show a => Show (WrappedNum a)
Instance details Defined in Data.Semiring Methods showsPrec :: Int -> WrappedNum a -> ShowS # show :: WrappedNum a -> String # showList :: [WrappedNum a] -> ShowS #
Show (SBool z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> SBool z -> ShowS # show :: SBool z -> String # showList :: [SBool z] -> ShowS #
Show (SOrdering z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> SOrdering z -> ShowS # show :: SOrdering z -> String # showList :: [SOrdering z] -> ShowS #
Show (STuple0 z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> STuple0 z -> ShowS # show :: STuple0 z -> String # showList :: [STuple0 z] -> ShowS #
Show (SVoid z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> SVoid z -> ShowS # show :: SVoid z -> String # showList :: [SVoid z] -> ShowS #
Show (SNat n)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods showsPrec :: Int -> SNat n -> ShowS # show :: SNat n -> String # showList :: [SNat n] -> ShowS #
Show (SSymbol s)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods showsPrec :: Int -> SSymbol s -> ShowS # show :: SSymbol s -> String # showList :: [SSymbol s] -> ShowS #
Show a => Show (Maybe a)
Instance details Defined in Data.Strict.Maybe Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Show flag => Show (TyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TyVarBndr flag -> ShowS # show :: TyVarBndr flag -> String # showList :: [TyVarBndr flag] -> ShowS #
Show flag => Show (DTyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Desugar.AST Methods showsPrec :: Int -> DTyVarBndr flag -> ShowS # show :: DTyVarBndr flag -> String # showList :: [DTyVarBndr flag] -> ShowS #
Show a => Show (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods showsPrec :: Int -> HashSet a -> ShowS # show :: HashSet a -> String # showList :: [HashSet a] -> ShowS #
Show a => Show (Vector a)
Instance details Defined in Data.Vector Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
(Show a, Prim a) => Show (Vector a)
Instance details Defined in Data.Vector.Primitive Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
(Show a, Storable a) => Show (Vector a)
Instance details Defined in Data.Vector.Storable Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
(Show t, KnownSymbol s) => Show (ElField '(s, t))
Instance details Defined in Data.Vinyl.Functor Methods showsPrec :: Int -> ElField '(s, t) -> ShowS # show :: ElField '(s, t) -> String # showList :: [ElField '(s, t)] -> ShowS #
Show a => Show (Identity a)
Instance details Defined in Data.Vinyl.Functor Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Show a => Show (Thunk a)
Instance details Defined in Data.Vinyl.Functor Methods showsPrec :: Int -> Thunk a -> ShowS # show :: Thunk a -> String # showList :: [Thunk a] -> ShowS #
Show a => Show (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Show a => Show (a)	Since: base-4.15
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a) -> ShowS # show :: (a) -> String # showList :: [(a)] -> ShowS #
Show a => Show [a]	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> [a] -> ShowS # show :: [a] -> String # showList :: [[a]] -> ShowS #
(Show a) :=> (Show (Complex a))
Instance details Defined in Data.Constraint Methods ins :: Show a :- Show (Complex a) #
(Show a) :=> (Show (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Show a :- Show (Const a b) #
(Show a) :=> (Show (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Show a :- Show (Identity a) #
(Show a) :=> (Show (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Show a :- Show (Maybe a) #
(Show a) :=> (Show [a])
Instance details Defined in Data.Constraint Methods ins :: Show a :- Show [a] #
Show a => Show (OddWord a n)
Instance details Defined in Data.Word.Odd Methods showsPrec :: Int -> OddWord a n -> ShowS # show :: OddWord a n -> String # showList :: [OddWord a n] -> ShowS #
(Show i, Show r) => Show (IResult i r)
Instance details Defined in Data.Attoparsec.Internal.Types Methods showsPrec :: Int -> IResult i r -> ShowS # show :: IResult i r -> String # showList :: [IResult i r] -> ShowS #
(Show a, Show b) => Show (Either a b)	Since: base-3.0
Instance details Defined in Data.Either Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
HasResolution a => Show (Fixed a)	Since: base-2.1
Instance details Defined in Data.Fixed Methods showsPrec :: Int -> Fixed a -> ShowS # show :: Fixed a -> String # showList :: [Fixed a] -> ShowS #
Show (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods showsPrec :: Int -> Proxy s -> ShowS # show :: Proxy s -> String # showList :: [Proxy s] -> ShowS #
(Show a, Show b) => Show (Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Arg a b -> ShowS # show :: Arg a b -> String # showList :: [Arg a b] -> ShowS #
Show (TypeRep a)
Instance details Defined in Data.Typeable.Internal Methods showsPrec :: Int -> TypeRep a -> ShowS # show :: TypeRep a -> String # showList :: [TypeRep a] -> ShowS #
Show (U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> U1 p -> ShowS # show :: U1 p -> String # showList :: [U1 p] -> ShowS #
Show (V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> V1 p -> ShowS # show :: V1 p -> String # showList :: [V1 p] -> ShowS #
Show (ST s a)	Since: base-2.1
Instance details Defined in GHC.ST Methods showsPrec :: Int -> ST s a -> ShowS # show :: ST s a -> String # showList :: [ST s a] -> ShowS #
Show a => Show (ListN n a)
Instance details Defined in Basement.Sized.List Methods showsPrec :: Int -> ListN n a -> ShowS # show :: ListN n a -> String # showList :: [ListN n a] -> ShowS #
(Show a, Show b) => Show (Bimap a b)
Instance details Defined in Data.Bimap Methods showsPrec :: Int -> Bimap a b -> ShowS # show :: Bimap a b -> String # showList :: [Bimap a b] -> ShowS #
Show (a :- b)
Instance details Defined in Data.Constraint Methods showsPrec :: Int -> (a :- b) -> ShowS # show :: (a :- b) -> String # showList :: [a :- b] -> ShowS #
(Show k, Show a) => Show (Map k a)
Instance details Defined in Data.Map.Internal Methods showsPrec :: Int -> Map k a -> ShowS # show :: Map k a -> String # showList :: [Map k a] -> ShowS #
(Show1 f, Show a) => Show (Cofree f a)
Instance details Defined in Control.Comonad.Cofree Methods showsPrec :: Int -> Cofree f a -> ShowS # show :: Cofree f a -> String # showList :: [Cofree f a] -> ShowS #
(Show1 f, Show a) => Show (Free f a)
Instance details Defined in Control.Monad.Free Methods showsPrec :: Int -> Free f a -> ShowS # show :: Free f a -> String # showList :: [Free f a] -> ShowS #
Show k => Show (Extension p k)
Instance details Defined in Data.Field.Galois.Extension Methods showsPrec :: Int -> Extension p k -> ShowS # show :: Extension p k -> String # showList :: [Extension p k] -> ShowS #
Show k => Show (RootsOfUnity n k)
Instance details Defined in Data.Field.Galois.Unity Methods showsPrec :: Int -> RootsOfUnity n k -> ShowS # show :: RootsOfUnity n k -> String # showList :: [RootsOfUnity n k] -> ShowS #
Show (Signature c m)
Instance details Defined in Crypto.BLST.Internal.Types Methods showsPrec :: Int -> Signature c m -> ShowS # show :: Signature c m -> String # showList :: [Signature c m] -> ShowS #
Show (Var a) Source #
Instance details Defined in Indigo.Common.Var Methods showsPrec :: Int -> Var a -> ShowS # show :: Var a -> String # showList :: [Var a] -> ShowS #
Show (f a) => Show (Yoneda f a)
Instance details Defined in Data.Functor.Yoneda Methods showsPrec :: Int -> Yoneda f a -> ShowS # show :: Yoneda f a -> String # showList :: [Yoneda f a] -> ShowS #
Show (TAddress p vd)
Instance details Defined in Lorentz.Address Methods showsPrec :: Int -> TAddress p vd -> ShowS # show :: TAddress p vd -> String # showList :: [TAddress p vd] -> ShowS #
Show (inp :-> out)
Instance details Defined in Lorentz.Base Methods showsPrec :: Int -> (inp :-> out) -> ShowS # show :: (inp :-> out) -> String # showList :: [inp :-> out] -> ShowS #
Show (ContractCode cp st)
Instance details Defined in Lorentz.Base Methods showsPrec :: Int -> ContractCode cp st -> ShowS # show :: ContractCode cp st -> String # showList :: [ContractCode cp st] -> ShowS #
Show (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods showsPrec :: Int -> Hash alg a -> ShowS # show :: Hash alg a -> String # showList :: [Hash alg a] -> ShowS #
Show (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Methods showsPrec :: Int -> WrappedLambda i o -> ShowS # show :: WrappedLambda i o -> String # showList :: [WrappedLambda i o] -> ShowS #
Show a => Show (View_ a r)
Instance details Defined in Lorentz.Macro Methods showsPrec :: Int -> View_ a r -> ShowS # show :: View_ a r -> String # showList :: [View_ a r] -> ShowS #
Show a => Show (Void_ a b)
Instance details Defined in Lorentz.Macro Methods showsPrec :: Int -> Void_ a b -> ShowS # show :: Void_ a b -> String # showList :: [Void_ a b] -> ShowS #
(Show a, Show b) => Show (ZippedStackRepr a b)
Instance details Defined in Lorentz.Zip Methods showsPrec :: Int -> ZippedStackRepr a b -> ShowS # show :: ZippedStackRepr a b -> String # showList :: [ZippedStackRepr a b] -> ShowS #
(Show (Token s), Show e) => Show (ParseError s e)
Instance details Defined in Text.Megaparsec.Error Methods showsPrec :: Int -> ParseError s e -> ShowS # show :: ParseError s e -> String # showList :: [ParseError s e] -> ShowS #
(Show s, Show (Token s), Show e) => Show (ParseErrorBundle s e)
Instance details Defined in Text.Megaparsec.Error Methods showsPrec :: Int -> ParseErrorBundle s e -> ShowS # show :: ParseErrorBundle s e -> String # showList :: [ParseErrorBundle s e] -> ShowS #
(Show (ParseError s e), Show s) => Show (State s e)
Instance details Defined in Text.Megaparsec.State Methods showsPrec :: Int -> State s e -> ShowS # show :: State s e -> String # showList :: [State s e] -> ShowS #
(Show n, Show m) => Show (ArithError n m)
Instance details Defined in Morley.Michelson.Typed.Arith Methods showsPrec :: Int -> ArithError n m -> ShowS # show :: ArithError n m -> String # showList :: [ArithError n m] -> ShowS #
Show (EntrypointCallT param arg)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> EntrypointCallT param arg -> ShowS # show :: EntrypointCallT param arg -> String # showList :: [EntrypointCallT param arg] -> ShowS #
Show (EpLiftSequence arg param)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> EpLiftSequence arg param -> ShowS # show :: EpLiftSequence arg param -> String # showList :: [EpLiftSequence arg param] -> ShowS #
(Show k, Show v) => Show (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> BigMap k v -> ShowS # show :: BigMap k v -> String # showList :: [BigMap k v] -> ShowS #
Show (Instr inp out)
Instance details Defined in Morley.Michelson.Typed.Instr Methods showsPrec :: Int -> Instr inp out -> ShowS # show :: Instr inp out -> String # showList :: [Instr inp out] -> ShowS #
Show (Emit instr t)
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> Emit instr t -> ShowS # show :: Emit instr t -> String # showList :: [Emit instr t] -> ShowS #
Show (TransferTokens instr p)
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> TransferTokens instr p -> ShowS # show :: TransferTokens instr p -> String # showList :: [TransferTokens instr p] -> ShowS #
Show (Value' instr t)
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> Value' instr t -> ShowS # show :: Value' instr t -> String # showList :: [Value' instr t] -> ShowS #
(forall (arg :: T) (ret :: T). Show (ViewCode' instr arg st ret)) => Show (SomeView' instr st)
Instance details Defined in Morley.Michelson.Typed.View Methods showsPrec :: Int -> SomeView' instr st -> ShowS # show :: SomeView' instr st -> String # showList :: [SomeView' instr st] -> ShowS #
(forall (i :: [T]) (o :: [T]). Show (instr i o)) => Show (ViewsSet' instr st)
Instance details Defined in Morley.Michelson.Typed.View Methods showsPrec :: Int -> ViewsSet' instr st -> ShowS # show :: ViewsSet' instr st -> String # showList :: [ViewsSet' instr st] -> ShowS #
Typeable tag => Show (Annotation tag)
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods showsPrec :: Int -> Annotation tag -> ShowS # show :: Annotation tag -> String # showList :: [Annotation tag] -> ShowS #
(Show a, Show b) => Show (Bimap a b)
Instance details Defined in Morley.Util.Bimap Methods showsPrec :: Int -> Bimap a b -> ShowS # show :: Bimap a b -> String # showList :: [Bimap a b] -> ShowS #
Show a => Show (SizedList' n a)
Instance details Defined in Morley.Util.SizedList Methods showsPrec :: Int -> SizedList' n a -> ShowS # show :: SizedList' n a -> String # showList :: [SizedList' n a] -> ShowS #
(forall (a :: k). Show (f a)) => Show (Some1 f)
Instance details Defined in Morley.Util.Type Methods showsPrec :: Int -> Some1 f -> ShowS # show :: Some1 f -> String # showList :: [Some1 f] -> ShowS #
(Show a, Vector v a) => Show (Poly v a)
Instance details Defined in Data.Poly.Internal.Dense Methods showsPrec :: Int -> Poly v a -> ShowS # show :: Poly v a -> String # showList :: [Poly v a] -> ShowS #
Show v => Show (IntMapOf k v)
Instance details Defined in Data.Semiring Methods showsPrec :: Int -> IntMapOf k v -> ShowS # show :: IntMapOf k v -> String # showList :: [IntMapOf k v] -> ShowS #
ShowSing (Maybe a) => Show (SFirst z)
Instance details Defined in Data.Monoid.Singletons Methods showsPrec :: Int -> SFirst z -> ShowS # show :: SFirst z -> String # showList :: [SFirst z] -> ShowS #
ShowSing (Maybe a) => Show (SLast z)
Instance details Defined in Data.Monoid.Singletons Methods showsPrec :: Int -> SLast z -> ShowS # show :: SLast z -> String # showList :: [SLast z] -> ShowS #
ShowSing a => Show (SIdentity z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> SIdentity z -> ShowS # show :: SIdentity z -> String # showList :: [SIdentity z] -> ShowS #
(ShowSing a, ShowSing [a]) => Show (SList z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> SList z -> ShowS # show :: SList z -> String # showList :: [SList z] -> ShowS #
ShowSing a => Show (SMaybe z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> SMaybe z -> ShowS # show :: SMaybe z -> String # showList :: [SMaybe z] -> ShowS #
(ShowSing a, ShowSing [a]) => Show (SNonEmpty z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> SNonEmpty z -> ShowS # show :: SNonEmpty z -> String # showList :: [SNonEmpty z] -> ShowS #
(Show a, Show b) => Show (Either a b)
Instance details Defined in Data.Strict.Either Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
(Show a, Show b) => Show (These a b)
Instance details Defined in Data.Strict.These Methods showsPrec :: Int -> These a b -> ShowS # show :: These a b -> String # showList :: [These a b] -> ShowS #
(Show a, Show b) => Show (Pair a b)
Instance details Defined in Data.Strict.Tuple Methods showsPrec :: Int -> Pair a b -> ShowS # show :: Pair a b -> String # showList :: [Pair a b] -> ShowS #
(Show a, Show b) => Show (These a b)
Instance details Defined in Data.These Methods showsPrec :: Int -> These a b -> ShowS # show :: These a b -> String # showList :: [These a b] -> ShowS #
(Show1 m, Show a) => Show (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods showsPrec :: Int -> MaybeT m a -> ShowS # show :: MaybeT m a -> String # showList :: [MaybeT m a] -> ShowS #
(Show k, Show v) => Show (HashMap k v)
Instance details Defined in Data.HashMap.Internal Methods showsPrec :: Int -> HashMap k v -> ShowS # show :: HashMap k v -> String # showList :: [HashMap k v] -> ShowS #
(Show a, Show b) => Show (a, b)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b) -> ShowS # show :: (a, b) -> String # showList :: [(a, b)] -> ShowS #
(Integral a, Show a) :=> (Show (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: (Integral a, Show a) :- Show (Ratio a) #
(Show a, Show b) :=> (Show (Either a b))
Instance details Defined in Data.Constraint Methods ins :: (Show a, Show b) :- Show (Either a b) #
(Show a, Show b) :=> (Show (a, b))
Instance details Defined in Data.Constraint Methods ins :: (Show a, Show b) :- Show (a, b) #
Show a => Show (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods showsPrec :: Int -> Const a b -> ShowS # show :: Const a b -> String # showList :: [Const a b] -> ShowS #
Show (f a) => Show (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> Ap f a -> ShowS # show :: Ap f a -> String # showList :: [Ap f a] -> ShowS #
Show (f a) => Show (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Alt f a -> ShowS # show :: Alt f a -> String # showList :: [Alt f a] -> ShowS #
Show (Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods showsPrec :: Int -> Coercion a b -> ShowS # show :: Coercion a b -> String # showList :: [Coercion a b] -> ShowS #
Show (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods showsPrec :: Int -> (a :~: b) -> ShowS # show :: (a :~: b) -> String # showList :: [a :~: b] -> ShowS #
Show (f p) => Show (Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Rec1 f p -> ShowS # show :: Rec1 f p -> String # showList :: [Rec1 f p] -> ShowS #
Show (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Show (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Show (URec Float p)
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Show (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Show (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
Show (p (Fix p a) a) => Show (Fix p a)
Instance details Defined in Data.Bifunctor.Fix Methods showsPrec :: Int -> Fix p a -> ShowS # show :: Fix p a -> String # showList :: [Fix p a] -> ShowS #
Show (p a a) => Show (Join p a)
Instance details Defined in Data.Bifunctor.Join Methods showsPrec :: Int -> Join p a -> ShowS # show :: Join p a -> String # showList :: [Join p a] -> ShowS #
(Show a, Show (f b)) => Show (CofreeF f a b)
Instance details Defined in Control.Comonad.Trans.Cofree Methods showsPrec :: Int -> CofreeF f a b -> ShowS # show :: CofreeF f a b -> String # showList :: [CofreeF f a b] -> ShowS #
Show (w (CofreeF f a (CofreeT f w a))) => Show (CofreeT f w a)
Instance details Defined in Control.Comonad.Trans.Cofree Methods showsPrec :: Int -> CofreeT f w a -> ShowS # show :: CofreeT f w a -> String # showList :: [CofreeT f w a] -> ShowS #
(Show a, Show (f b)) => Show (FreeF f a b)
Instance details Defined in Control.Monad.Trans.Free Methods showsPrec :: Int -> FreeF f a b -> ShowS # show :: FreeF f a b -> String # showList :: [FreeF f a b] -> ShowS #
(Show1 f, Show1 m, Show a) => Show (FreeT f m a)
Instance details Defined in Control.Monad.Trans.Free Methods showsPrec :: Int -> FreeT f m a -> ShowS # show :: FreeT f m a -> String # showList :: [FreeT f m a] -> ShowS #
Show (Contract cp st vd)
Instance details Defined in Lorentz.Base Methods showsPrec :: Int -> Contract cp st vd -> ShowS # show :: Contract cp st vd -> String # showList :: [Contract cp st vd] -> ShowS #
(forall (i :: [T]) (o :: [T]). Show (instr i o)) => Show (Contract' instr cp st)
Instance details Defined in Morley.Michelson.Typed.Contract Methods showsPrec :: Int -> Contract' instr cp st -> ShowS # show :: Contract' instr cp st -> String # showList :: [Contract' instr cp st] -> ShowS #
Show (instr (ContractInp cp st) (ContractOut st)) => Show (ContractCode' instr cp st)
Instance details Defined in Morley.Michelson.Typed.Contract Methods showsPrec :: Int -> ContractCode' instr cp st -> ShowS # show :: ContractCode' instr cp st -> String # showList :: [ContractCode' instr cp st] -> ShowS #
Show (CreateContract instr cp st)
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> CreateContract instr cp st -> ShowS # show :: CreateContract instr cp st -> String # showList :: [CreateContract instr cp st] -> ShowS #
Show (LambdaCode' instr inp out)
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> LambdaCode' instr inp out -> ShowS # show :: LambdaCode' instr inp out -> String # showList :: [LambdaCode' instr inp out] -> ShowS #
(forall (a :: k). c a => Show (f a)) => Show (Constrained c f)
Instance details Defined in Morley.Util.Constrained Methods showsPrec :: Int -> Constrained c f -> ShowS # show :: Constrained c f -> String # showList :: [Constrained c f] -> ShowS #
Show (SProxy z)
Instance details Defined in Data.Proxy.Singletons Methods showsPrec :: Int -> SProxy z -> ShowS # show :: SProxy z -> String # showList :: [SProxy z] -> ShowS #
(ShowSing a, ShowSing b) => Show (SArg z)
Instance details Defined in Data.Semigroup.Singletons Methods showsPrec :: Int -> SArg z -> ShowS # show :: SArg z -> String # showList :: [SArg z] -> ShowS #
(ShowSing a, ShowSing b) => Show (SEither z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> SEither z -> ShowS # show :: SEither z -> String # showList :: [SEither z] -> ShowS #
(ShowSing a, ShowSing b) => Show (STuple2 z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> STuple2 z -> ShowS # show :: STuple2 z -> String # showList :: [STuple2 z] -> ShowS #
Show b => Show (Tagged s b)
Instance details Defined in Data.Tagged Methods showsPrec :: Int -> Tagged s b -> ShowS # show :: Tagged s b -> String # showList :: [Tagged s b] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (These1 f g a)
Instance details Defined in Data.Functor.These Methods showsPrec :: Int -> These1 f g a -> ShowS # show :: These1 f g a -> String # showList :: [These1 f g a] -> ShowS #
(Show e, Show1 m, Show a) => Show (ErrorT e m a)
Instance details Defined in Control.Monad.Trans.Error Methods showsPrec :: Int -> ErrorT e m a -> ShowS # show :: ErrorT e m a -> String # showList :: [ErrorT e m a] -> ShowS #
(Show e, Show1 m, Show a) => Show (ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods showsPrec :: Int -> ExceptT e m a -> ShowS # show :: ExceptT e m a -> String # showList :: [ExceptT e m a] -> ShowS #
(Show1 f, Show a) => Show (IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods showsPrec :: Int -> IdentityT f a -> ShowS # show :: IdentityT f a -> String # showList :: [IdentityT f a] -> ShowS #
(RPureConstrained (IndexableField rs) rs, RecApplicative rs, Show (Rec f rs)) => Show (ARec f rs)
Instance details Defined in Data.Vinyl.ARec.Internal Methods showsPrec :: Int -> ARec f rs -> ShowS # show :: ARec f rs -> String # showList :: [ARec f rs] -> ShowS #
(RMap rs, ReifyConstraint Show f rs, RecordToList rs) => Show (Rec f rs)	Records may be shown insofar as their points may be shown. `reifyConstraint` is used to great effect here.
Instance details Defined in Data.Vinyl.Core Methods showsPrec :: Int -> Rec f rs -> ShowS # show :: Rec f rs -> String # showList :: [Rec f rs] -> ShowS #
Show a => Show (Const a b)
Instance details Defined in Data.Vinyl.Functor Methods showsPrec :: Int -> Const a b -> ShowS # show :: Const a b -> String # showList :: [Const a b] -> ShowS #
(Show a, Show b, Show c) => Show (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c) -> ShowS # show :: (a, b, c) -> String # showList :: [(a, b, c)] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods showsPrec :: Int -> Product f g a -> ShowS # show :: Product f g a -> String # showList :: [Product f g a] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods showsPrec :: Int -> Sum f g a -> ShowS # show :: Sum f g a -> String # showList :: [Sum f g a] -> ShowS #
Show (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods showsPrec :: Int -> (a :~~: b) -> ShowS # show :: (a :~~: b) -> String # showList :: [a :~~: b] -> ShowS #
(Show (f p), Show (g p)) => Show ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :: g) p -> ShowS # show :: (f :: g) p -> String # showList :: [(f :*: g) p] -> ShowS #
(Show (f p), Show (g p)) => Show ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :+: g) p -> ShowS # show :: (f :+: g) p -> String # showList :: [(f :+: g) p] -> ShowS #
Show c => Show (K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> K1 i c p -> ShowS # show :: K1 i c p -> String # showList :: [K1 i c p] -> ShowS #
Show (BigMapId k2 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> BigMapId k2 v -> ShowS # show :: BigMapId k2 v -> String # showList :: [BigMapId k2 v] -> ShowS #
(forall (o' :: k). Show (instr i o')) => Show (RemFail instr i o)
Instance details Defined in Morley.Michelson.Typed.Value Methods showsPrec :: Int -> RemFail instr i o -> ShowS # show :: RemFail instr i o -> String # showList :: [RemFail instr i o] -> ShowS #
Show (ViewCode' instr arg st ret) => Show (View' instr arg st ret)
Instance details Defined in Morley.Michelson.Typed.View Methods showsPrec :: Int -> View' instr arg st ret -> ShowS # show :: View' instr arg st ret -> String # showList :: [View' instr arg st ret] -> ShowS #
(ShowSing a, ShowSing b, ShowSing c) => Show (STuple3 z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> STuple3 z -> ShowS # show :: STuple3 z -> String # showList :: [STuple3 z] -> ShowS #
(Show a, Show b, Show c, Show d) => Show (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d) -> ShowS # show :: (a, b, c, d) -> String # showList :: [(a, b, c, d)] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods showsPrec :: Int -> Compose f g a -> ShowS # show :: Compose f g a -> String # showList :: [Compose f g a] -> ShowS #
Show (f (g p)) => Show ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :.: g) p -> ShowS # show :: (f :.: g) p -> String # showList :: [(f :.: g) p] -> ShowS #
Show (f p) => Show (M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> M1 i c f p -> ShowS # show :: M1 i c f p -> String # showList :: [M1 i c f p] -> ShowS #
Show (f a) => Show (Clown f a b)
Instance details Defined in Data.Bifunctor.Clown Methods showsPrec :: Int -> Clown f a b -> ShowS # show :: Clown f a b -> String # showList :: [Clown f a b] -> ShowS #
Show (p b a) => Show (Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Methods showsPrec :: Int -> Flip p a b -> ShowS # show :: Flip p a b -> String # showList :: [Flip p a b] -> ShowS #
Show (g b) => Show (Joker g a b)
Instance details Defined in Data.Bifunctor.Joker Methods showsPrec :: Int -> Joker g a b -> ShowS # show :: Joker g a b -> String # showList :: [Joker g a b] -> ShowS #
Show (p a b) => Show (WrappedBifunctor p a b)
Instance details Defined in Data.Bifunctor.Wrapped Methods showsPrec :: Int -> WrappedBifunctor p a b -> ShowS # show :: WrappedBifunctor p a b -> String # showList :: [WrappedBifunctor p a b] -> ShowS #
(ShowSing a, ShowSing b, ShowSing c, ShowSing d) => Show (STuple4 z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> STuple4 z -> ShowS # show :: STuple4 z -> String # showList :: [STuple4 z] -> ShowS #
Show (f (g a)) => Show (Compose f g a)
Instance details Defined in Data.Vinyl.Functor Methods showsPrec :: Int -> Compose f g a -> ShowS # show :: Compose f g a -> String # showList :: [Compose f g a] -> ShowS #
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e) -> ShowS # show :: (a, b, c, d, e) -> String # showList :: [(a, b, c, d, e)] -> ShowS #
(Show (f a b), Show (g a b)) => Show (Product f g a b)
Instance details Defined in Data.Bifunctor.Product Methods showsPrec :: Int -> Product f g a b -> ShowS # show :: Product f g a b -> String # showList :: [Product f g a b] -> ShowS #
(Show (p a b), Show (q a b)) => Show (Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Methods showsPrec :: Int -> Sum p q a b -> ShowS # show :: Sum p q a b -> String # showList :: [Sum p q a b] -> ShowS #
(ShowSing a, ShowSing b, ShowSing c, ShowSing d, ShowSing e) => Show (STuple5 z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> STuple5 z -> ShowS # show :: STuple5 z -> String # showList :: [STuple5 z] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f) -> ShowS # show :: (a, b, c, d, e, f) -> String # showList :: [(a, b, c, d, e, f)] -> ShowS #
Show (f (p a b)) => Show (Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Methods showsPrec :: Int -> Tannen f p a b -> ShowS # show :: Tannen f p a b -> String # showList :: [Tannen f p a b] -> ShowS #
(ShowSing a, ShowSing b, ShowSing c, ShowSing d, ShowSing e, ShowSing f) => Show (STuple6 z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> STuple6 z -> ShowS # show :: STuple6 z -> String # showList :: [STuple6 z] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g) -> ShowS # show :: (a, b, c, d, e, f, g) -> String # showList :: [(a, b, c, d, e, f, g)] -> ShowS #
(ShowSing a, ShowSing b, ShowSing c, ShowSing d, ShowSing e, ShowSing f, ShowSing g) => Show (STuple7 z)
Instance details Defined in Data.Singletons.Base.Instances Methods showsPrec :: Int -> STuple7 z -> ShowS # show :: STuple7 z -> String # showList :: [STuple7 z] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h) -> ShowS # show :: (a, b, c, d, e, f, g, h) -> String # showList :: [(a, b, c, d, e, f, g, h)] -> ShowS #
Show (p (f a) (g b)) => Show (Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Methods showsPrec :: Int -> Biff p f g a b -> ShowS # show :: Biff p f g a b -> String # showList :: [Biff p f g a b] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> ShowS # show :: (a, b, c, d, e, f, g, h, i) -> String # showList :: [(a, b, c, d, e, f, g, h, i)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> ShowS #

class Typeable (a :: k) #

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

Instances

Instances details

HasDict (Typeable k, Typeable a) (TypeRep a)
Instance details Defined in Data.Constraint Methods evidence :: TypeRep a -> Dict (Typeable k, Typeable a) #

class Monad m => MonadFail (m :: Type -> Type) where #

When a value is bound in do-notation, the pattern on the left hand side of <- might not match. In this case, this class provides a function to recover.

A Monad without a MonadFail instance may only be used in conjunction with pattern that always match, such as newtypes, tuples, data types with only a single data constructor, and irrefutable patterns (~pat).

Instances of MonadFail should satisfy the following law: fail s should be a left zero for >>=,

fail s >>= f  =  fail s

If your Monad is also MonadPlus, a popular definition is

fail _ = mzero

Since: base-4.9.0.0

Methods

fail :: String -> m a #

Instances

Instances details

MonadFail IResult
Instance details Defined in Data.Aeson.Types.Internal Methods fail :: String -> IResult a #
MonadFail Parser
Instance details Defined in Data.Aeson.Types.Internal Methods fail :: String -> Parser a #
MonadFail Result
Instance details Defined in Data.Aeson.Types.Internal Methods fail :: String -> Result a #
MonadFail P	Since: base-4.9.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fail :: String -> P a #
MonadFail ReadP	Since: base-4.9.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fail :: String -> ReadP a #
MonadFail DList
Instance details Defined in Data.DList.Internal Methods fail :: String -> DList a #
MonadFail IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> IO a #
MonadFail Array
Instance details Defined in Data.Primitive.Array Methods fail :: String -> Array a #
MonadFail SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods fail :: String -> SmallArray a #
MonadFail Q
Instance details Defined in Language.Haskell.TH.Syntax Methods fail :: String -> Q a #
MonadFail Vector	Since: vector-0.12.1.0
Instance details Defined in Data.Vector Methods fail :: String -> Vector a #
MonadFail Maybe	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> Maybe a #
MonadFail []	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> [a] #
MonadFail (Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods fail :: String -> Parser i a #
MonadFail (ST s)	Since: base-4.11.0.0
Instance details Defined in GHC.ST Methods fail :: String -> ST s a #
Monad m => MonadFail (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fail :: String -> MaybeT m a #
MonadFail m => MonadFail (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods fail :: String -> RandT g m a #
MonadFail m => MonadFail (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Strict Methods fail :: String -> RandT g m a #
MonadFail f => MonadFail (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods fail :: String -> Ap f a #
(Functor f, MonadFail m) => MonadFail (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods fail :: String -> FreeT f m a #
(Monad m, Error e) => MonadFail (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods fail :: String -> ErrorT e m a #
MonadFail m => MonadFail (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods fail :: String -> ExceptT e m a #
MonadFail m => MonadFail (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods fail :: String -> IdentityT m a #
MonadFail m => MonadFail (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods fail :: String -> ReaderT r m a #
MonadFail m => MonadFail (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods fail :: String -> StateT s m a #
MonadFail m => MonadFail (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods fail :: String -> StateT s m a #

class IsString a where #

Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).

Methods

fromString :: String -> a #

Instances

Instances details

IsString Value
Instance details Defined in Data.Aeson.Types.Internal Methods fromString :: String -> Value #
IsString Alphabet
Instance details Defined in Data.ByteString.Base58.Internal Methods fromString :: String -> Alphabet #
IsString AsciiString
Instance details Defined in Basement.Types.AsciiString Methods fromString :: String -> AsciiString #
IsString String
Instance details Defined in Basement.UTF8.Base Methods fromString :: String0 -> String #
IsString ByteString	Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Internal Methods fromString :: String -> ByteString #
IsString ByteString	Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Lazy.Internal Methods fromString :: String -> ByteString #
IsString ShortByteString	Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Short.Internal Methods fromString :: String -> ShortByteString #
IsString MichelinePrimitive
Instance details Defined in Morley.Micheline.Expression Methods fromString :: String -> MichelinePrimitive #
IsString MichelsonSource
Instance details Defined in Morley.Michelson.Parser.Types Methods fromString :: String -> MichelsonSource #
IsString DocTypeRepLHS
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods fromString :: String -> DocTypeRepLHS #
IsString CommentType
Instance details Defined in Morley.Michelson.Typed.Instr Methods fromString :: String -> CommentType #
IsString Anchor
Instance details Defined in Morley.Util.Markdown Methods fromString :: String -> Anchor #
IsString Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods fromString :: String -> Doc #
IsString Builder
Instance details Defined in Data.Text.Internal.Builder Methods fromString :: String -> Builder #
IsString ShortText	Note: Surrogate pairs (`[U+D800 .. U+DFFF]`) in string literals are replaced by U+FFFD. This matches the behaviour of `IsString` instance for `Text`.
Instance details Defined in Data.Text.Short.Internal Methods fromString :: String -> ShortText #
IsString a => IsString (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Identity a #
a ~ Char => IsString (Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods fromString :: String -> Seq a #
a ~ Char => IsString (DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods fromString :: String -> DNonEmpty a #
a ~ Char => IsString (DList a)
Instance details Defined in Data.DList.Internal Methods fromString :: String -> DList a #
(IsString a, Hashable a) => IsString (Hashed a)
Instance details Defined in Data.Hashable.Class Methods fromString :: String -> Hashed a #
IsString (PrintComment st)
Instance details Defined in Morley.Michelson.Typed.Instr Methods fromString :: String -> PrintComment st #
(Bottom, TypeError ('Text "There is no instance defined for (IsString Address)" :$$: 'Text "Consider using QuasiQuotes: `[ta\|some text...\|]`") :: Constraint) => IsString (KindedAddress kind)
Instance details Defined in Morley.Tezos.Address Methods fromString :: String -> KindedAddress kind #
IsString (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fromString :: String -> Doc a #
a ~ Char => IsString [a]	`(a ~ Char)` context was introduced in `4.9.0.0` Since: base-2.1
Instance details Defined in Data.String Methods fromString :: String -> [a] #
di ~ DName => IsString (SubDoc -> di)	This instance allows writing something like `docGroup "Title"`, this makes sense as the most primitive and basic use case for doc groups is putting a section under name.
Instance details Defined in Morley.Michelson.Doc Methods fromString :: String -> SubDoc -> di #
IsString a => IsString (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Const a b #
IsString a => IsString (Tagged s a)
Instance details Defined in Data.Tagged Methods fromString :: String -> Tagged s a #

class Functor f => Applicative (f :: Type -> Type) where #

A functor with application, providing operations to

embed pure expressions (pure), and
sequence computations and combine their results (<*> and liftA2).

A minimal complete definition must include implementations of pure and of either <*> or liftA2. If it defines both, then they must behave the same as their default definitions:

(<*>) = liftA2 id

liftA2 f x y = f <$> x <*> y

Further, any definition must satisfy the following:

Identity

pure id <*> v = v

Composition

pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

Homomorphism

pure f <*> pure x = pure (f x)

Interchange

u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

```
u *> v = (id <$ u) <*> v
```
```
u <* v = liftA2 const u v
```

As a consequence of these laws, the Functor instance for f will satisfy

```
fmap f x = pure f <*> x
```

It may be useful to note that supposing

forall x y. p (q x y) = f x . g y

it follows from the above that

liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v

If f is also a Monad, it should satisfy

```
pure = return
```

m1 <*> m2 = m1 >>= (x1 -> m2 >>= (x2 -> return (x1 x2)))

```
(*>) = (>>)
```

(which implies that pure and <*> satisfy the applicative functor laws).

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a #

Lift a value.

(<*>) :: f (a -> b) -> f a -> f b infixl 4 #

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

Example

Expand

Used in combination with (<$>), (<*>) can be used to build a record.

>>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}

>>> produceFoo :: Applicative f => f Foo

>>> produceBar :: Applicative f => f Bar
>>> produceBaz :: Applicative f => f Baz

>>> mkState :: Applicative f => f MyState
>>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz

liftA2 :: (a -> b -> c) -> f a -> f b -> f c #

Lift a binary function to actions.

Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.

This became a typeclass method in 4.10.0.0. Prior to that, it was a function defined in terms of <*> and fmap.

Example

Expand

>>> liftA2 (,) (Just 3) (Just 5)
Just (3,5)

(*>) :: f a -> f b -> f b infixl 4 #

Sequence actions, discarding the value of the first argument.

Examples

Expand

If used in conjunction with the Applicative instance for Maybe, you can chain Maybe computations, with a possible "early return" in case of Nothing.

>>> Just 2 *> Just 3
Just 3

>>> Nothing *> Just 3
Nothing

Of course a more interesting use case would be to have effectful computations instead of just returning pure values.

>>> import Data.Char
>>> import Text.ParserCombinators.ReadP
>>> let p = string "my name is " *> munch1 isAlpha <* eof
>>> readP_to_S p "my name is Simon"
[("Simon","")]

(<*) :: f a -> f b -> f a infixl 4 #

Sequence actions, discarding the value of the second argument.

Instances

Instances details

Applicative IResult
Instance details Defined in Data.Aeson.Types.Internal Methods pure :: a -> IResult a # (<>) :: IResult (a -> b) -> IResult a -> IResult b # liftA2 :: (a -> b -> c) -> IResult a -> IResult b -> IResult c # (>) :: IResult a -> IResult b -> IResult b # (<*) :: IResult a -> IResult b -> IResult a #
Applicative Parser
Instance details Defined in Data.Aeson.Types.Internal Methods pure :: a -> Parser a # (<>) :: Parser (a -> b) -> Parser a -> Parser b # liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c # (>) :: Parser a -> Parser b -> Parser b # (<*) :: Parser a -> Parser b -> Parser a #
Applicative Result
Instance details Defined in Data.Aeson.Types.Internal Methods pure :: a -> Result a # (<>) :: Result (a -> b) -> Result a -> Result b # liftA2 :: (a -> b -> c) -> Result a -> Result b -> Result c # (>) :: Result a -> Result b -> Result b # (<*) :: Result a -> Result b -> Result a #
Applicative ZipList	f <$> ZipList xs1 <> ... <> ZipList xsN = ZipList (zipWithN f xs1 ... xsN) where `zipWithN` refers to the `zipWith` function of the appropriate arity (`zipWith`, `zipWith3`, `zipWith4`, ...). For example: (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <> ZipList "567" <> ZipList [1..] = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> ZipList a # (<>) :: ZipList (a -> b) -> ZipList a -> ZipList b # liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c # (>) :: ZipList a -> ZipList b -> ZipList b # (<*) :: ZipList a -> ZipList b -> ZipList a #
Applicative Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods pure :: a -> Complex a # (<>) :: Complex (a -> b) -> Complex a -> Complex b # liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c # (>) :: Complex a -> Complex b -> Complex b # (<*) :: Complex a -> Complex b -> Complex a #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a # (<>) :: Identity (a -> b) -> Identity a -> Identity b # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c # (>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Applicative First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> First a # (<>) :: First (a -> b) -> First a -> First b # liftA2 :: (a -> b -> c) -> First a -> First b -> First c # (>) :: First a -> First b -> First b # (<*) :: First a -> First b -> First a #
Applicative Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> Last a # (<>) :: Last (a -> b) -> Last a -> Last b # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c # (>) :: Last a -> Last b -> Last b # (<*) :: Last a -> Last b -> Last a #
Applicative Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods pure :: a -> Down a # (<>) :: Down (a -> b) -> Down a -> Down b # liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c # (>) :: Down a -> Down b -> Down b # (<*) :: Down a -> Down b -> Down a #
Applicative First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> First a # (<>) :: First (a -> b) -> First a -> First b # liftA2 :: (a -> b -> c) -> First a -> First b -> First c # (>) :: First a -> First b -> First b # (<*) :: First a -> First b -> First a #
Applicative Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Last a # (<>) :: Last (a -> b) -> Last a -> Last b # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c # (>) :: Last a -> Last b -> Last b # (<*) :: Last a -> Last b -> Last a #
Applicative Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Max a # (<>) :: Max (a -> b) -> Max a -> Max b # liftA2 :: (a -> b -> c) -> Max a -> Max b -> Max c # (>) :: Max a -> Max b -> Max b # (<*) :: Max a -> Max b -> Max a #
Applicative Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Min a # (<>) :: Min (a -> b) -> Min a -> Min b # liftA2 :: (a -> b -> c) -> Min a -> Min b -> Min c # (>) :: Min a -> Min b -> Min b # (<*) :: Min a -> Min b -> Min a #
Applicative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Option a # (<>) :: Option (a -> b) -> Option a -> Option b # liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c # (>) :: Option a -> Option b -> Option b # (<*) :: Option a -> Option b -> Option a #
Applicative Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Dual a # (<>) :: Dual (a -> b) -> Dual a -> Dual b # liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c # (>) :: Dual a -> Dual b -> Dual b # (<*) :: Dual a -> Dual b -> Dual a #
Applicative Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Product a # (<>) :: Product (a -> b) -> Product a -> Product b # liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c # (>) :: Product a -> Product b -> Product b # (<*) :: Product a -> Product b -> Product a #
Applicative Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Sum a # (<>) :: Sum (a -> b) -> Sum a -> Sum b # liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c # (>) :: Sum a -> Sum b -> Sum b # (<*) :: Sum a -> Sum b -> Sum a #
Applicative NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods pure :: a -> NonEmpty a # (<>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b # liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c # (>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a #
Applicative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods pure :: a -> STM a # (<>) :: STM (a -> b) -> STM a -> STM b # liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c # (>) :: STM a -> STM b -> STM b # (<*) :: STM a -> STM b -> STM a #
Applicative Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Par1 a # (<>) :: Par1 (a -> b) -> Par1 a -> Par1 b # liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c # (>) :: Par1 a -> Par1 b -> Par1 b # (<*) :: Par1 a -> Par1 b -> Par1 a #
Applicative P	Since: base-4.5.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods pure :: a -> P a # (<>) :: P (a -> b) -> P a -> P b # liftA2 :: (a -> b -> c) -> P a -> P b -> P c # (>) :: P a -> P b -> P b # (<*) :: P a -> P b -> P a #
Applicative ReadP	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods pure :: a -> ReadP a # (<>) :: ReadP (a -> b) -> ReadP a -> ReadP b # liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c # (>) :: ReadP a -> ReadP b -> ReadP b # (<*) :: ReadP a -> ReadP b -> ReadP a #
Applicative Put
Instance details Defined in Data.ByteString.Builder.Internal Methods pure :: a -> Put a # (<>) :: Put (a -> b) -> Put a -> Put b # liftA2 :: (a -> b -> c) -> Put a -> Put b -> Put c # (>) :: Put a -> Put b -> Put b # (<*) :: Put a -> Put b -> Put a #
Applicative Identifier
Instance details Defined in Text.Casing Methods pure :: a -> Identifier a # (<>) :: Identifier (a -> b) -> Identifier a -> Identifier b # liftA2 :: (a -> b -> c) -> Identifier a -> Identifier b -> Identifier c # (>) :: Identifier a -> Identifier b -> Identifier b # (<*) :: Identifier a -> Identifier b -> Identifier a #
Applicative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods pure :: a -> Seq a # (<>) :: Seq (a -> b) -> Seq a -> Seq b # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c # (>) :: Seq a -> Seq b -> Seq b # (<*) :: Seq a -> Seq b -> Seq a #
Applicative Tree
Instance details Defined in Data.Tree Methods pure :: a -> Tree a # (<>) :: Tree (a -> b) -> Tree a -> Tree b # liftA2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c # (>) :: Tree a -> Tree b -> Tree b # (<*) :: Tree a -> Tree b -> Tree a #
Applicative CryptoFailable
Instance details Defined in Crypto.Error.Types Methods pure :: a -> CryptoFailable a # (<>) :: CryptoFailable (a -> b) -> CryptoFailable a -> CryptoFailable b # liftA2 :: (a -> b -> c) -> CryptoFailable a -> CryptoFailable b -> CryptoFailable c # (>) :: CryptoFailable a -> CryptoFailable b -> CryptoFailable b # (<*) :: CryptoFailable a -> CryptoFailable b -> CryptoFailable a #
Applicative DNonEmpty
Instance details Defined in Data.DList.DNonEmpty.Internal Methods pure :: a -> DNonEmpty a # (<>) :: DNonEmpty (a -> b) -> DNonEmpty a -> DNonEmpty b # liftA2 :: (a -> b -> c) -> DNonEmpty a -> DNonEmpty b -> DNonEmpty c # (>) :: DNonEmpty a -> DNonEmpty b -> DNonEmpty b # (<*) :: DNonEmpty a -> DNonEmpty b -> DNonEmpty a #
Applicative DList
Instance details Defined in Data.DList.Internal Methods pure :: a -> DList a # (<>) :: DList (a -> b) -> DList a -> DList b # liftA2 :: (a -> b -> c) -> DList a -> DList b -> DList c # (>) :: DList a -> DList b -> DList b # (<*) :: DList a -> DList b -> DList a #
Applicative IO	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> IO a # (<>) :: IO (a -> b) -> IO a -> IO b # liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c # (>) :: IO a -> IO b -> IO b # (<*) :: IO a -> IO b -> IO a #
Applicative IndigoM Source #
Instance details Defined in Indigo.Frontend.Program Methods pure :: a -> IndigoM a # (<>) :: IndigoM (a -> b) -> IndigoM a -> IndigoM b # liftA2 :: (a -> b -> c) -> IndigoM a -> IndigoM b -> IndigoM c # (>) :: IndigoM a -> IndigoM b -> IndigoM b # (<*) :: IndigoM a -> IndigoM b -> IndigoM a #
Applicative WithFinalizedDoc
Instance details Defined in Morley.Michelson.Doc Methods pure :: a -> WithFinalizedDoc a # (<>) :: WithFinalizedDoc (a -> b) -> WithFinalizedDoc a -> WithFinalizedDoc b # liftA2 :: (a -> b -> c) -> WithFinalizedDoc a -> WithFinalizedDoc b -> WithFinalizedDoc c # (>) :: WithFinalizedDoc a -> WithFinalizedDoc b -> WithFinalizedDoc b # (<*) :: WithFinalizedDoc a -> WithFinalizedDoc b -> WithFinalizedDoc a #
Applicative EvalOp
Instance details Defined in Morley.Michelson.Interpret Methods pure :: a -> EvalOp a # (<>) :: EvalOp (a -> b) -> EvalOp a -> EvalOp b # liftA2 :: (a -> b -> c) -> EvalOp a -> EvalOp b -> EvalOp c # (>) :: EvalOp a -> EvalOp b -> EvalOp b # (<*) :: EvalOp a -> EvalOp b -> EvalOp a #
Applicative Array
Instance details Defined in Data.Primitive.Array Methods pure :: a -> Array a # (<>) :: Array (a -> b) -> Array a -> Array b # liftA2 :: (a -> b -> c) -> Array a -> Array b -> Array c # (>) :: Array a -> Array b -> Array b # (<*) :: Array a -> Array b -> Array a #
Applicative SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods pure :: a -> SmallArray a # (<>) :: SmallArray (a -> b) -> SmallArray a -> SmallArray b # liftA2 :: (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c # (>) :: SmallArray a -> SmallArray b -> SmallArray b # (<*) :: SmallArray a -> SmallArray b -> SmallArray a #
Applicative PprM
Instance details Defined in Language.Haskell.TH.PprLib Methods pure :: a -> PprM a # (<>) :: PprM (a -> b) -> PprM a -> PprM b # liftA2 :: (a -> b -> c) -> PprM a -> PprM b -> PprM c # (>) :: PprM a -> PprM b -> PprM b # (<*) :: PprM a -> PprM b -> PprM a #
Applicative Q
Instance details Defined in Language.Haskell.TH.Syntax Methods pure :: a -> Q a # (<>) :: Q (a -> b) -> Q a -> Q b # liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c # (>) :: Q a -> Q b -> Q b # (<*) :: Q a -> Q b -> Q a #
Applicative Vector
Instance details Defined in Data.Vector Methods pure :: a -> Vector a # (<>) :: Vector (a -> b) -> Vector a -> Vector b # liftA2 :: (a -> b -> c) -> Vector a -> Vector b -> Vector c # (>) :: Vector a -> Vector b -> Vector b # (<*) :: Vector a -> Vector b -> Vector a #
Applicative Identity
Instance details Defined in Data.Vinyl.Functor Methods pure :: a -> Identity a # (<>) :: Identity (a -> b) -> Identity a -> Identity b # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c # (>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Applicative Thunk
Instance details Defined in Data.Vinyl.Functor Methods pure :: a -> Thunk a # (<>) :: Thunk (a -> b) -> Thunk a -> Thunk b # liftA2 :: (a -> b -> c) -> Thunk a -> Thunk b -> Thunk c # (>) :: Thunk a -> Thunk b -> Thunk b # (<*) :: Thunk a -> Thunk b -> Thunk a #
Applicative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # (>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Applicative Solo	Since: base-4.15
Instance details Defined in GHC.Base Methods pure :: a -> Solo a # (<>) :: Solo (a -> b) -> Solo a -> Solo b # liftA2 :: (a -> b -> c) -> Solo a -> Solo b -> Solo c # (>) :: Solo a -> Solo b -> Solo b # (<*) :: Solo a -> Solo b -> Solo a #
Applicative []	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> [a] # (<>) :: [a -> b] -> [a] -> [b] # liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] # (>) :: [a] -> [b] -> [b] # (<*) :: [a] -> [b] -> [a] #
() :=> (Applicative (Either a))
Instance details Defined in Data.Constraint Methods ins :: () :- Applicative (Either a) #
() :=> (Applicative IO)
Instance details Defined in Data.Constraint Methods ins :: () :- Applicative IO #
() :=> (Applicative Maybe)
Instance details Defined in Data.Constraint Methods ins :: () :- Applicative Maybe #
() :=> (Applicative ((->) a))
Instance details Defined in Data.Constraint Methods ins :: () :- Applicative ((->) a) #
() :=> (Applicative [])
Instance details Defined in Data.Constraint Methods ins :: () :- Applicative [] #
Representable f => Applicative (Co f)
Instance details Defined in Data.Functor.Rep Methods pure :: a -> Co f a # (<>) :: Co f (a -> b) -> Co f a -> Co f b # liftA2 :: (a -> b -> c) -> Co f a -> Co f b -> Co f c # (>) :: Co f a -> Co f b -> Co f b # (<*) :: Co f a -> Co f b -> Co f a #
Applicative (Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods pure :: a -> Parser i a # (<>) :: Parser i (a -> b) -> Parser i a -> Parser i b # liftA2 :: (a -> b -> c) -> Parser i a -> Parser i b -> Parser i c # (>) :: Parser i a -> Parser i b -> Parser i b # (<*) :: Parser i a -> Parser i b -> Parser i a #
Monad m => Applicative (WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a #
Arrow a => Applicative (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 #
Applicative (Either e)	Since: base-3.0
Instance details Defined in Data.Either Methods pure :: a -> Either e a # (<>) :: Either e (a -> b) -> Either e a -> Either e b # liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c # (>) :: Either e a -> Either e b -> Either e b # (<*) :: Either e a -> Either e b -> Either e a #
Applicative (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details 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 #
Applicative (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> U1 a # (<>) :: U1 (a -> b) -> U1 a -> U1 b # liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c # (>) :: U1 a -> U1 b -> U1 b # (<*) :: U1 a -> U1 b -> U1 a #
Applicative (ST s)	Since: base-4.4.0.0
Instance details Defined in GHC.ST Methods pure :: a -> ST s a # (<>) :: ST s (a -> b) -> ST s a -> ST s b # liftA2 :: (a -> b -> c) -> ST s a -> ST s b -> ST s c # (>) :: ST s a -> ST s b -> ST s b # (<*) :: ST s a -> ST s b -> ST s a #
Applicative (SetM s)
Instance details Defined in Data.Graph Methods pure :: a -> SetM s a # (<>) :: SetM s (a -> b) -> SetM s a -> SetM s b # liftA2 :: (a -> b -> c) -> SetM s a -> SetM s b -> SetM s c # (>) :: SetM s a -> SetM s b -> SetM s b # (<*) :: SetM s a -> SetM s b -> SetM s a #
DRG gen => Applicative (MonadPseudoRandom gen)
Instance details Defined in Crypto.Random.Types Methods pure :: a -> MonadPseudoRandom gen a # (<>) :: MonadPseudoRandom gen (a -> b) -> MonadPseudoRandom gen a -> MonadPseudoRandom gen b # liftA2 :: (a -> b -> c) -> MonadPseudoRandom gen a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen c # (>) :: MonadPseudoRandom gen a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen b # (<*) :: MonadPseudoRandom gen a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen a #
Alternative f => Applicative (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods pure :: a -> Cofree f a # (<>) :: Cofree f (a -> b) -> Cofree f a -> Cofree f b # liftA2 :: (a -> b -> c) -> Cofree f a -> Cofree f b -> Cofree f c # (>) :: Cofree f a -> Cofree f b -> Cofree f b # (<*) :: Cofree f a -> Cofree f b -> Cofree f a #
Functor f => Applicative (Free f)
Instance details Defined in Control.Monad.Free Methods pure :: a -> Free f a # (<>) :: Free f (a -> b) -> Free f a -> Free f b # liftA2 :: (a -> b -> c) -> Free f a -> Free f b -> Free f c # (>) :: Free f a -> Free f b -> Free f b # (<*) :: Free f a -> Free f b -> Free f a #
Applicative (Program instr) Source #
Instance details Defined in Indigo.Frontend.Program Methods pure :: a -> Program instr a # (<>) :: Program instr (a -> b) -> Program instr a -> Program instr b # liftA2 :: (a -> b -> c) -> Program instr a -> Program instr b -> Program instr c # (>) :: Program instr a -> Program instr b -> Program instr b # (<*) :: Program instr a -> Program instr b -> Program instr a #
Applicative f => Applicative (Yoneda f)
Instance details Defined in Data.Functor.Yoneda Methods pure :: a -> Yoneda f a # (<>) :: Yoneda f (a -> b) -> Yoneda f a -> Yoneda f b # liftA2 :: (a -> b -> c) -> Yoneda f a -> Yoneda f b -> Yoneda f c # (>) :: Yoneda f a -> Yoneda f b -> Yoneda f b # (<*) :: Yoneda f a -> Yoneda f b -> Yoneda f a #
Applicative f => Applicative (Indexing f)
Instance details Defined in Control.Lens.Internal.Indexed Methods pure :: a -> Indexing f a # (<>) :: Indexing f (a -> b) -> Indexing f a -> Indexing f b # liftA2 :: (a -> b -> c) -> Indexing f a -> Indexing f b -> Indexing f c # (>) :: Indexing f a -> Indexing f b -> Indexing f b # (<*) :: Indexing f a -> Indexing f b -> Indexing f a #
Applicative f => Applicative (Indexing64 f)
Instance details Defined in Control.Lens.Internal.Indexed Methods pure :: a -> Indexing64 f a # (<>) :: Indexing64 f (a -> b) -> Indexing64 f a -> Indexing64 f b # liftA2 :: (a -> b -> c) -> Indexing64 f a -> Indexing64 f b -> Indexing64 f c # (>) :: Indexing64 f a -> Indexing64 f b -> Indexing64 f b # (<*) :: Indexing64 f a -> Indexing64 f b -> Indexing64 f a #
Applicative (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods pure :: a -> ReifiedFold s a # (<>) :: ReifiedFold s (a -> b) -> ReifiedFold s a -> ReifiedFold s b # liftA2 :: (a -> b -> c) -> ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s c # (>) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b # (<*) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s a #
Applicative (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods pure :: a -> ReifiedGetter s a # (<>) :: ReifiedGetter s (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b # liftA2 :: (a -> b -> c) -> ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s c # (>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b # (<*) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s a #
SingI n => Applicative (SizedList' n)
Instance details Defined in Morley.Util.SizedList Methods pure :: a -> SizedList' n a # (<>) :: SizedList' n (a -> b) -> SizedList' n a -> SizedList' n b # liftA2 :: (a -> b -> c) -> SizedList' n a -> SizedList' n b -> SizedList' n c # (>) :: SizedList' n a -> SizedList' n b -> SizedList' n b # (<*) :: SizedList' n a -> SizedList' n b -> SizedList' n a #
Semigroup a => Applicative (These a)
Instance details Defined in Data.Strict.These Methods pure :: a0 -> These a a0 # (<>) :: These a (a0 -> b) -> These a a0 -> These a b # liftA2 :: (a0 -> b -> c) -> These a a0 -> These a b -> These a c # (>) :: These a a0 -> These a b -> These a b # (<*) :: These a a0 -> These a b -> These a a0 #
Semigroup a => Applicative (These a)
Instance details Defined in Data.These Methods pure :: a0 -> These a a0 # (<>) :: These a (a0 -> b) -> These a a0 -> These a b # liftA2 :: (a0 -> b -> c) -> These a a0 -> These a b -> These a c # (>) :: These a a0 -> These a b -> These a b # (<*) :: These a a0 -> These a b -> These a a0 #
(Functor m, Monad m) => Applicative (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods pure :: a -> MaybeT m a # (<>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b # liftA2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c # (>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # (<*) :: MaybeT m a -> MaybeT m b -> MaybeT m a #
Monoid a => Applicative ((,) a)	For tuples, the `Monoid` constraint on `a` determines how the first values merge. For example, `String`s concatenate: ("hello ", (+15)) <> ("world!", 2002) ("hello world!",2017) Since: base-2.1*
Instance details Defined in GHC.Base Methods pure :: a0 -> (a, a0) # (<>) :: (a, a0 -> b) -> (a, a0) -> (a, b) # liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c) # (>) :: (a, a0) -> (a, b) -> (a, b) # (<*) :: (a, a0) -> (a, b) -> (a, a0) #
(Monad m) :=> (Applicative (WrappedMonad m))
Instance details Defined in Data.Constraint Methods ins :: Monad m :- Applicative (WrappedMonad m) #
(Monoid a) :=> (Applicative (Const a :: Type -> Type))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Applicative (Const a) #
(Monoid a) :=> (Applicative ((,) a))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Applicative ((,) a) #
Class (Applicative f) (Alternative f)
Instance details Defined in Data.Constraint Methods cls :: Alternative f :- Applicative f #
Class (Applicative f) (Monad f)
Instance details Defined in Data.Constraint Methods cls :: Monad f :- Applicative f #
Class (Functor f) (Applicative f)
Instance details Defined in Data.Constraint Methods cls :: Applicative f :- Functor f #
Monad m => Applicative (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods pure :: a -> RandT g m a # (<>) :: RandT g m (a -> b) -> RandT g m a -> RandT g m b # liftA2 :: (a -> b -> c) -> RandT g m a -> RandT g m b -> RandT g m c # (>) :: RandT g m a -> RandT g m b -> RandT g m b # (<*) :: RandT g m a -> RandT g m b -> RandT g m a #
Monad m => Applicative (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Strict Methods pure :: a -> RandT g m a # (<>) :: RandT g m (a -> b) -> RandT g m a -> RandT g m b # liftA2 :: (a -> b -> c) -> RandT g m a -> RandT g m b -> RandT g m c # (>) :: RandT g m a -> RandT g m b -> RandT g m b # (<*) :: RandT g m a -> RandT g m b -> RandT g m a #
Arrow a => Applicative (WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 #
Applicative m => Applicative (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods pure :: a0 -> Kleisli m a a0 # (<>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b # liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c # (>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b # (<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0 #
Monoid m => Applicative (Const m :: Type -> Type)	Since: base-2.0.1
Instance details Defined in Data.Functor.Const Methods pure :: a -> Const m a # (<>) :: Const m (a -> b) -> Const m a -> Const m b # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c # (>) :: Const m a -> Const m b -> Const m b # (<*) :: Const m a -> Const m b -> Const m a #
Applicative f => Applicative (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> Ap f a # (<>) :: Ap f (a -> b) -> Ap f a -> Ap f b # liftA2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c # (>) :: Ap f a -> Ap f b -> Ap f b # (<*) :: Ap f a -> Ap f b -> Ap f a #
Applicative f => Applicative (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Alt f a # (<>) :: Alt f (a -> b) -> Alt f a -> Alt f b # liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c # (>) :: Alt f a -> Alt f b -> Alt f b # (<*) :: Alt f a -> Alt f b -> Alt f a #
Applicative f => Applicative (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Rec1 f a # (<>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b # liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c # (>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # (<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a #
Biapplicative p => Applicative (Fix p)
Instance details Defined in Data.Bifunctor.Fix Methods pure :: a -> Fix p a # (<>) :: Fix p (a -> b) -> Fix p a -> Fix p b # liftA2 :: (a -> b -> c) -> Fix p a -> Fix p b -> Fix p c # (>) :: Fix p a -> Fix p b -> Fix p b # (<*) :: Fix p a -> Fix p b -> Fix p a #
Biapplicative p => Applicative (Join p)
Instance details Defined in Data.Bifunctor.Join Methods pure :: a -> Join p a # (<>) :: Join p (a -> b) -> Join p a -> Join p b # liftA2 :: (a -> b -> c) -> Join p a -> Join p b -> Join p c # (>) :: Join p a -> Join p b -> Join p b # (<*) :: Join p a -> Join p b -> Join p a #
(Applicative f, Monad f) => Applicative (WhenMissing f x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))`. Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c # (>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a #
(Alternative f, Applicative w) => Applicative (CofreeT f w)
Instance details Defined in Control.Comonad.Trans.Cofree Methods pure :: a -> CofreeT f w a # (<>) :: CofreeT f w (a -> b) -> CofreeT f w a -> CofreeT f w b # liftA2 :: (a -> b -> c) -> CofreeT f w a -> CofreeT f w b -> CofreeT f w c # (>) :: CofreeT f w a -> CofreeT f w b -> CofreeT f w b # (<*) :: CofreeT f w a -> CofreeT f w b -> CofreeT f w a #
(Functor f, Monad m) => Applicative (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods pure :: a -> FreeT f m a # (<>) :: FreeT f m (a -> b) -> FreeT f m a -> FreeT f m b # liftA2 :: (a -> b -> c) -> FreeT f m a -> FreeT f m b -> FreeT f m c # (>) :: FreeT f m a -> FreeT f m b -> FreeT f m b # (<*) :: FreeT f m a -> FreeT f m b -> FreeT f m a #
(Applicative f, Applicative g) => Applicative (Day f g)
Instance details Defined in Data.Functor.Day Methods pure :: a -> Day f g a # (<>) :: Day f g (a -> b) -> Day f g a -> Day f g b # liftA2 :: (a -> b -> c) -> Day f g a -> Day f g b -> Day f g c # (>) :: Day f g a -> Day f g b -> Day f g b # (<*) :: Day f g a -> Day f g b -> Day f g a #
Applicative (Indexed i a)
Instance details Defined in Control.Lens.Internal.Indexed Methods pure :: a0 -> Indexed i a a0 # (<>) :: Indexed i a (a0 -> b) -> Indexed i a a0 -> Indexed i a b # liftA2 :: (a0 -> b -> c) -> Indexed i a a0 -> Indexed i a b -> Indexed i a c # (>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b # (<*) :: Indexed i a a0 -> Indexed i a b -> Indexed i a a0 #
(Monad m, Monoid r) => Applicative (Effect m r)
Instance details Defined in Lens.Micro.Mtl.Internal Methods pure :: a -> Effect m r a # (<>) :: Effect m r (a -> b) -> Effect m r a -> Effect m r b # liftA2 :: (a -> b -> c) -> Effect m r a -> Effect m r b -> Effect m r c # (>) :: Effect m r a -> Effect m r b -> Effect m r b # (<*) :: Effect m r a -> Effect m r b -> Effect m r a #
(Monad m, Monoid s) => Applicative (Focusing m s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods pure :: a -> Focusing m s a # (<>) :: Focusing m s (a -> b) -> Focusing m s a -> Focusing m s b # liftA2 :: (a -> b -> c) -> Focusing m s a -> Focusing m s b -> Focusing m s c # (>) :: Focusing m s a -> Focusing m s b -> Focusing m s b # (<*) :: Focusing m s a -> Focusing m s b -> Focusing m s a #
Applicative (k (May s)) => Applicative (FocusingMay k s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods pure :: a -> FocusingMay k s a # (<>) :: FocusingMay k s (a -> b) -> FocusingMay k s a -> FocusingMay k s b # liftA2 :: (a -> b -> c) -> FocusingMay k s a -> FocusingMay k s b -> FocusingMay k s c # (>) :: FocusingMay k s a -> FocusingMay k s b -> FocusingMay k s b # (<*) :: FocusingMay k s a -> FocusingMay k s b -> FocusingMay k s a #
Applicative f => Applicative (ApplicativeBoolean f)
Instance details Defined in Morley.Prelude.Boolean Methods pure :: a -> ApplicativeBoolean f a # (<>) :: ApplicativeBoolean f (a -> b) -> ApplicativeBoolean f a -> ApplicativeBoolean f b # liftA2 :: (a -> b -> c) -> ApplicativeBoolean f a -> ApplicativeBoolean f b -> ApplicativeBoolean f c # (>) :: ApplicativeBoolean f a -> ApplicativeBoolean f b -> ApplicativeBoolean f b # (<*) :: ApplicativeBoolean f a -> ApplicativeBoolean f b -> ApplicativeBoolean f a #
(Applicative (Rep p), Representable p) => Applicative (Prep p)
Instance details Defined in Data.Profunctor.Rep Methods pure :: a -> Prep p a # (<>) :: Prep p (a -> b) -> Prep p a -> Prep p b # liftA2 :: (a -> b -> c) -> Prep p a -> Prep p b -> Prep p c # (>) :: Prep p a -> Prep p b -> Prep p b # (<*) :: Prep p a -> Prep p b -> Prep p a #
Applicative (Tagged s)
Instance details Defined in Data.Tagged Methods pure :: a -> Tagged s a # (<>) :: Tagged s (a -> b) -> Tagged s a -> Tagged s b # liftA2 :: (a -> b -> c) -> Tagged s a -> Tagged s b -> Tagged s c # (>) :: Tagged s a -> Tagged s b -> Tagged s b # (<*) :: Tagged s a -> Tagged s b -> Tagged s a #
(Functor m, Monad m) => Applicative (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods pure :: a -> ErrorT e m a # (<>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b # liftA2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c # (>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b # (<*) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a #
(Functor m, Monad m) => Applicative (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods pure :: a -> ExceptT e m a # (<>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b # liftA2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c # (>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # (<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a #
Applicative m => Applicative (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods pure :: a -> IdentityT m a # (<>) :: IdentityT m (a -> b) -> IdentityT m a -> IdentityT m b # liftA2 :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c # (>) :: IdentityT m a -> IdentityT m b -> IdentityT m b # (<*) :: IdentityT m a -> IdentityT m b -> IdentityT m a #
Applicative m => Applicative (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods pure :: a -> ReaderT r m a # (<>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b # liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c # (>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # (<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a #
(Functor m, Monad m) => Applicative (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods pure :: a -> StateT s m a # (<>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c # (>) :: StateT s m a -> StateT s m b -> StateT s m b # (<*) :: StateT s m a -> StateT s m b -> StateT s m a #
(Functor m, Monad m) => Applicative (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods pure :: a -> StateT s m a # (<>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c # (>) :: StateT s m a -> StateT s m b -> StateT s m b # (<*) :: StateT s m a -> StateT s m b -> StateT s m a #
(Monoid a, Monoid b) => Applicative ((,,) a b)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods pure :: a0 -> (a, b, a0) # (<>) :: (a, b, a0 -> b0) -> (a, b, a0) -> (a, b, b0) # liftA2 :: (a0 -> b0 -> c) -> (a, b, a0) -> (a, b, b0) -> (a, b, c) # (>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) # (<*) :: (a, b, a0) -> (a, b, b0) -> (a, b, a0) #
(Applicative f, Applicative g) => Applicative (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods pure :: a -> Product f g a # (<>) :: Product f g (a -> b) -> Product f g a -> Product f g b # liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c # (>) :: Product f g a -> Product f g b -> Product f g b # (<*) :: Product f g a -> Product f g b -> Product f g a #
(Applicative f, Applicative g) => Applicative (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> (f :: g) a # (<>) :: (f :: g) (a -> b) -> (f :: g) a -> (f :: g) b # liftA2 :: (a -> b -> c) -> (f :: g) a -> (f :: g) b -> (f :: g) c # (>) :: (f :: g) a -> (f :: g) b -> (f :: g) b # (<) :: (f :: g) a -> (f :: g) b -> (f :: g) a #
Monoid c => Applicative (K1 i c :: Type -> Type)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> K1 i c a # (<>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b # liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 # (>) :: K1 i c a -> K1 i c b -> K1 i c b # (<*) :: K1 i c a -> K1 i c b -> K1 i c a #
(Monad f, Applicative f) => Applicative (WhenMatched f x y)	Equivalent to `ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c # (>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a #
(Applicative f, Monad f) => Applicative (WhenMissing f k x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))` . Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a # (<>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c # (>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a #
Applicative (k (Err e s)) => Applicative (FocusingErr e k s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods pure :: a -> FocusingErr e k s a # (<>) :: FocusingErr e k s (a -> b) -> FocusingErr e k s a -> FocusingErr e k s b # liftA2 :: (a -> b -> c) -> FocusingErr e k s a -> FocusingErr e k s b -> FocusingErr e k s c # (>) :: FocusingErr e k s a -> FocusingErr e k s b -> FocusingErr e k s b # (<*) :: FocusingErr e k s a -> FocusingErr e k s b -> FocusingErr e k s a #
Applicative (k (f s)) => Applicative (FocusingOn f k s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods pure :: a -> FocusingOn f k s a # (<>) :: FocusingOn f k s (a -> b) -> FocusingOn f k s a -> FocusingOn f k s b # liftA2 :: (a -> b -> c) -> FocusingOn f k s a -> FocusingOn f k s b -> FocusingOn f k s c # (>) :: FocusingOn f k s a -> FocusingOn f k s b -> FocusingOn f k s b # (<*) :: FocusingOn f k s a -> FocusingOn f k s b -> FocusingOn f k s a #
Applicative (k (s, w)) => Applicative (FocusingPlus w k s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods pure :: a -> FocusingPlus w k s a # (<>) :: FocusingPlus w k s (a -> b) -> FocusingPlus w k s a -> FocusingPlus w k s b # liftA2 :: (a -> b -> c) -> FocusingPlus w k s a -> FocusingPlus w k s b -> FocusingPlus w k s c # (>) :: FocusingPlus w k s a -> FocusingPlus w k s b -> FocusingPlus w k s b # (<*) :: FocusingPlus w k s a -> FocusingPlus w k s b -> FocusingPlus w k s a #
(Monad m, Monoid s, Monoid w) => Applicative (FocusingWith w m s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods pure :: a -> FocusingWith w m s a # (<>) :: FocusingWith w m s (a -> b) -> FocusingWith w m s a -> FocusingWith w m s b # liftA2 :: (a -> b -> c) -> FocusingWith w m s a -> FocusingWith w m s b -> FocusingWith w m s c # (>) :: FocusingWith w m s a -> FocusingWith w m s b -> FocusingWith w m s b # (<*) :: FocusingWith w m s a -> FocusingWith w m s b -> FocusingWith w m s a #
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods pure :: a0 -> (a, b, c, a0) # (<>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) # liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0) # (>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) # (<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0) #
Applicative ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> r -> a # (<>) :: (r -> (a -> b)) -> (r -> a) -> r -> b # liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c # (>) :: (r -> a) -> (r -> b) -> r -> b # (<*) :: (r -> a) -> (r -> b) -> r -> a #
(Applicative f, Applicative g) => Applicative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods pure :: a -> Compose f g a # (<>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c # (>) :: Compose f g a -> Compose f g b -> Compose f g b # (<*) :: Compose f g a -> Compose f g b -> Compose f g a #
(Applicative f, Applicative g) => Applicative (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> (f :.: g) a # (<>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b # liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c # (>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b # (<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a #
Applicative f => Applicative (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> M1 i c f a # (<>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b # liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0 # (>) :: M1 i c f a -> M1 i c f b -> M1 i c f b # (<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a #
(Monad f, Applicative f) => Applicative (WhenMatched f k x y)	Equivalent to `ReaderT k (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a # (<>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c # (>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a #
(Monoid s, Monoid w, Monad m) => Applicative (EffectRWS w st m s)
Instance details Defined in Lens.Micro.Mtl.Internal Methods pure :: a -> EffectRWS w st m s a # (<>) :: EffectRWS w st m s (a -> b) -> EffectRWS w st m s a -> EffectRWS w st m s b # liftA2 :: (a -> b -> c) -> EffectRWS w st m s a -> EffectRWS w st m s b -> EffectRWS w st m s c # (>) :: EffectRWS w st m s a -> EffectRWS w st m s b -> EffectRWS w st m s b # (<*) :: EffectRWS w st m s a -> EffectRWS w st m s b -> EffectRWS w st m s a #
Reifies s (ReifiedApplicative f) => Applicative (ReflectedApplicative f s)
Instance details Defined in Data.Reflection Methods pure :: a -> ReflectedApplicative f s a # (<>) :: ReflectedApplicative f s (a -> b) -> ReflectedApplicative f s a -> ReflectedApplicative f s b # liftA2 :: (a -> b -> c) -> ReflectedApplicative f s a -> ReflectedApplicative f s b -> ReflectedApplicative f s c # (>) :: ReflectedApplicative f s a -> ReflectedApplicative f s b -> ReflectedApplicative f s b # (<*) :: ReflectedApplicative f s a -> ReflectedApplicative f s b -> ReflectedApplicative f s a #
(Applicative f, Applicative g) => Applicative (Compose f g)
Instance details Defined in Data.Vinyl.Functor Methods pure :: a -> Compose f g a # (<>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c # (>) :: Compose f g a -> Compose f g b -> Compose f g b # (<*) :: Compose f g a -> Compose f g b -> Compose f g a #
Monad state => Applicative (Builder collection mutCollection step state err)
Instance details Defined in Basement.MutableBuilder Methods pure :: a -> Builder collection mutCollection step state err a # (<>) :: Builder collection mutCollection step state err (a -> b) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b # liftA2 :: (a -> b -> c) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err c # (>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b # (<*) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err a #
(Applicative f, Applicative g) => Applicative (Lift (,) f g)
Instance details Defined in Data.Vinyl.Functor Methods pure :: a -> Lift (,) f g a # (<>) :: Lift (,) f g (a -> b) -> Lift (,) f g a -> Lift (,) f g b # liftA2 :: (a -> b -> c) -> Lift (,) f g a -> Lift (,) f g b -> Lift (,) f g c # (>) :: Lift (,) f g a -> Lift (,) f g b -> Lift (,) f g b # (<*) :: Lift (,) f g a -> Lift (,) f g b -> Lift (,) f g a #

class Foldable (t :: Type -> Type) #

The Foldable class represents data structures that can be reduced to a summary value one element at a time. Strict left-associative folds are a good fit for space-efficient reduction, while lazy right-associative folds are a good fit for corecursive iteration, or for folds that short-circuit after processing an initial subsequence of the structure's elements.

Instances can be derived automatically by enabling the DeriveFoldable extension. For example, a derived instance for a binary tree might be:

{-# LANGUAGE DeriveFoldable #-}
data Tree a = Empty
            | Leaf a
            | Node (Tree a) a (Tree a)
    deriving Foldable

A more detailed description can be found in the Overview section of Data.Foldable.

For the class laws see the Laws section of Data.Foldable.

Minimal complete definition

foldMap | foldr

Instances

Instances details

Foldable KeyMap
Instance details Defined in Data.Aeson.KeyMap Methods fold :: Monoid m => KeyMap m -> m # foldMap :: Monoid m => (a -> m) -> KeyMap a -> m # foldMap' :: Monoid m => (a -> m) -> KeyMap a -> m # foldr :: (a -> b -> b) -> b -> KeyMap a -> b # foldr' :: (a -> b -> b) -> b -> KeyMap a -> b # foldl :: (b -> a -> b) -> b -> KeyMap a -> b # foldl' :: (b -> a -> b) -> b -> KeyMap a -> b # foldr1 :: (a -> a -> a) -> KeyMap a -> a # foldl1 :: (a -> a -> a) -> KeyMap a -> a # toList :: KeyMap a -> [a] # null :: KeyMap a -> Bool # length :: KeyMap a -> Int # elem :: Eq a => a -> KeyMap a -> Bool # maximum :: Ord a => KeyMap a -> a # minimum :: Ord a => KeyMap a -> a # sum :: Num a => KeyMap a -> a # product :: Num a => KeyMap a -> a #
Foldable IResult
Instance details Defined in Data.Aeson.Types.Internal Methods fold :: Monoid m => IResult m -> m # foldMap :: Monoid m => (a -> m) -> IResult a -> m # foldMap' :: Monoid m => (a -> m) -> IResult a -> m # foldr :: (a -> b -> b) -> b -> IResult a -> b # foldr' :: (a -> b -> b) -> b -> IResult a -> b # foldl :: (b -> a -> b) -> b -> IResult a -> b # foldl' :: (b -> a -> b) -> b -> IResult a -> b # foldr1 :: (a -> a -> a) -> IResult a -> a # foldl1 :: (a -> a -> a) -> IResult a -> a # toList :: IResult a -> [a] # null :: IResult a -> Bool # length :: IResult a -> Int # elem :: Eq a => a -> IResult a -> Bool # maximum :: Ord a => IResult a -> a # minimum :: Ord a => IResult a -> a # sum :: Num a => IResult a -> a # product :: Num a => IResult a -> a #
Foldable Result
Instance details Defined in Data.Aeson.Types.Internal Methods fold :: Monoid m => Result m -> m # foldMap :: Monoid m => (a -> m) -> Result a -> m # foldMap' :: Monoid m => (a -> m) -> Result a -> m # foldr :: (a -> b -> b) -> b -> Result a -> b # foldr' :: (a -> b -> b) -> b -> Result a -> b # foldl :: (b -> a -> b) -> b -> Result a -> b # foldl' :: (b -> a -> b) -> b -> Result a -> b # foldr1 :: (a -> a -> a) -> Result a -> a # foldl1 :: (a -> a -> a) -> Result a -> a # toList :: Result a -> [a] # null :: Result a -> Bool # length :: Result a -> Int # elem :: Eq a => a -> Result a -> Bool # maximum :: Ord a => Result a -> a # minimum :: Ord a => Result a -> a # sum :: Num a => Result a -> a # product :: Num a => Result a -> a #
Foldable ZipList	Since: base-4.9.0.0
Instance details Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m # foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m # foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b # foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b # foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # toList :: ZipList a -> [a] # null :: ZipList a -> Bool # length :: ZipList a -> Int # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # sum :: Num a => ZipList a -> a # product :: Num a => ZipList a -> a #
Foldable Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods fold :: Monoid m => Complex m -> m # foldMap :: Monoid m => (a -> m) -> Complex a -> m # foldMap' :: Monoid m => (a -> m) -> Complex a -> m # foldr :: (a -> b -> b) -> b -> Complex a -> b # foldr' :: (a -> b -> b) -> b -> Complex a -> b # foldl :: (b -> a -> b) -> b -> Complex a -> b # foldl' :: (b -> a -> b) -> b -> Complex a -> b # foldr1 :: (a -> a -> a) -> Complex a -> a # foldl1 :: (a -> a -> a) -> Complex a -> a # toList :: Complex a -> [a] # null :: Complex a -> Bool # length :: Complex a -> Int # elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # sum :: Num a => Complex a -> a # product :: Num a => Complex a -> a #
Foldable Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] # null :: Identity a -> Bool # length :: Identity a -> Int # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # sum :: Num a => Identity a -> a # product :: Num a => Identity a -> a #
Foldable First	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] # null :: First a -> Bool # length :: First a -> Int # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # sum :: Num a => First a -> a # product :: Num a => First a -> a #
Foldable Last	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] # null :: Last a -> Bool # length :: Last a -> Int # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # minimum :: Ord a => Last a -> a # sum :: Num a => Last a -> a # product :: Num a => Last a -> a #
Foldable Down	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m # foldMap :: Monoid m => (a -> m) -> Down a -> m # foldMap' :: Monoid m => (a -> m) -> Down a -> m # foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b # foldl :: (b -> a -> b) -> b -> Down a -> b # foldl' :: (b -> a -> b) -> b -> Down a -> b # foldr1 :: (a -> a -> a) -> Down a -> a # foldl1 :: (a -> a -> a) -> Down a -> a # toList :: Down a -> [a] # null :: Down a -> Bool # length :: Down a -> Int # elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # minimum :: Ord a => Down a -> a # sum :: Num a => Down a -> a # product :: Num a => Down a -> a #
Foldable First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] # null :: First a -> Bool # length :: First a -> Int # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # sum :: Num a => First a -> a # product :: Num a => First a -> a #
Foldable Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] # null :: Last a -> Bool # length :: Last a -> Int # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # minimum :: Ord a => Last a -> a # sum :: Num a => Last a -> a # product :: Num a => Last a -> a #
Foldable Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Max m -> m # foldMap :: Monoid m => (a -> m) -> Max a -> m # foldMap' :: Monoid m => (a -> m) -> Max a -> m # foldr :: (a -> b -> b) -> b -> Max a -> b # foldr' :: (a -> b -> b) -> b -> Max a -> b # foldl :: (b -> a -> b) -> b -> Max a -> b # foldl' :: (b -> a -> b) -> b -> Max a -> b # foldr1 :: (a -> a -> a) -> Max a -> a # foldl1 :: (a -> a -> a) -> Max a -> a # toList :: Max a -> [a] # null :: Max a -> Bool # length :: Max a -> Int # elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # minimum :: Ord a => Max a -> a # sum :: Num a => Max a -> a # product :: Num a => Max a -> a #
Foldable Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Min m -> m # foldMap :: Monoid m => (a -> m) -> Min a -> m # foldMap' :: Monoid m => (a -> m) -> Min a -> m # foldr :: (a -> b -> b) -> b -> Min a -> b # foldr' :: (a -> b -> b) -> b -> Min a -> b # foldl :: (b -> a -> b) -> b -> Min a -> b # foldl' :: (b -> a -> b) -> b -> Min a -> b # foldr1 :: (a -> a -> a) -> Min a -> a # foldl1 :: (a -> a -> a) -> Min a -> a # toList :: Min a -> [a] # null :: Min a -> Bool # length :: Min a -> Int # elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # minimum :: Ord a => Min a -> a # sum :: Num a => Min a -> a # product :: Num a => Min a -> a #
Foldable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Option m -> m # foldMap :: Monoid m => (a -> m) -> Option a -> m # foldMap' :: Monoid m => (a -> m) -> Option a -> m # foldr :: (a -> b -> b) -> b -> Option a -> b # foldr' :: (a -> b -> b) -> b -> Option a -> b # foldl :: (b -> a -> b) -> b -> Option a -> b # foldl' :: (b -> a -> b) -> b -> Option a -> b # foldr1 :: (a -> a -> a) -> Option a -> a # foldl1 :: (a -> a -> a) -> Option a -> a # toList :: Option a -> [a] # null :: Option a -> Bool # length :: Option a -> Int # elem :: Eq a => a -> Option a -> Bool # maximum :: Ord a => Option a -> a # minimum :: Ord a => Option a -> a # sum :: Num a => Option a -> a # product :: Num a => Option a -> a #
Foldable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m # foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldMap' :: Monoid m => (a -> m) -> Dual a -> m # foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b # foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b # foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # toList :: Dual a -> [a] # null :: Dual a -> Bool # length :: Dual a -> Int # elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # minimum :: Ord a => Dual a -> a # sum :: Num a => Dual a -> a # product :: Num a => Dual a -> a #
Foldable Product	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m # foldMap :: Monoid m => (a -> m) -> Product a -> m # foldMap' :: Monoid m => (a -> m) -> Product a -> m # foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b # foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b # foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # toList :: Product a -> [a] # null :: Product a -> Bool # length :: Product a -> Int # elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # sum :: Num a => Product a -> a # product :: Num a => Product a -> a #
Foldable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m # foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldMap' :: Monoid m => (a -> m) -> Sum a -> m # foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b # foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b # foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # toList :: Sum a -> [a] # null :: Sum a -> Bool # length :: Sum a -> Int # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # minimum :: Ord a => Sum a -> a # sum :: Num a => Sum a -> a # product :: Num a => Sum a -> a #
Foldable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m # foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m # foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b # foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b # foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # toList :: NonEmpty a -> [a] # null :: NonEmpty a -> Bool # length :: NonEmpty a -> Int # elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # sum :: Num a => NonEmpty a -> a # product :: Num a => NonEmpty a -> a #
Foldable Par1	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Par1 m -> m # foldMap :: Monoid m => (a -> m) -> Par1 a -> m # foldMap' :: Monoid m => (a -> m) -> Par1 a -> m # foldr :: (a -> b -> b) -> b -> Par1 a -> b # foldr' :: (a -> b -> b) -> b -> Par1 a -> b # foldl :: (b -> a -> b) -> b -> Par1 a -> b # foldl' :: (b -> a -> b) -> b -> Par1 a -> b # foldr1 :: (a -> a -> a) -> Par1 a -> a # foldl1 :: (a -> a -> a) -> Par1 a -> a # toList :: Par1 a -> [a] # null :: Par1 a -> Bool # length :: Par1 a -> Int # elem :: Eq a => a -> Par1 a -> Bool # maximum :: Ord a => Par1 a -> a # minimum :: Ord a => Par1 a -> a # sum :: Num a => Par1 a -> a # product :: Num a => Par1 a -> a #
Foldable Identifier
Instance details Defined in Text.Casing Methods fold :: Monoid m => Identifier m -> m # foldMap :: Monoid m => (a -> m) -> Identifier a -> m # foldMap' :: Monoid m => (a -> m) -> Identifier a -> m # foldr :: (a -> b -> b) -> b -> Identifier a -> b # foldr' :: (a -> b -> b) -> b -> Identifier a -> b # foldl :: (b -> a -> b) -> b -> Identifier a -> b # foldl' :: (b -> a -> b) -> b -> Identifier a -> b # foldr1 :: (a -> a -> a) -> Identifier a -> a # foldl1 :: (a -> a -> a) -> Identifier a -> a # toList :: Identifier a -> [a] # null :: Identifier a -> Bool # length :: Identifier a -> Int # elem :: Eq a => a -> Identifier a -> Bool # maximum :: Ord a => Identifier a -> a # minimum :: Ord a => Identifier a -> a # sum :: Num a => Identifier a -> a # product :: Num a => Identifier a -> a #
Foldable SCC	Since: containers-0.5.9
Instance details Defined in Data.Graph Methods fold :: Monoid m => SCC m -> m # foldMap :: Monoid m => (a -> m) -> SCC a -> m # foldMap' :: Monoid m => (a -> m) -> SCC a -> m # foldr :: (a -> b -> b) -> b -> SCC a -> b # foldr' :: (a -> b -> b) -> b -> SCC a -> b # foldl :: (b -> a -> b) -> b -> SCC a -> b # foldl' :: (b -> a -> b) -> b -> SCC a -> b # foldr1 :: (a -> a -> a) -> SCC a -> a # foldl1 :: (a -> a -> a) -> SCC a -> a # toList :: SCC a -> [a] # null :: SCC a -> Bool # length :: SCC a -> Int # elem :: Eq a => a -> SCC a -> Bool # maximum :: Ord a => SCC a -> a # minimum :: Ord a => SCC a -> a # sum :: Num a => SCC a -> a # product :: Num a => SCC a -> a #
Foldable IntMap	Folds in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m # foldMap :: Monoid m => (a -> m) -> IntMap a -> m # foldMap' :: Monoid m => (a -> m) -> IntMap a -> m # foldr :: (a -> b -> b) -> b -> IntMap a -> b # foldr' :: (a -> b -> b) -> b -> IntMap a -> b # foldl :: (b -> a -> b) -> b -> IntMap a -> b # foldl' :: (b -> a -> b) -> b -> IntMap a -> b # foldr1 :: (a -> a -> a) -> IntMap a -> a # foldl1 :: (a -> a -> a) -> IntMap a -> a # toList :: IntMap a -> [a] # null :: IntMap a -> Bool # length :: IntMap a -> Int # elem :: Eq a => a -> IntMap a -> Bool # maximum :: Ord a => IntMap a -> a # minimum :: Ord a => IntMap a -> a # sum :: Num a => IntMap a -> a # product :: Num a => IntMap a -> a #
Foldable Digit
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Digit m -> m # foldMap :: Monoid m => (a -> m) -> Digit a -> m # foldMap' :: Monoid m => (a -> m) -> Digit a -> m # foldr :: (a -> b -> b) -> b -> Digit a -> b # foldr' :: (a -> b -> b) -> b -> Digit a -> b # foldl :: (b -> a -> b) -> b -> Digit a -> b # foldl' :: (b -> a -> b) -> b -> Digit a -> b # foldr1 :: (a -> a -> a) -> Digit a -> a # foldl1 :: (a -> a -> a) -> Digit a -> a # toList :: Digit a -> [a] # null :: Digit a -> Bool # length :: Digit a -> Int # elem :: Eq a => a -> Digit a -> Bool # maximum :: Ord a => Digit a -> a # minimum :: Ord a => Digit a -> a # sum :: Num a => Digit a -> a # product :: Num a => Digit a -> a #
Foldable Elem
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Elem m -> m # foldMap :: Monoid m => (a -> m) -> Elem a -> m # foldMap' :: Monoid m => (a -> m) -> Elem a -> m # foldr :: (a -> b -> b) -> b -> Elem a -> b # foldr' :: (a -> b -> b) -> b -> Elem a -> b # foldl :: (b -> a -> b) -> b -> Elem a -> b # foldl' :: (b -> a -> b) -> b -> Elem a -> b # foldr1 :: (a -> a -> a) -> Elem a -> a # foldl1 :: (a -> a -> a) -> Elem a -> a # toList :: Elem a -> [a] # null :: Elem a -> Bool # length :: Elem a -> Int # elem :: Eq a => a -> Elem a -> Bool # maximum :: Ord a => Elem a -> a # minimum :: Ord a => Elem a -> a # sum :: Num a => Elem a -> a # product :: Num a => Elem a -> a #
Foldable FingerTree
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => FingerTree m -> m # foldMap :: Monoid m => (a -> m) -> FingerTree a -> m # foldMap' :: Monoid m => (a -> m) -> FingerTree a -> m # foldr :: (a -> b -> b) -> b -> FingerTree a -> b # foldr' :: (a -> b -> b) -> b -> FingerTree a -> b # foldl :: (b -> a -> b) -> b -> FingerTree a -> b # foldl' :: (b -> a -> b) -> b -> FingerTree a -> b # foldr1 :: (a -> a -> a) -> FingerTree a -> a # foldl1 :: (a -> a -> a) -> FingerTree a -> a # toList :: FingerTree a -> [a] # null :: FingerTree a -> Bool # length :: FingerTree a -> Int # elem :: Eq a => a -> FingerTree a -> Bool # maximum :: Ord a => FingerTree a -> a # minimum :: Ord a => FingerTree a -> a # sum :: Num a => FingerTree a -> a # product :: Num a => FingerTree a -> a #
Foldable Node
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Node m -> m # foldMap :: Monoid m => (a -> m) -> Node a -> m # foldMap' :: Monoid m => (a -> m) -> Node a -> m # foldr :: (a -> b -> b) -> b -> Node a -> b # foldr' :: (a -> b -> b) -> b -> Node a -> b # foldl :: (b -> a -> b) -> b -> Node a -> b # foldl' :: (b -> a -> b) -> b -> Node a -> b # foldr1 :: (a -> a -> a) -> Node a -> a # foldl1 :: (a -> a -> a) -> Node a -> a # toList :: Node a -> [a] # null :: Node a -> Bool # length :: Node a -> Int # elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # minimum :: Ord a => Node a -> a # sum :: Num a => Node a -> a # product :: Num a => Node a -> a #
Foldable Seq
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m # foldMap :: Monoid m => (a -> m) -> Seq a -> m # foldMap' :: Monoid m => (a -> m) -> Seq a -> m # foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b # foldl :: (b -> a -> b) -> b -> Seq a -> b # foldl' :: (b -> a -> b) -> b -> Seq a -> b # foldr1 :: (a -> a -> a) -> Seq a -> a # foldl1 :: (a -> a -> a) -> Seq a -> a # toList :: Seq a -> [a] # null :: Seq a -> Bool # length :: Seq a -> Int # elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # minimum :: Ord a => Seq a -> a # sum :: Num a => Seq a -> a # product :: Num a => Seq a -> a #
Foldable ViewL
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewL m -> m # foldMap :: Monoid m => (a -> m) -> ViewL a -> m # foldMap' :: Monoid m => (a -> m) -> ViewL a -> m # foldr :: (a -> b -> b) -> b -> ViewL a -> b # foldr' :: (a -> b -> b) -> b -> ViewL a -> b # foldl :: (b -> a -> b) -> b -> ViewL a -> b # foldl' :: (b -> a -> b) -> b -> ViewL a -> b # foldr1 :: (a -> a -> a) -> ViewL a -> a # foldl1 :: (a -> a -> a) -> ViewL a -> a # toList :: ViewL a -> [a] # null :: ViewL a -> Bool # length :: ViewL a -> Int # elem :: Eq a => a -> ViewL a -> Bool # maximum :: Ord a => ViewL a -> a # minimum :: Ord a => ViewL a -> a # sum :: Num a => ViewL a -> a # product :: Num a => ViewL a -> a #
Foldable ViewR
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewR m -> m # foldMap :: Monoid m => (a -> m) -> ViewR a -> m # foldMap' :: Monoid m => (a -> m) -> ViewR a -> m # foldr :: (a -> b -> b) -> b -> ViewR a -> b # foldr' :: (a -> b -> b) -> b -> ViewR a -> b # foldl :: (b -> a -> b) -> b -> ViewR a -> b # foldl' :: (b -> a -> b) -> b -> ViewR a -> b # foldr1 :: (a -> a -> a) -> ViewR a -> a # foldl1 :: (a -> a -> a) -> ViewR a -> a # toList :: ViewR a -> [a] # null :: ViewR a -> Bool # length :: ViewR a -> Int # elem :: Eq a => a -> ViewR a -> Bool # maximum :: Ord a => ViewR a -> a # minimum :: Ord a => ViewR a -> a # sum :: Num a => ViewR a -> a # product :: Num a => ViewR a -> a #
Foldable Set	Folds in order of increasing key.
Instance details Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m # foldMap :: Monoid m => (a -> m) -> Set a -> m # foldMap' :: Monoid m => (a -> m) -> Set a -> m # foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b # foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b # foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # toList :: Set a -> [a] # null :: Set a -> Bool # length :: Set a -> Int # elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # minimum :: Ord a => Set a -> a # sum :: Num a => Set a -> a # product :: Num a => Set a -> a #
Foldable Tree
Instance details Defined in Data.Tree Methods fold :: Monoid m => Tree m -> m # foldMap :: Monoid m => (a -> m) -> Tree a -> m # foldMap' :: Monoid m => (a -> m) -> Tree a -> m # foldr :: (a -> b -> b) -> b -> Tree a -> b # foldr' :: (a -> b -> b) -> b -> Tree a -> b # foldl :: (b -> a -> b) -> b -> Tree a -> b # foldl' :: (b -> a -> b) -> b -> Tree a -> b # foldr1 :: (a -> a -> a) -> Tree a -> a # foldl1 :: (a -> a -> a) -> Tree a -> a # toList :: Tree a -> [a] # null :: Tree a -> Bool # length :: Tree a -> Int # elem :: Eq a => a -> Tree a -> Bool # maximum :: Ord a => Tree a -> a # minimum :: Ord a => Tree a -> a # sum :: Num a => Tree a -> a # product :: Num a => Tree a -> a #
Foldable DNonEmpty
Instance details Defined in Data.DList.DNonEmpty.Internal Methods fold :: Monoid m => DNonEmpty m -> m # foldMap :: Monoid m => (a -> m) -> DNonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> DNonEmpty a -> m # foldr :: (a -> b -> b) -> b -> DNonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> DNonEmpty a -> b # foldl :: (b -> a -> b) -> b -> DNonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> DNonEmpty a -> b # foldr1 :: (a -> a -> a) -> DNonEmpty a -> a # foldl1 :: (a -> a -> a) -> DNonEmpty a -> a # toList :: DNonEmpty a -> [a] # null :: DNonEmpty a -> Bool # length :: DNonEmpty a -> Int # elem :: Eq a => a -> DNonEmpty a -> Bool # maximum :: Ord a => DNonEmpty a -> a # minimum :: Ord a => DNonEmpty a -> a # sum :: Num a => DNonEmpty a -> a # product :: Num a => DNonEmpty a -> a #
Foldable DList
Instance details Defined in Data.DList.Internal Methods fold :: Monoid m => DList m -> m # foldMap :: Monoid m => (a -> m) -> DList a -> m # foldMap' :: Monoid m => (a -> m) -> DList a -> m # foldr :: (a -> b -> b) -> b -> DList a -> b # foldr' :: (a -> b -> b) -> b -> DList a -> b # foldl :: (b -> a -> b) -> b -> DList a -> b # foldl' :: (b -> a -> b) -> b -> DList a -> b # foldr1 :: (a -> a -> a) -> DList a -> a # foldl1 :: (a -> a -> a) -> DList a -> a # toList :: DList a -> [a] # null :: DList a -> Bool # length :: DList a -> Int # elem :: Eq a => a -> DList a -> Bool # maximum :: Ord a => DList a -> a # minimum :: Ord a => DList a -> a # sum :: Num a => DList a -> a # product :: Num a => DList a -> a #
Foldable Hashed
Instance details Defined in Data.Hashable.Class Methods fold :: Monoid m => Hashed m -> m # foldMap :: Monoid m => (a -> m) -> Hashed a -> m # foldMap' :: Monoid m => (a -> m) -> Hashed a -> m # foldr :: (a -> b -> b) -> b -> Hashed a -> b # foldr' :: (a -> b -> b) -> b -> Hashed a -> b # foldl :: (b -> a -> b) -> b -> Hashed a -> b # foldl' :: (b -> a -> b) -> b -> Hashed a -> b # foldr1 :: (a -> a -> a) -> Hashed a -> a # foldl1 :: (a -> a -> a) -> Hashed a -> a # toList :: Hashed a -> [a] # null :: Hashed a -> Bool # length :: Hashed a -> Int # elem :: Eq a => a -> Hashed a -> Bool # maximum :: Ord a => Hashed a -> a # minimum :: Ord a => Hashed a -> a # sum :: Num a => Hashed a -> a # product :: Num a => Hashed a -> a #
Foldable ResultStateLogs
Instance details Defined in Morley.Michelson.Interpret Methods fold :: Monoid m => ResultStateLogs m -> m # foldMap :: Monoid m => (a -> m) -> ResultStateLogs a -> m # foldMap' :: Monoid m => (a -> m) -> ResultStateLogs a -> m # foldr :: (a -> b -> b) -> b -> ResultStateLogs a -> b # foldr' :: (a -> b -> b) -> b -> ResultStateLogs a -> b # foldl :: (b -> a -> b) -> b -> ResultStateLogs a -> b # foldl' :: (b -> a -> b) -> b -> ResultStateLogs a -> b # foldr1 :: (a -> a -> a) -> ResultStateLogs a -> a # foldl1 :: (a -> a -> a) -> ResultStateLogs a -> a # toList :: ResultStateLogs a -> [a] # null :: ResultStateLogs a -> Bool # length :: ResultStateLogs a -> Int # elem :: Eq a => a -> ResultStateLogs a -> Bool # maximum :: Ord a => ResultStateLogs a -> a # minimum :: Ord a => ResultStateLogs a -> a # sum :: Num a => ResultStateLogs a -> a # product :: Num a => ResultStateLogs a -> a #
Foldable MismatchError
Instance details Defined in Morley.Util.MismatchError Methods fold :: Monoid m => MismatchError m -> m # foldMap :: Monoid m => (a -> m) -> MismatchError a -> m # foldMap' :: Monoid m => (a -> m) -> MismatchError a -> m # foldr :: (a -> b -> b) -> b -> MismatchError a -> b # foldr' :: (a -> b -> b) -> b -> MismatchError a -> b # foldl :: (b -> a -> b) -> b -> MismatchError a -> b # foldl' :: (b -> a -> b) -> b -> MismatchError a -> b # foldr1 :: (a -> a -> a) -> MismatchError a -> a # foldl1 :: (a -> a -> a) -> MismatchError a -> a # toList :: MismatchError a -> [a] # null :: MismatchError a -> Bool # length :: MismatchError a -> Int # elem :: Eq a => a -> MismatchError a -> Bool # maximum :: Ord a => MismatchError a -> a # minimum :: Ord a => MismatchError a -> a # sum :: Num a => MismatchError a -> a # product :: Num a => MismatchError a -> a #
Foldable SomeSizedList
Instance details Defined in Morley.Util.SizedList Methods fold :: Monoid m => SomeSizedList m -> m # foldMap :: Monoid m => (a -> m) -> SomeSizedList a -> m # foldMap' :: Monoid m => (a -> m) -> SomeSizedList a -> m # foldr :: (a -> b -> b) -> b -> SomeSizedList a -> b # foldr' :: (a -> b -> b) -> b -> SomeSizedList a -> b # foldl :: (b -> a -> b) -> b -> SomeSizedList a -> b # foldl' :: (b -> a -> b) -> b -> SomeSizedList a -> b # foldr1 :: (a -> a -> a) -> SomeSizedList a -> a # foldl1 :: (a -> a -> a) -> SomeSizedList a -> a # toList :: SomeSizedList a -> [a] # null :: SomeSizedList a -> Bool # length :: SomeSizedList a -> Int # elem :: Eq a => a -> SomeSizedList a -> Bool # maximum :: Ord a => SomeSizedList a -> a # minimum :: Ord a => SomeSizedList a -> a # sum :: Num a => SomeSizedList a -> a # product :: Num a => SomeSizedList a -> a #
Foldable Array
Instance details Defined in Data.Primitive.Array Methods fold :: Monoid m => Array m -> m # foldMap :: Monoid m => (a -> m) -> Array a -> m # foldMap' :: Monoid m => (a -> m) -> Array a -> m # foldr :: (a -> b -> b) -> b -> Array a -> b # foldr' :: (a -> b -> b) -> b -> Array a -> b # foldl :: (b -> a -> b) -> b -> Array a -> b # foldl' :: (b -> a -> b) -> b -> Array a -> b # foldr1 :: (a -> a -> a) -> Array a -> a # foldl1 :: (a -> a -> a) -> Array a -> a # toList :: Array a -> [a] # null :: Array a -> Bool # length :: Array a -> Int # elem :: Eq a => a -> Array a -> Bool # maximum :: Ord a => Array a -> a # minimum :: Ord a => Array a -> a # sum :: Num a => Array a -> a # product :: Num a => Array a -> a #
Foldable SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods fold :: Monoid m => SmallArray m -> m # foldMap :: Monoid m => (a -> m) -> SmallArray a -> m # foldMap' :: Monoid m => (a -> m) -> SmallArray a -> m # foldr :: (a -> b -> b) -> b -> SmallArray a -> b # foldr' :: (a -> b -> b) -> b -> SmallArray a -> b # foldl :: (b -> a -> b) -> b -> SmallArray a -> b # foldl' :: (b -> a -> b) -> b -> SmallArray a -> b # foldr1 :: (a -> a -> a) -> SmallArray a -> a # foldl1 :: (a -> a -> a) -> SmallArray a -> a # toList :: SmallArray a -> [a] # null :: SmallArray a -> Bool # length :: SmallArray a -> Int # elem :: Eq a => a -> SmallArray a -> Bool # maximum :: Ord a => SmallArray a -> a # minimum :: Ord a => SmallArray a -> a # sum :: Num a => SmallArray a -> a # product :: Num a => SmallArray a -> a #
Foldable Add
Instance details Defined in Data.Semiring Methods fold :: Monoid m => Add m -> m # foldMap :: Monoid m => (a -> m) -> Add a -> m # foldMap' :: Monoid m => (a -> m) -> Add a -> m # foldr :: (a -> b -> b) -> b -> Add a -> b # foldr' :: (a -> b -> b) -> b -> Add a -> b # foldl :: (b -> a -> b) -> b -> Add a -> b # foldl' :: (b -> a -> b) -> b -> Add a -> b # foldr1 :: (a -> a -> a) -> Add a -> a # foldl1 :: (a -> a -> a) -> Add a -> a # toList :: Add a -> [a] # null :: Add a -> Bool # length :: Add a -> Int # elem :: Eq a => a -> Add a -> Bool # maximum :: Ord a => Add a -> a # minimum :: Ord a => Add a -> a # sum :: Num a => Add a -> a # product :: Num a => Add a -> a #
Foldable Mul
Instance details Defined in Data.Semiring Methods fold :: Monoid m => Mul m -> m # foldMap :: Monoid m => (a -> m) -> Mul a -> m # foldMap' :: Monoid m => (a -> m) -> Mul a -> m # foldr :: (a -> b -> b) -> b -> Mul a -> b # foldr' :: (a -> b -> b) -> b -> Mul a -> b # foldl :: (b -> a -> b) -> b -> Mul a -> b # foldl' :: (b -> a -> b) -> b -> Mul a -> b # foldr1 :: (a -> a -> a) -> Mul a -> a # foldl1 :: (a -> a -> a) -> Mul a -> a # toList :: Mul a -> [a] # null :: Mul a -> Bool # length :: Mul a -> Int # elem :: Eq a => a -> Mul a -> Bool # maximum :: Ord a => Mul a -> a # minimum :: Ord a => Mul a -> a # sum :: Num a => Mul a -> a # product :: Num a => Mul a -> a #
Foldable WrappedNum
Instance details Defined in Data.Semiring Methods fold :: Monoid m => WrappedNum m -> m # foldMap :: Monoid m => (a -> m) -> WrappedNum a -> m # foldMap' :: Monoid m => (a -> m) -> WrappedNum a -> m # foldr :: (a -> b -> b) -> b -> WrappedNum a -> b # foldr' :: (a -> b -> b) -> b -> WrappedNum a -> b # foldl :: (b -> a -> b) -> b -> WrappedNum a -> b # foldl' :: (b -> a -> b) -> b -> WrappedNum a -> b # foldr1 :: (a -> a -> a) -> WrappedNum a -> a # foldl1 :: (a -> a -> a) -> WrappedNum a -> a # toList :: WrappedNum a -> [a] # null :: WrappedNum a -> Bool # length :: WrappedNum a -> Int # elem :: Eq a => a -> WrappedNum a -> Bool # maximum :: Ord a => WrappedNum a -> a # minimum :: Ord a => WrappedNum a -> a # sum :: Num a => WrappedNum a -> a # product :: Num a => WrappedNum a -> a #
Foldable Maybe
Instance details Defined in Data.Strict.Maybe Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # toList :: Maybe a -> [a] # null :: Maybe a -> Bool # length :: Maybe a -> Int # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # sum :: Num a => Maybe a -> a # product :: Num a => Maybe a -> a #
Foldable HashSet
Instance details Defined in Data.HashSet.Internal Methods fold :: Monoid m => HashSet m -> m # foldMap :: Monoid m => (a -> m) -> HashSet a -> m # foldMap' :: Monoid m => (a -> m) -> HashSet a -> m # foldr :: (a -> b -> b) -> b -> HashSet a -> b # foldr' :: (a -> b -> b) -> b -> HashSet a -> b # foldl :: (b -> a -> b) -> b -> HashSet a -> b # foldl' :: (b -> a -> b) -> b -> HashSet a -> b # foldr1 :: (a -> a -> a) -> HashSet a -> a # foldl1 :: (a -> a -> a) -> HashSet a -> a # toList :: HashSet a -> [a] # null :: HashSet a -> Bool # length :: HashSet a -> Int # elem :: Eq a => a -> HashSet a -> Bool # maximum :: Ord a => HashSet a -> a # minimum :: Ord a => HashSet a -> a # sum :: Num a => HashSet a -> a # product :: Num a => HashSet a -> a #
Foldable Vector
Instance details Defined in Data.Vector Methods fold :: Monoid m => Vector m -> m # foldMap :: Monoid m => (a -> m) -> Vector a -> m # foldMap' :: Monoid m => (a -> m) -> Vector a -> m # foldr :: (a -> b -> b) -> b -> Vector a -> b # foldr' :: (a -> b -> b) -> b -> Vector a -> b # foldl :: (b -> a -> b) -> b -> Vector a -> b # foldl' :: (b -> a -> b) -> b -> Vector a -> b # foldr1 :: (a -> a -> a) -> Vector a -> a # foldl1 :: (a -> a -> a) -> Vector a -> a # toList :: Vector a -> [a] # null :: Vector a -> Bool # length :: Vector a -> Int # elem :: Eq a => a -> Vector a -> Bool # maximum :: Ord a => Vector a -> a # minimum :: Ord a => Vector a -> a # sum :: Num a => Vector a -> a # product :: Num a => Vector a -> a #
Foldable Identity
Instance details Defined in Data.Vinyl.Functor Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] # null :: Identity a -> Bool # length :: Identity a -> Int # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # sum :: Num a => Identity a -> a # product :: Num a => Identity a -> a #
Foldable Thunk
Instance details Defined in Data.Vinyl.Functor Methods fold :: Monoid m => Thunk m -> m # foldMap :: Monoid m => (a -> m) -> Thunk a -> m # foldMap' :: Monoid m => (a -> m) -> Thunk a -> m # foldr :: (a -> b -> b) -> b -> Thunk a -> b # foldr' :: (a -> b -> b) -> b -> Thunk a -> b # foldl :: (b -> a -> b) -> b -> Thunk a -> b # foldl' :: (b -> a -> b) -> b -> Thunk a -> b # foldr1 :: (a -> a -> a) -> Thunk a -> a # foldl1 :: (a -> a -> a) -> Thunk a -> a # toList :: Thunk a -> [a] # null :: Thunk a -> Bool # length :: Thunk a -> Int # elem :: Eq a => a -> Thunk a -> Bool # maximum :: Ord a => Thunk a -> a # minimum :: Ord a => Thunk a -> a # sum :: Num a => Thunk a -> a # product :: Num a => Thunk a -> a #
Foldable Maybe	Since: base-2.1
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # toList :: Maybe a -> [a] # null :: Maybe a -> Bool # length :: Maybe a -> Int # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # sum :: Num a => Maybe a -> a # product :: Num a => Maybe a -> a #
Foldable Solo	Since: base-4.15
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Solo m -> m # foldMap :: Monoid m => (a -> m) -> Solo a -> m # foldMap' :: Monoid m => (a -> m) -> Solo a -> m # foldr :: (a -> b -> b) -> b -> Solo a -> b # foldr' :: (a -> b -> b) -> b -> Solo a -> b # foldl :: (b -> a -> b) -> b -> Solo a -> b # foldl' :: (b -> a -> b) -> b -> Solo a -> b # foldr1 :: (a -> a -> a) -> Solo a -> a # foldl1 :: (a -> a -> a) -> Solo a -> a # toList :: Solo a -> [a] # null :: Solo a -> Bool # length :: Solo a -> Int # elem :: Eq a => a -> Solo a -> Bool # maximum :: Ord a => Solo a -> a # minimum :: Ord a => Solo a -> a # sum :: Num a => Solo a -> a # product :: Num a => Solo a -> a #
Foldable []	Since: base-2.1
Instance details Defined in Data.Foldable Methods fold :: Monoid m => [m] -> m # foldMap :: Monoid m => (a -> m) -> [a] -> m # foldMap' :: Monoid m => (a -> m) -> [a] -> m # foldr :: (a -> b -> b) -> b -> [a] -> b # foldr' :: (a -> b -> b) -> b -> [a] -> b # foldl :: (b -> a -> b) -> b -> [a] -> b # foldl' :: (b -> a -> b) -> b -> [a] -> b # foldr1 :: (a -> a -> a) -> [a] -> a # foldl1 :: (a -> a -> a) -> [a] -> a # toList :: [a] -> [a] # null :: [a] -> Bool # length :: [a] -> Int # elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # minimum :: Ord a => [a] -> a # sum :: Num a => [a] -> a # product :: Num a => [a] -> a #
Foldable (Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # toList :: Either a a0 -> [a0] # null :: Either a a0 -> Bool # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # sum :: Num a0 => Either a a0 -> a0 # product :: Num a0 => Either a a0 -> a0 #
Foldable (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m # foldMap :: Monoid m => (a -> m) -> Proxy a -> 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 #
Foldable (Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Arg a m -> m # foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # toList :: Arg a a0 -> [a0] # null :: Arg a a0 -> Bool # length :: Arg a a0 -> Int # elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # sum :: Num a0 => Arg a a0 -> a0 # product :: Num a0 => Arg a a0 -> a0 #
Foldable (Array i)	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Array i m -> m # foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldMap' :: Monoid m => (a -> m) -> Array i a -> m # foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b # foldl :: (b -> a -> b) -> b -> Array i a -> b # foldl' :: (b -> a -> b) -> b -> Array i a -> b # foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # toList :: Array i a -> [a] # null :: Array i a -> Bool # length :: Array i a -> Int # elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # sum :: Num a => Array i a -> a # product :: Num a => Array i a -> a #
Foldable (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => U1 m -> m # foldMap :: Monoid m => (a -> m) -> U1 a -> m # foldMap' :: Monoid m => (a -> m) -> U1 a -> m # foldr :: (a -> b -> b) -> b -> U1 a -> b # foldr' :: (a -> b -> b) -> b -> U1 a -> b # foldl :: (b -> a -> b) -> b -> U1 a -> b # foldl' :: (b -> a -> b) -> b -> U1 a -> b # foldr1 :: (a -> a -> a) -> U1 a -> a # foldl1 :: (a -> a -> a) -> U1 a -> a # toList :: U1 a -> [a] # null :: U1 a -> Bool # length :: U1 a -> Int # elem :: Eq a => a -> U1 a -> Bool # maximum :: Ord a => U1 a -> a # minimum :: Ord a => U1 a -> a # sum :: Num a => U1 a -> a # product :: Num a => U1 a -> a #
Foldable (UAddr :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m # foldMap :: Monoid m => (a -> m) -> UAddr a -> m # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m # foldr :: (a -> b -> b) -> b -> UAddr a -> b # foldr' :: (a -> b -> b) -> b -> UAddr a -> b # foldl :: (b -> a -> b) -> b -> UAddr a -> b # foldl' :: (b -> a -> b) -> b -> UAddr a -> b # foldr1 :: (a -> a -> a) -> UAddr a -> a # foldl1 :: (a -> a -> a) -> UAddr a -> a # toList :: UAddr a -> [a] # null :: UAddr a -> Bool # length :: UAddr a -> Int # elem :: Eq a => a -> UAddr a -> Bool # maximum :: Ord a => UAddr a -> a # minimum :: Ord a => UAddr a -> a # sum :: Num a => UAddr a -> a # product :: Num a => UAddr a -> a #
Foldable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b # foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] # null :: UChar a -> Bool # length :: UChar a -> Int # elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # sum :: Num a => UChar a -> a # product :: Num a => UChar a -> a #
Foldable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m # foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m # foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b # foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b # foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] # null :: UDouble a -> Bool # length :: UDouble a -> Int # elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # sum :: Num a => UDouble a -> a # product :: Num a => UDouble a -> a #
Foldable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m # foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m # foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b # foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b # foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] # null :: UFloat a -> Bool # length :: UFloat a -> Int # elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # sum :: Num a => UFloat a -> a # product :: Num a => UFloat a -> a #
Foldable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m # foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m # foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b # foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b # foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] # null :: UInt a -> Bool # length :: UInt a -> Int # elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # minimum :: Ord a => UInt a -> a # sum :: Num a => UInt a -> a # product :: Num a => UInt a -> a #
Foldable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m # foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m # foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b # foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b # foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] # null :: UWord a -> Bool # length :: UWord a -> Int # elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # sum :: Num a => UWord a -> a # product :: Num a => UWord a -> a #
Foldable (V1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => V1 m -> m # foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldMap' :: Monoid m => (a -> m) -> V1 a -> m # foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b # foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b # foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # toList :: V1 a -> [a] # null :: V1 a -> Bool # length :: V1 a -> Int # elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # minimum :: Ord a => V1 a -> a # sum :: Num a => V1 a -> a # product :: Num a => V1 a -> a #
Foldable (Map k)	Folds in order of increasing key.
Instance details Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m # foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldMap' :: Monoid m => (a -> m) -> Map k a -> m # foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b # foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b # foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # toList :: Map k a -> [a] # null :: Map k a -> Bool # length :: Map k a -> Int # elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # sum :: Num a => Map k a -> a # product :: Num a => Map k a -> a #
Foldable f => Foldable (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods fold :: Monoid m => Cofree f m -> m # foldMap :: Monoid m => (a -> m) -> Cofree f a -> m # foldMap' :: Monoid m => (a -> m) -> Cofree f a -> m # foldr :: (a -> b -> b) -> b -> Cofree f a -> b # foldr' :: (a -> b -> b) -> b -> Cofree f a -> b # foldl :: (b -> a -> b) -> b -> Cofree f a -> b # foldl' :: (b -> a -> b) -> b -> Cofree f a -> b # foldr1 :: (a -> a -> a) -> Cofree f a -> a # foldl1 :: (a -> a -> a) -> Cofree f a -> a # toList :: Cofree f a -> [a] # null :: Cofree f a -> Bool # length :: Cofree f a -> Int # elem :: Eq a => a -> Cofree f a -> Bool # maximum :: Ord a => Cofree f a -> a # minimum :: Ord a => Cofree f a -> a # sum :: Num a => Cofree f a -> a # product :: Num a => Cofree f a -> a #
Foldable f => Foldable (Free f)
Instance details Defined in Control.Monad.Free Methods fold :: Monoid m => Free f m -> m # foldMap :: Monoid m => (a -> m) -> Free f a -> m # foldMap' :: Monoid m => (a -> m) -> Free f a -> m # foldr :: (a -> b -> b) -> b -> Free f a -> b # foldr' :: (a -> b -> b) -> b -> Free f a -> b # foldl :: (b -> a -> b) -> b -> Free f a -> b # foldl' :: (b -> a -> b) -> b -> Free f a -> b # foldr1 :: (a -> a -> a) -> Free f a -> a # foldl1 :: (a -> a -> a) -> Free f a -> a # toList :: Free f a -> [a] # null :: Free f a -> Bool # length :: Free f a -> Int # elem :: Eq a => a -> Free f a -> Bool # maximum :: Ord a => Free f a -> a # minimum :: Ord a => Free f a -> a # sum :: Num a => Free f a -> a # product :: Num a => Free f a -> a #
Foldable f => Foldable (Yoneda f)
Instance details Defined in Data.Functor.Yoneda Methods fold :: Monoid m => Yoneda f m -> m # foldMap :: Monoid m => (a -> m) -> Yoneda f a -> m # foldMap' :: Monoid m => (a -> m) -> Yoneda f a -> m # foldr :: (a -> b -> b) -> b -> Yoneda f a -> b # foldr' :: (a -> b -> b) -> b -> Yoneda f a -> b # foldl :: (b -> a -> b) -> b -> Yoneda f a -> b # foldl' :: (b -> a -> b) -> b -> Yoneda f a -> b # foldr1 :: (a -> a -> a) -> Yoneda f a -> a # foldl1 :: (a -> a -> a) -> Yoneda f a -> a # toList :: Yoneda f a -> [a] # null :: Yoneda f a -> Bool # length :: Yoneda f a -> Int # elem :: Eq a => a -> Yoneda f a -> Bool # maximum :: Ord a => Yoneda f a -> a # minimum :: Ord a => Yoneda f a -> a # sum :: Num a => Yoneda f a -> a # product :: Num a => Yoneda f a -> a #
Foldable (BigMap k)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods fold :: Monoid m => BigMap k m -> m # foldMap :: Monoid m => (a -> m) -> BigMap k a -> m # foldMap' :: Monoid m => (a -> m) -> BigMap k a -> m # foldr :: (a -> b -> b) -> b -> BigMap k a -> b # foldr' :: (a -> b -> b) -> b -> BigMap k a -> b # foldl :: (b -> a -> b) -> b -> BigMap k a -> b # foldl' :: (b -> a -> b) -> b -> BigMap k a -> b # foldr1 :: (a -> a -> a) -> BigMap k a -> a # foldl1 :: (a -> a -> a) -> BigMap k a -> a # toList :: BigMap k a -> [a] # null :: BigMap k a -> Bool # length :: BigMap k a -> Int # elem :: Eq a => a -> BigMap k a -> Bool # maximum :: Ord a => BigMap k a -> a # minimum :: Ord a => BigMap k a -> a # sum :: Num a => BigMap k a -> a # product :: Num a => BigMap k a -> a #
Foldable (SizedList' n)
Instance details Defined in Morley.Util.SizedList Methods fold :: Monoid m => SizedList' n m -> m # foldMap :: Monoid m => (a -> m) -> SizedList' n a -> m # foldMap' :: Monoid m => (a -> m) -> SizedList' n a -> m # foldr :: (a -> b -> b) -> b -> SizedList' n a -> b # foldr' :: (a -> b -> b) -> b -> SizedList' n a -> b # foldl :: (b -> a -> b) -> b -> SizedList' n a -> b # foldl' :: (b -> a -> b) -> b -> SizedList' n a -> b # foldr1 :: (a -> a -> a) -> SizedList' n a -> a # foldl1 :: (a -> a -> a) -> SizedList' n a -> a # toList :: SizedList' n a -> [a] # null :: SizedList' n a -> Bool # length :: SizedList' n a -> Int # elem :: Eq a => a -> SizedList' n a -> Bool # maximum :: Ord a => SizedList' n a -> a # minimum :: Ord a => SizedList' n a -> a # sum :: Num a => SizedList' n a -> a # product :: Num a => SizedList' n a -> a #
Foldable (Either e)
Instance details Defined in Data.Strict.Either Methods fold :: Monoid m => Either e m -> m # foldMap :: Monoid m => (a -> m) -> Either e a -> m # foldMap' :: Monoid m => (a -> m) -> Either e a -> m # foldr :: (a -> b -> b) -> b -> Either e a -> b # foldr' :: (a -> b -> b) -> b -> Either e a -> b # foldl :: (b -> a -> b) -> b -> Either e a -> b # foldl' :: (b -> a -> b) -> b -> Either e a -> b # foldr1 :: (a -> a -> a) -> Either e a -> a # foldl1 :: (a -> a -> a) -> Either e a -> a # toList :: Either e a -> [a] # null :: Either e a -> Bool # length :: Either e a -> Int # elem :: Eq a => a -> Either e a -> Bool # maximum :: Ord a => Either e a -> a # minimum :: Ord a => Either e a -> a # sum :: Num a => Either e a -> a # product :: Num a => Either e a -> a #
Foldable (These a)
Instance details Defined in Data.Strict.These Methods fold :: Monoid m => These a m -> m # foldMap :: Monoid m => (a0 -> m) -> These a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> These a a0 -> m # foldr :: (a0 -> b -> b) -> b -> These a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> These a a0 -> b # foldl :: (b -> a0 -> b) -> b -> These a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> These a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 # toList :: These a a0 -> [a0] # null :: These a a0 -> Bool # length :: These a a0 -> Int # elem :: Eq a0 => a0 -> These a a0 -> Bool # maximum :: Ord a0 => These a a0 -> a0 # minimum :: Ord a0 => These a a0 -> a0 # sum :: Num a0 => These a a0 -> a0 # product :: Num a0 => These a a0 -> a0 #
Foldable (Pair e)
Instance details Defined in Data.Strict.Tuple Methods fold :: Monoid m => Pair e m -> m # foldMap :: Monoid m => (a -> m) -> Pair e a -> m # foldMap' :: Monoid m => (a -> m) -> Pair e a -> m # foldr :: (a -> b -> b) -> b -> Pair e a -> b # foldr' :: (a -> b -> b) -> b -> Pair e a -> b # foldl :: (b -> a -> b) -> b -> Pair e a -> b # foldl' :: (b -> a -> b) -> b -> Pair e a -> b # foldr1 :: (a -> a -> a) -> Pair e a -> a # foldl1 :: (a -> a -> a) -> Pair e a -> a # toList :: Pair e a -> [a] # null :: Pair e a -> Bool # length :: Pair e a -> Int # elem :: Eq a => a -> Pair e a -> Bool # maximum :: Ord a => Pair e a -> a # minimum :: Ord a => Pair e a -> a # sum :: Num a => Pair e a -> a # product :: Num a => Pair e a -> a #
Foldable (These a)
Instance details Defined in Data.These Methods fold :: Monoid m => These a m -> m # foldMap :: Monoid m => (a0 -> m) -> These a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> These a a0 -> m # foldr :: (a0 -> b -> b) -> b -> These a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> These a a0 -> b # foldl :: (b -> a0 -> b) -> b -> These a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> These a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 # toList :: These a a0 -> [a0] # null :: These a a0 -> Bool # length :: These a a0 -> Int # elem :: Eq a0 => a0 -> These a a0 -> Bool # maximum :: Ord a0 => These a a0 -> a0 # minimum :: Ord a0 => These a a0 -> a0 # sum :: Num a0 => These a a0 -> a0 # product :: Num a0 => These a a0 -> a0 #
Foldable f => Foldable (MaybeT f)
Instance details Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m # foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m # foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b # foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b # foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # toList :: MaybeT f a -> [a] # null :: MaybeT f a -> Bool # length :: MaybeT f a -> Int # elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # sum :: Num a => MaybeT f a -> a # product :: Num a => MaybeT f a -> a #
Foldable (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods fold :: Monoid m => HashMap k m -> m # foldMap :: Monoid m => (a -> m) -> HashMap k a -> m # foldMap' :: Monoid m => (a -> m) -> HashMap k a -> m # foldr :: (a -> b -> b) -> b -> HashMap k a -> b # foldr' :: (a -> b -> b) -> b -> HashMap k a -> b # foldl :: (b -> a -> b) -> b -> HashMap k a -> b # foldl' :: (b -> a -> b) -> b -> HashMap k a -> b # foldr1 :: (a -> a -> a) -> HashMap k a -> a # foldl1 :: (a -> a -> a) -> HashMap k a -> a # toList :: HashMap k a -> [a] # null :: HashMap k a -> Bool # length :: HashMap k a -> Int # elem :: Eq a => a -> HashMap k a -> Bool # maximum :: Ord a => HashMap k a -> a # minimum :: Ord a => HashMap k a -> a # sum :: Num a => HashMap k a -> a # product :: Num a => HashMap k a -> a #
Foldable ((,) a)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (a, m) -> m # foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldMap' :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # toList :: (a, a0) -> [a0] # null :: (a, a0) -> Bool # length :: (a, a0) -> Int # elem :: Eq a0 => a0 -> (a, a0) -> Bool # maximum :: Ord a0 => (a, a0) -> a0 # minimum :: Ord a0 => (a, a0) -> a0 # sum :: Num a0 => (a, a0) -> a0 # product :: Num a0 => (a, a0) -> a0 #
Foldable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b # foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # toList :: Const m a -> [a] # null :: Const m a -> Bool # length :: Const m a -> Int # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # sum :: Num a => Const m a -> a # product :: Num a => Const m a -> a #
Foldable f => Foldable (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Ap f m -> m # foldMap :: Monoid m => (a -> m) -> Ap f a -> m # foldMap' :: Monoid m => (a -> m) -> Ap f a -> m # foldr :: (a -> b -> b) -> b -> Ap f a -> b # foldr' :: (a -> b -> b) -> b -> Ap f a -> b # foldl :: (b -> a -> b) -> b -> Ap f a -> b # foldl' :: (b -> a -> b) -> b -> Ap f a -> b # foldr1 :: (a -> a -> a) -> Ap f a -> a # foldl1 :: (a -> a -> a) -> Ap f a -> a # toList :: Ap f a -> [a] # null :: Ap f a -> Bool # length :: Ap f a -> Int # elem :: Eq a => a -> Ap f a -> Bool # maximum :: Ord a => Ap f a -> a # minimum :: Ord a => Ap f a -> a # sum :: Num a => Ap f a -> a # product :: Num a => Ap f a -> a #
Foldable f => Foldable (Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m # foldMap :: Monoid m => (a -> m) -> Alt f a -> m # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m # foldr :: (a -> b -> b) -> b -> Alt f a -> b # foldr' :: (a -> b -> b) -> b -> Alt f a -> b # foldl :: (b -> a -> b) -> b -> Alt f a -> b # foldl' :: (b -> a -> b) -> b -> Alt f a -> b # foldr1 :: (a -> a -> a) -> Alt f a -> a # foldl1 :: (a -> a -> a) -> Alt f a -> a # toList :: Alt f a -> [a] # null :: Alt f a -> Bool # length :: Alt f a -> Int # elem :: Eq a => a -> Alt f a -> Bool # maximum :: Ord a => Alt f a -> a # minimum :: Ord a => Alt f a -> a # sum :: Num a => Alt f a -> a # product :: Num a => Alt f a -> a #
Foldable f => Foldable (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Rec1 f m -> m # foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m # foldMap' :: Monoid m => (a -> m) -> Rec1 f a -> m # foldr :: (a -> b -> b) -> b -> Rec1 f a -> b # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b # foldl :: (b -> a -> b) -> b -> Rec1 f a -> b # foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b # foldr1 :: (a -> a -> a) -> Rec1 f a -> a # foldl1 :: (a -> a -> a) -> Rec1 f a -> a # toList :: Rec1 f a -> [a] # null :: Rec1 f a -> Bool # length :: Rec1 f a -> Int # elem :: Eq a => a -> Rec1 f a -> Bool # maximum :: Ord a => Rec1 f a -> a # minimum :: Ord a => Rec1 f a -> a # sum :: Num a => Rec1 f a -> a # product :: Num a => Rec1 f a -> a #
Bifoldable p => Foldable (Fix p)
Instance details Defined in Data.Bifunctor.Fix Methods fold :: Monoid m => Fix p m -> m # foldMap :: Monoid m => (a -> m) -> Fix p a -> m # foldMap' :: Monoid m => (a -> m) -> Fix p a -> m # foldr :: (a -> b -> b) -> b -> Fix p a -> b # foldr' :: (a -> b -> b) -> b -> Fix p a -> b # foldl :: (b -> a -> b) -> b -> Fix p a -> b # foldl' :: (b -> a -> b) -> b -> Fix p a -> b # foldr1 :: (a -> a -> a) -> Fix p a -> a # foldl1 :: (a -> a -> a) -> Fix p a -> a # toList :: Fix p a -> [a] # null :: Fix p a -> Bool # length :: Fix p a -> Int # elem :: Eq a => a -> Fix p a -> Bool # maximum :: Ord a => Fix p a -> a # minimum :: Ord a => Fix p a -> a # sum :: Num a => Fix p a -> a # product :: Num a => Fix p a -> a #
Bifoldable p => Foldable (Join p)
Instance details Defined in Data.Bifunctor.Join Methods fold :: Monoid m => Join p m -> m # foldMap :: Monoid m => (a -> m) -> Join p a -> m # foldMap' :: Monoid m => (a -> m) -> Join p a -> m # foldr :: (a -> b -> b) -> b -> Join p a -> b # foldr' :: (a -> b -> b) -> b -> Join p a -> b # foldl :: (b -> a -> b) -> b -> Join p a -> b # foldl' :: (b -> a -> b) -> b -> Join p a -> b # foldr1 :: (a -> a -> a) -> Join p a -> a # foldl1 :: (a -> a -> a) -> Join p a -> a # toList :: Join p a -> [a] # null :: Join p a -> Bool # length :: Join p a -> Int # elem :: Eq a => a -> Join p a -> Bool # maximum :: Ord a => Join p a -> a # minimum :: Ord a => Join p a -> a # sum :: Num a => Join p a -> a # product :: Num a => Join p a -> a #
Foldable f => Foldable (CofreeF f a)
Instance details Defined in Control.Comonad.Trans.Cofree Methods fold :: Monoid m => CofreeF f a m -> m # foldMap :: Monoid m => (a0 -> m) -> CofreeF f a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> CofreeF f a a0 -> m # foldr :: (a0 -> b -> b) -> b -> CofreeF f a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> CofreeF f a a0 -> b # foldl :: (b -> a0 -> b) -> b -> CofreeF f a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> CofreeF f a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> CofreeF f a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> CofreeF f a a0 -> a0 # toList :: CofreeF f a a0 -> [a0] # null :: CofreeF f a a0 -> Bool # length :: CofreeF f a a0 -> Int # elem :: Eq a0 => a0 -> CofreeF f a a0 -> Bool # maximum :: Ord a0 => CofreeF f a a0 -> a0 # minimum :: Ord a0 => CofreeF f a a0 -> a0 # sum :: Num a0 => CofreeF f a a0 -> a0 # product :: Num a0 => CofreeF f a a0 -> a0 #
(Foldable f, Foldable w) => Foldable (CofreeT f w)
Instance details Defined in Control.Comonad.Trans.Cofree Methods fold :: Monoid m => CofreeT f w m -> m # foldMap :: Monoid m => (a -> m) -> CofreeT f w a -> m # foldMap' :: Monoid m => (a -> m) -> CofreeT f w a -> m # foldr :: (a -> b -> b) -> b -> CofreeT f w a -> b # foldr' :: (a -> b -> b) -> b -> CofreeT f w a -> b # foldl :: (b -> a -> b) -> b -> CofreeT f w a -> b # foldl' :: (b -> a -> b) -> b -> CofreeT f w a -> b # foldr1 :: (a -> a -> a) -> CofreeT f w a -> a # foldl1 :: (a -> a -> a) -> CofreeT f w a -> a # toList :: CofreeT f w a -> [a] # null :: CofreeT f w a -> Bool # length :: CofreeT f w a -> Int # elem :: Eq a => a -> CofreeT f w a -> Bool # maximum :: Ord a => CofreeT f w a -> a # minimum :: Ord a => CofreeT f w a -> a # sum :: Num a => CofreeT f w a -> a # product :: Num a => CofreeT f w a -> a #
Foldable f => Foldable (FreeF f a)
Instance details Defined in Control.Monad.Trans.Free Methods fold :: Monoid m => FreeF f a m -> m # foldMap :: Monoid m => (a0 -> m) -> FreeF f a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> FreeF f a a0 -> m # foldr :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> FreeF f a a0 -> b # foldl :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> FreeF f a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> FreeF f a a0 -> a0 # toList :: FreeF f a a0 -> [a0] # null :: FreeF f a a0 -> Bool # length :: FreeF f a a0 -> Int # elem :: Eq a0 => a0 -> FreeF f a a0 -> Bool # maximum :: Ord a0 => FreeF f a a0 -> a0 # minimum :: Ord a0 => FreeF f a a0 -> a0 # sum :: Num a0 => FreeF f a a0 -> a0 # product :: Num a0 => FreeF f a a0 -> a0 #
(Foldable m, Foldable f) => Foldable (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods fold :: Monoid m0 => FreeT f m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> FreeT f m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> FreeT f m a -> m0 # foldr :: (a -> b -> b) -> b -> FreeT f m a -> b # foldr' :: (a -> b -> b) -> b -> FreeT f m a -> b # foldl :: (b -> a -> b) -> b -> FreeT f m a -> b # foldl' :: (b -> a -> b) -> b -> FreeT f m a -> b # foldr1 :: (a -> a -> a) -> FreeT f m a -> a # foldl1 :: (a -> a -> a) -> FreeT f m a -> a # toList :: FreeT f m a -> [a] # null :: FreeT f m a -> Bool # length :: FreeT f m a -> Int # elem :: Eq a => a -> FreeT f m a -> Bool # maximum :: Ord a => FreeT f m a -> a # minimum :: Ord a => FreeT f m a -> a # sum :: Num a => FreeT f m a -> a # product :: Num a => FreeT f m a -> a #
Foldable (Tagged s)
Instance details Defined in Data.Tagged Methods fold :: Monoid m => Tagged s m -> m # foldMap :: Monoid m => (a -> m) -> Tagged s a -> m # foldMap' :: Monoid m => (a -> m) -> Tagged s a -> m # foldr :: (a -> b -> b) -> b -> Tagged s a -> b # foldr' :: (a -> b -> b) -> b -> Tagged s a -> b # foldl :: (b -> a -> b) -> b -> Tagged s a -> b # foldl' :: (b -> a -> b) -> b -> Tagged s a -> b # foldr1 :: (a -> a -> a) -> Tagged s a -> a # foldl1 :: (a -> a -> a) -> Tagged s a -> a # toList :: Tagged s a -> [a] # null :: Tagged s a -> Bool # length :: Tagged s a -> Int # elem :: Eq a => a -> Tagged s a -> Bool # maximum :: Ord a => Tagged s a -> a # minimum :: Ord a => Tagged s a -> a # sum :: Num a => Tagged s a -> a # product :: Num a => Tagged s a -> a #
(Foldable f, Foldable g) => Foldable (These1 f g)
Instance details Defined in Data.Functor.These Methods fold :: Monoid m => These1 f g m -> m # foldMap :: Monoid m => (a -> m) -> These1 f g a -> m # foldMap' :: Monoid m => (a -> m) -> These1 f g a -> m # foldr :: (a -> b -> b) -> b -> These1 f g a -> b # foldr' :: (a -> b -> b) -> b -> These1 f g a -> b # foldl :: (b -> a -> b) -> b -> These1 f g a -> b # foldl' :: (b -> a -> b) -> b -> These1 f g a -> b # foldr1 :: (a -> a -> a) -> These1 f g a -> a # foldl1 :: (a -> a -> a) -> These1 f g a -> a # toList :: These1 f g a -> [a] # null :: These1 f g a -> Bool # length :: These1 f g a -> Int # elem :: Eq a => a -> These1 f g a -> Bool # maximum :: Ord a => These1 f g a -> a # minimum :: Ord a => These1 f g a -> a # sum :: Num a => These1 f g a -> a # product :: Num a => These1 f g a -> a #
Foldable f => Foldable (ErrorT e f)
Instance details Defined in Control.Monad.Trans.Error Methods fold :: Monoid m => ErrorT e f m -> m # foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ErrorT e f a -> m # foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b # foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b # foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b # foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b # foldr1 :: (a -> a -> a) -> ErrorT e f a -> a # foldl1 :: (a -> a -> a) -> ErrorT e f a -> a # toList :: ErrorT e f a -> [a] # null :: ErrorT e f a -> Bool # length :: ErrorT e f a -> Int # elem :: Eq a => a -> ErrorT e f a -> Bool # maximum :: Ord a => ErrorT e f a -> a # minimum :: Ord a => ErrorT e f a -> a # sum :: Num a => ErrorT e f a -> a # product :: Num a => ErrorT e f a -> a #
Foldable f => Foldable (ExceptT e f)
Instance details Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m # foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] # null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # sum :: Num a => ExceptT e f a -> a # product :: Num a => ExceptT e f a -> a #
Foldable f => Foldable (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods fold :: Monoid m => IdentityT f m -> m # foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m # foldMap' :: Monoid m => (a -> m) -> IdentityT f a -> m # foldr :: (a -> b -> b) -> b -> IdentityT f a -> b # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b # foldl :: (b -> a -> b) -> b -> IdentityT f a -> b # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b # foldr1 :: (a -> a -> a) -> IdentityT f a -> a # foldl1 :: (a -> a -> a) -> IdentityT f a -> a # toList :: IdentityT f a -> [a] # null :: IdentityT f a -> Bool # length :: IdentityT f a -> Int # elem :: Eq a => a -> IdentityT f a -> Bool # maximum :: Ord a => IdentityT f a -> a # minimum :: Ord a => IdentityT f a -> a # sum :: Num a => IdentityT f a -> a # product :: Num a => IdentityT f a -> a #
Foldable (Const a :: Type -> Type)
Instance details Defined in Data.Vinyl.Functor Methods fold :: Monoid m => Const a m -> m # foldMap :: Monoid m => (a0 -> m) -> Const a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Const a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Const a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Const a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Const a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Const a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Const a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Const a a0 -> a0 # toList :: Const a a0 -> [a0] # null :: Const a a0 -> Bool # length :: Const a a0 -> Int # elem :: Eq a0 => a0 -> Const a a0 -> Bool # maximum :: Ord a0 => Const a a0 -> a0 # minimum :: Ord a0 => Const a a0 -> a0 # sum :: Num a0 => Const a a0 -> a0 # product :: Num a0 => Const a a0 -> a0 #
(Foldable f, Foldable g) => Foldable (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods fold :: Monoid m => Product f g m -> m # foldMap :: Monoid m => (a -> m) -> Product f g a -> m # foldMap' :: Monoid m => (a -> m) -> Product f g a -> m # foldr :: (a -> b -> b) -> b -> Product f g a -> b # foldr' :: (a -> b -> b) -> b -> Product f g a -> b # foldl :: (b -> a -> b) -> b -> Product f g a -> b # foldl' :: (b -> a -> b) -> b -> Product f g a -> b # foldr1 :: (a -> a -> a) -> Product f g a -> a # foldl1 :: (a -> a -> a) -> Product f g a -> a # toList :: Product f g a -> [a] # null :: Product f g a -> Bool # length :: Product f g a -> Int # elem :: Eq a => a -> Product f g a -> Bool # maximum :: Ord a => Product f g a -> a # minimum :: Ord a => Product f g a -> a # sum :: Num a => Product f g a -> a # product :: Num a => Product f g a -> a #
(Foldable f, Foldable g) => Foldable (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods fold :: Monoid m => Sum f g m -> m # foldMap :: Monoid m => (a -> m) -> Sum f g a -> m # foldMap' :: Monoid m => (a -> m) -> Sum f g a -> m # foldr :: (a -> b -> b) -> b -> Sum f g a -> b # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b # foldl :: (b -> a -> b) -> b -> Sum f g a -> b # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b # foldr1 :: (a -> a -> a) -> Sum f g a -> a # foldl1 :: (a -> a -> a) -> Sum f g a -> a # toList :: Sum f g a -> [a] # null :: Sum f g a -> Bool # length :: Sum f g a -> Int # elem :: Eq a => a -> Sum f g a -> Bool # maximum :: Ord a => Sum f g a -> a # minimum :: Ord a => Sum f g a -> a # sum :: Num a => Sum f g a -> a # product :: Num a => Sum f g a -> a #
(Foldable f, Foldable g) => Foldable (f :*: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :: g) a -> b # foldr1 :: (a -> a -> a) -> (f :: g) a -> a # foldl1 :: (a -> a -> a) -> (f :: g) a -> a # toList :: (f :: g) a -> [a] # null :: (f :: g) a -> Bool # length :: (f :: g) a -> Int # elem :: Eq a => a -> (f :: g) a -> Bool # maximum :: Ord a => (f :: g) a -> a # minimum :: Ord a => (f :: g) a -> a # sum :: Num a => (f :: g) a -> a # product :: Num a => (f :*: g) a -> a #
(Foldable f, Foldable g) => Foldable (f :+: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldr1 :: (a -> a -> a) -> (f :+: g) a -> a # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a # toList :: (f :+: g) a -> [a] # null :: (f :+: g) a -> Bool # length :: (f :+: g) a -> Int # elem :: Eq a => a -> (f :+: g) a -> Bool # maximum :: Ord a => (f :+: g) a -> a # minimum :: Ord a => (f :+: g) a -> a # sum :: Num a => (f :+: g) a -> a # product :: Num a => (f :+: g) a -> a #
Foldable (K1 i c :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m # foldMap :: Monoid m => (a -> m) -> K1 i c a -> m # foldMap' :: Monoid m => (a -> m) -> K1 i c a -> m # foldr :: (a -> b -> b) -> b -> K1 i c a -> b # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b # foldl :: (b -> a -> b) -> b -> K1 i c a -> b # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b # foldr1 :: (a -> a -> a) -> K1 i c a -> a # foldl1 :: (a -> a -> a) -> K1 i c a -> a # toList :: K1 i c a -> [a] # null :: K1 i c a -> Bool # length :: K1 i c a -> Int # elem :: Eq a => a -> K1 i c a -> Bool # maximum :: Ord a => K1 i c a -> a # minimum :: Ord a => K1 i c a -> a # sum :: Num a => K1 i c a -> a # product :: Num a => K1 i c a -> a #
(Foldable f, Foldable g) => Foldable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m # foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m # foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b # foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b # foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] # null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # sum :: Num a => Compose f g a -> a # product :: Num a => Compose f g a -> a #
(Foldable f, Foldable g) => Foldable (f :.: g)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m # foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldr1 :: (a -> a -> a) -> (f :.: g) a -> a # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a # toList :: (f :.: g) a -> [a] # null :: (f :.: g) a -> Bool # length :: (f :.: g) a -> Int # elem :: Eq a => a -> (f :.: g) a -> Bool # maximum :: Ord a => (f :.: g) a -> a # minimum :: Ord a => (f :.: g) a -> a # sum :: Num a => (f :.: g) a -> a # product :: Num a => (f :.: g) a -> a #
Foldable f => Foldable (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m # foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m # foldMap' :: Monoid m => (a -> m) -> M1 i c f a -> m # foldr :: (a -> b -> b) -> b -> M1 i c f a -> b # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b # foldl :: (b -> a -> b) -> b -> M1 i c f a -> b # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b # foldr1 :: (a -> a -> a) -> M1 i c f a -> a # foldl1 :: (a -> a -> a) -> M1 i c f a -> a # toList :: M1 i c f a -> [a] # null :: M1 i c f a -> Bool # length :: M1 i c f a -> Int # elem :: Eq a => a -> M1 i c f a -> Bool # maximum :: Ord a => M1 i c f a -> a # minimum :: Ord a => M1 i c f a -> a # sum :: Num a => M1 i c f a -> a # product :: Num a => M1 i c f a -> a #
Foldable (Clown f a :: Type -> Type)
Instance details Defined in Data.Bifunctor.Clown Methods fold :: Monoid m => Clown f a m -> m # foldMap :: Monoid m => (a0 -> m) -> Clown f a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Clown f a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Clown f a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Clown f a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Clown f a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Clown f a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Clown f a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Clown f a a0 -> a0 # toList :: Clown f a a0 -> [a0] # null :: Clown f a a0 -> Bool # length :: Clown f a a0 -> Int # elem :: Eq a0 => a0 -> Clown f a a0 -> Bool # maximum :: Ord a0 => Clown f a a0 -> a0 # minimum :: Ord a0 => Clown f a a0 -> a0 # sum :: Num a0 => Clown f a a0 -> a0 # product :: Num a0 => Clown f a a0 -> a0 #
Bifoldable p => Foldable (Flip p a)
Instance details Defined in Data.Bifunctor.Flip Methods fold :: Monoid m => Flip p a m -> m # foldMap :: Monoid m => (a0 -> m) -> Flip p a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Flip p a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Flip p a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Flip p a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Flip p a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Flip p a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0 # toList :: Flip p a a0 -> [a0] # null :: Flip p a a0 -> Bool # length :: Flip p a a0 -> Int # elem :: Eq a0 => a0 -> Flip p a a0 -> Bool # maximum :: Ord a0 => Flip p a a0 -> a0 # minimum :: Ord a0 => Flip p a a0 -> a0 # sum :: Num a0 => Flip p a a0 -> a0 # product :: Num a0 => Flip p a a0 -> a0 #
Foldable g => Foldable (Joker g a)
Instance details Defined in Data.Bifunctor.Joker Methods fold :: Monoid m => Joker g a m -> m # foldMap :: Monoid m => (a0 -> m) -> Joker g a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Joker g a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Joker g a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Joker g a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Joker g a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Joker g a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Joker g a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Joker g a a0 -> a0 # toList :: Joker g a a0 -> [a0] # null :: Joker g a a0 -> Bool # length :: Joker g a a0 -> Int # elem :: Eq a0 => a0 -> Joker g a a0 -> Bool # maximum :: Ord a0 => Joker g a a0 -> a0 # minimum :: Ord a0 => Joker g a a0 -> a0 # sum :: Num a0 => Joker g a a0 -> a0 # product :: Num a0 => Joker g a a0 -> a0 #
Bifoldable p => Foldable (WrappedBifunctor p a)
Instance details Defined in Data.Bifunctor.Wrapped Methods fold :: Monoid m => WrappedBifunctor p a m -> m # foldMap :: Monoid m => (a0 -> m) -> WrappedBifunctor p a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> WrappedBifunctor p a a0 -> m # foldr :: (a0 -> b -> b) -> b -> WrappedBifunctor p a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> WrappedBifunctor p a a0 -> b # foldl :: (b -> a0 -> b) -> b -> WrappedBifunctor p a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> WrappedBifunctor p a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> WrappedBifunctor p a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> WrappedBifunctor p a a0 -> a0 # toList :: WrappedBifunctor p a a0 -> [a0] # null :: WrappedBifunctor p a a0 -> Bool # length :: WrappedBifunctor p a a0 -> Int # elem :: Eq a0 => a0 -> WrappedBifunctor p a a0 -> Bool # maximum :: Ord a0 => WrappedBifunctor p a a0 -> a0 # minimum :: Ord a0 => WrappedBifunctor p a a0 -> a0 # sum :: Num a0 => WrappedBifunctor p a a0 -> a0 # product :: Num a0 => WrappedBifunctor p a a0 -> a0 #
(Foldable f, Foldable g) => Foldable (Compose f g)
Instance details Defined in Data.Vinyl.Functor Methods fold :: Monoid m => Compose f g m -> m # foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m # foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b # foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b # foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] # null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # sum :: Num a => Compose f g a -> a # product :: Num a => Compose f g a -> a #
(Foldable f, Bifoldable p) => Foldable (Tannen f p a)
Instance details Defined in Data.Bifunctor.Tannen Methods fold :: Monoid m => Tannen f p a m -> m # foldMap :: Monoid m => (a0 -> m) -> Tannen f p a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Tannen f p a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0 # toList :: Tannen f p a a0 -> [a0] # null :: Tannen f p a a0 -> Bool # length :: Tannen f p a a0 -> Int # elem :: Eq a0 => a0 -> Tannen f p a a0 -> Bool # maximum :: Ord a0 => Tannen f p a a0 -> a0 # minimum :: Ord a0 => Tannen f p a a0 -> a0 # sum :: Num a0 => Tannen f p a a0 -> a0 # product :: Num a0 => Tannen f p a a0 -> a0 #
(Bifoldable p, Foldable g) => Foldable (Biff p f g a)
Instance details Defined in Data.Bifunctor.Biff Methods fold :: Monoid m => Biff p f g a m -> m # foldMap :: Monoid m => (a0 -> m) -> Biff p f g a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Biff p f g a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0 # toList :: Biff p f g a a0 -> [a0] # null :: Biff p f g a a0 -> Bool # length :: Biff p f g a a0 -> Int # elem :: Eq a0 => a0 -> Biff p f g a a0 -> Bool # maximum :: Ord a0 => Biff p f g a a0 -> a0 # minimum :: Ord a0 => Biff p f g a a0 -> a0 # sum :: Num a0 => Biff p f g a a0 -> a0 # product :: Num a0 => Biff p f g a a0 -> a0 #

class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #

Functors representing data structures that can be transformed to structures of the same shape by performing an Applicative (or, therefore, Monad) action on each element from left to right.

A more detailed description of what same shape means, the various methods, how traversals are constructed, and example advanced use-cases can be found in the Overview section of Data.Traversable.

For the class laws see the Laws section of Data.Traversable.

Minimal complete definition

traverse | sequenceA

Methods

traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_.

Examples

Expand

Basic usage:

In the first two examples we show each evaluated action mapping to the output structure.

>>> traverse Just [1,2,3,4]
Just [1,2,3,4]

>>> traverse id [Right 1, Right 2, Right 3, Right 4]
Right [1,2,3,4]

In the next examples, we show that Nothing and Left values short circuit the created structure.

>>> traverse (const Nothing) [1,2,3,4]
Nothing

>>> traverse (\x -> if odd x then Just x else Nothing)  [1,2,3,4]
Nothing

>>> traverse id [Right 1, Right 2, Right 3, Right 4, Left 0]
Left 0

sequenceA :: Applicative f => t (f a) -> f (t a) #

Evaluate each action in the structure from left to right, and collect the results. For a version that ignores the results see sequenceA_.

Examples

Expand

Basic usage:

For the first two examples we show sequenceA fully evaluating a a structure and collecting the results.

>>> sequenceA [Just 1, Just 2, Just 3]
Just [1,2,3]

>>> sequenceA [Right 1, Right 2, Right 3]
Right [1,2,3]

The next two example show Nothing and Just will short circuit the resulting structure if present in the input. For more context, check the Traversable instances for Either and Maybe.

>>> sequenceA [Just 1, Just 2, Just 3, Nothing]
Nothing

>>> sequenceA [Right 1, Right 2, Right 3, Left 4]
Left 4

mapM :: Monad m => (a -> m b) -> t a -> m (t b) #

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see mapM_.

Examples

Expand

mapM is literally a traverse with a type signature restricted to Monad. Its implementation may be more efficient due to additional power of Monad.

sequence :: Monad m => t (m a) -> m (t a) #

Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_.

Examples

Expand

Basic usage:

The first two examples are instances where the input and and output of sequence are isomorphic.

>>> sequence $ Right [1,2,3,4]
[Right 1,Right 2,Right 3,Right 4]

>>> sequence $ [Right 1,Right 2,Right 3,Right 4]
Right [1,2,3,4]

The following examples demonstrate short circuit behavior for sequence.

>>> sequence $ Left [1,2,3,4]
Left [1,2,3,4]

>>> sequence $ [Left 0, Right 1,Right 2,Right 3,Right 4]
Left 0

Instances

Instances details

Traversable KeyMap
Instance details Defined in Data.Aeson.KeyMap Methods traverse :: Applicative f => (a -> f b) -> KeyMap a -> f (KeyMap b) # sequenceA :: Applicative f => KeyMap (f a) -> f (KeyMap a) # mapM :: Monad m => (a -> m b) -> KeyMap a -> m (KeyMap b) # sequence :: Monad m => KeyMap (m a) -> m (KeyMap a) #
Traversable IResult
Instance details Defined in Data.Aeson.Types.Internal Methods traverse :: Applicative f => (a -> f b) -> IResult a -> f (IResult b) # sequenceA :: Applicative f => IResult (f a) -> f (IResult a) # mapM :: Monad m => (a -> m b) -> IResult a -> m (IResult b) # sequence :: Monad m => IResult (m a) -> m (IResult a) #
Traversable Result
Instance details Defined in Data.Aeson.Types.Internal Methods traverse :: Applicative f => (a -> f b) -> Result a -> f (Result b) # sequenceA :: Applicative f => Result (f a) -> f (Result a) # mapM :: Monad m => (a -> m b) -> Result a -> m (Result b) # sequence :: Monad m => Result (m a) -> m (Result a) #
Traversable ZipList	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) # sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) # mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) # sequence :: Monad m => ZipList (m a) -> m (ZipList a) #
Traversable Complex	Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) # sequenceA :: Applicative f => Complex (f a) -> f (Complex a) # mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) # sequence :: Monad m => Complex (m a) -> m (Complex a) #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) # sequence :: Monad m => Identity (m a) -> m (Identity a) #
Traversable First	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) # sequence :: Monad m => First (m a) -> m (First a) #
Traversable Last	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) # sequence :: Monad m => Last (m a) -> m (Last a) #
Traversable Down	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Down a -> f (Down b) # sequenceA :: Applicative f => Down (f a) -> f (Down a) # mapM :: Monad m => (a -> m b) -> Down a -> m (Down b) # sequence :: Monad m => Down (m a) -> m (Down a) #
Traversable First	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) # sequence :: Monad m => First (m a) -> m (First a) #
Traversable Last	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) # sequence :: Monad m => Last (m a) -> m (Last a) #
Traversable Max	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Max a -> f (Max b) # sequenceA :: Applicative f => Max (f a) -> f (Max a) # mapM :: Monad m => (a -> m b) -> Max a -> m (Max b) # sequence :: Monad m => Max (m a) -> m (Max a) #
Traversable Min	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Min a -> f (Min b) # sequenceA :: Applicative f => Min (f a) -> f (Min a) # mapM :: Monad m => (a -> m b) -> Min a -> m (Min b) # sequence :: Monad m => Min (m a) -> m (Min a) #
Traversable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) # sequenceA :: Applicative f => Option (f a) -> f (Option a) # mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) # sequence :: Monad m => Option (m a) -> m (Option a) #
Traversable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) # sequenceA :: Applicative f => Dual (f a) -> f (Dual a) # mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) # sequence :: Monad m => Dual (m a) -> m (Dual a) #
Traversable Product	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) # sequenceA :: Applicative f => Product (f a) -> f (Product a) # mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) # sequence :: Monad m => Product (m a) -> m (Product a) #
Traversable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) # sequenceA :: Applicative f => Sum (f a) -> f (Sum a) # mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) # sequence :: Monad m => Sum (m a) -> m (Sum a) #
Traversable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) # sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) # mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) # sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) #
Traversable Par1	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b) # sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a) # mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b) # sequence :: Monad m => Par1 (m a) -> m (Par1 a) #
Traversable Identifier
Instance details Defined in Text.Casing Methods traverse :: Applicative f => (a -> f b) -> Identifier a -> f (Identifier b) # sequenceA :: Applicative f => Identifier (f a) -> f (Identifier a) # mapM :: Monad m => (a -> m b) -> Identifier a -> m (Identifier b) # sequence :: Monad m => Identifier (m a) -> m (Identifier a) #
Traversable SCC	Since: containers-0.5.9
Instance details Defined in Data.Graph Methods traverse :: Applicative f => (a -> f b) -> SCC a -> f (SCC b) # sequenceA :: Applicative f => SCC (f a) -> f (SCC a) # mapM :: Monad m => (a -> m b) -> SCC a -> m (SCC b) # sequence :: Monad m => SCC (m a) -> m (SCC a) #
Traversable IntMap	Traverses in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b) # sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a) # mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b) # sequence :: Monad m => IntMap (m a) -> m (IntMap a) #
Traversable Digit
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Digit a -> f (Digit b) # sequenceA :: Applicative f => Digit (f a) -> f (Digit a) # mapM :: Monad m => (a -> m b) -> Digit a -> m (Digit b) # sequence :: Monad m => Digit (m a) -> m (Digit a) #
Traversable Elem
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Elem a -> f (Elem b) # sequenceA :: Applicative f => Elem (f a) -> f (Elem a) # mapM :: Monad m => (a -> m b) -> Elem a -> m (Elem b) # sequence :: Monad m => Elem (m a) -> m (Elem a) #
Traversable FingerTree
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> FingerTree a -> f (FingerTree b) # sequenceA :: Applicative f => FingerTree (f a) -> f (FingerTree a) # mapM :: Monad m => (a -> m b) -> FingerTree a -> m (FingerTree b) # sequence :: Monad m => FingerTree (m a) -> m (FingerTree a) #
Traversable Node
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Node a -> f (Node b) # sequenceA :: Applicative f => Node (f a) -> f (Node a) # mapM :: Monad m => (a -> m b) -> Node a -> m (Node b) # sequence :: Monad m => Node (m a) -> m (Node a) #
Traversable Seq
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) # sequenceA :: Applicative f => Seq (f a) -> f (Seq a) # mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) # sequence :: Monad m => Seq (m a) -> m (Seq a) #
Traversable ViewL
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> ViewL a -> f (ViewL b) # sequenceA :: Applicative f => ViewL (f a) -> f (ViewL a) # mapM :: Monad m => (a -> m b) -> ViewL a -> m (ViewL b) # sequence :: Monad m => ViewL (m a) -> m (ViewL a) #
Traversable ViewR
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> ViewR a -> f (ViewR b) # sequenceA :: Applicative f => ViewR (f a) -> f (ViewR a) # mapM :: Monad m => (a -> m b) -> ViewR a -> m (ViewR b) # sequence :: Monad m => ViewR (m a) -> m (ViewR a) #
Traversable Tree
Instance details Defined in Data.Tree Methods traverse :: Applicative f => (a -> f b) -> Tree a -> f (Tree b) # sequenceA :: Applicative f => Tree (f a) -> f (Tree a) # mapM :: Monad m => (a -> m b) -> Tree a -> m (Tree b) # sequence :: Monad m => Tree (m a) -> m (Tree a) #
Traversable DList
Instance details Defined in Data.DList.Internal Methods traverse :: Applicative f => (a -> f b) -> DList a -> f (DList b) # sequenceA :: Applicative f => DList (f a) -> f (DList a) # mapM :: Monad m => (a -> m b) -> DList a -> m (DList b) # sequence :: Monad m => DList (m a) -> m (DList a) #
Traversable ResultStateLogs
Instance details Defined in Morley.Michelson.Interpret Methods traverse :: Applicative f => (a -> f b) -> ResultStateLogs a -> f (ResultStateLogs b) # sequenceA :: Applicative f => ResultStateLogs (f a) -> f (ResultStateLogs a) # mapM :: Monad m => (a -> m b) -> ResultStateLogs a -> m (ResultStateLogs b) # sequence :: Monad m => ResultStateLogs (m a) -> m (ResultStateLogs a) #
Traversable SomeSizedList
Instance details Defined in Morley.Util.SizedList Methods traverse :: Applicative f => (a -> f b) -> SomeSizedList a -> f (SomeSizedList b) # sequenceA :: Applicative f => SomeSizedList (f a) -> f (SomeSizedList a) # mapM :: Monad m => (a -> m b) -> SomeSizedList a -> m (SomeSizedList b) # sequence :: Monad m => SomeSizedList (m a) -> m (SomeSizedList a) #
Traversable Array
Instance details Defined in Data.Primitive.Array Methods traverse :: Applicative f => (a -> f b) -> Array a -> f (Array b) # sequenceA :: Applicative f => Array (f a) -> f (Array a) # mapM :: Monad m => (a -> m b) -> Array a -> m (Array b) # sequence :: Monad m => Array (m a) -> m (Array a) #
Traversable SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods traverse :: Applicative f => (a -> f b) -> SmallArray a -> f (SmallArray b) # sequenceA :: Applicative f => SmallArray (f a) -> f (SmallArray a) # mapM :: Monad m => (a -> m b) -> SmallArray a -> m (SmallArray b) # sequence :: Monad m => SmallArray (m a) -> m (SmallArray a) #
Traversable Add
Instance details Defined in Data.Semiring Methods traverse :: Applicative f => (a -> f b) -> Add a -> f (Add b) # sequenceA :: Applicative f => Add (f a) -> f (Add a) # mapM :: Monad m => (a -> m b) -> Add a -> m (Add b) # sequence :: Monad m => Add (m a) -> m (Add a) #
Traversable Mul
Instance details Defined in Data.Semiring Methods traverse :: Applicative f => (a -> f b) -> Mul a -> f (Mul b) # sequenceA :: Applicative f => Mul (f a) -> f (Mul a) # mapM :: Monad m => (a -> m b) -> Mul a -> m (Mul b) # sequence :: Monad m => Mul (m a) -> m (Mul a) #
Traversable WrappedNum
Instance details Defined in Data.Semiring Methods traverse :: Applicative f => (a -> f b) -> WrappedNum a -> f (WrappedNum b) # sequenceA :: Applicative f => WrappedNum (f a) -> f (WrappedNum a) # mapM :: Monad m => (a -> m b) -> WrappedNum a -> m (WrappedNum b) # sequence :: Monad m => WrappedNum (m a) -> m (WrappedNum a) #
Traversable Maybe
Instance details Defined in Data.Strict.Maybe Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Traversable Vector
Instance details Defined in Data.Vector Methods traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b) # sequenceA :: Applicative f => Vector (f a) -> f (Vector a) # mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b) # sequence :: Monad m => Vector (m a) -> m (Vector a) #
Traversable Identity
Instance details Defined in Data.Vinyl.Functor Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) # sequence :: Monad m => Identity (m a) -> m (Identity a) #
Traversable Thunk
Instance details Defined in Data.Vinyl.Functor Methods traverse :: Applicative f => (a -> f b) -> Thunk a -> f (Thunk b) # sequenceA :: Applicative f => Thunk (f a) -> f (Thunk a) # mapM :: Monad m => (a -> m b) -> Thunk a -> m (Thunk b) # sequence :: Monad m => Thunk (m a) -> m (Thunk a) #
Traversable Maybe	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Traversable Solo	Since: base-4.15
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Solo a -> f (Solo b) # sequenceA :: Applicative f => Solo (f a) -> f (Solo a) # mapM :: Monad m => (a -> m b) -> Solo a -> m (Solo b) # sequence :: Monad m => Solo (m a) -> m (Solo a) #
Traversable []	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> [a] -> f [b] # sequenceA :: Applicative f => [f a] -> f [a] # mapM :: Monad m => (a -> m b) -> [a] -> m [b] # sequence :: Monad m => [m a] -> m [a] #
Traversable (Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b) # sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0) # mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b) # sequence :: Monad m => Either a (m a0) -> m (Either a a0) #
Traversable (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details 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) #
Traversable (Arg a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a0 -> f b) -> Arg a a0 -> f (Arg a b) # sequenceA :: Applicative f => Arg a (f a0) -> f (Arg a a0) # mapM :: Monad m => (a0 -> m b) -> Arg a a0 -> m (Arg a b) # sequence :: Monad m => Arg a (m a0) -> m (Arg a a0) #
Ix i => Traversable (Array i)	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b) # sequenceA :: Applicative f => Array i (f a) -> f (Array i a) # mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b) # sequence :: Monad m => Array i (m a) -> m (Array i a) #
Traversable (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> U1 a -> f (U1 b) # sequenceA :: Applicative f => U1 (f a) -> f (U1 a) # mapM :: Monad m => (a -> m b) -> U1 a -> m (U1 b) # sequence :: Monad m => U1 (m a) -> m (U1 a) #
Traversable (UAddr :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b) # sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a) # mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b) # sequence :: Monad m => UAddr (m a) -> m (UAddr a) #
Traversable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b) # sequenceA :: Applicative f => UChar (f a) -> f (UChar a) # mapM :: Monad m => (a -> m b) -> UChar a -> m (UChar b) # sequence :: Monad m => UChar (m a) -> m (UChar a) #
Traversable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) # sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) # mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b) # sequence :: Monad m => UDouble (m a) -> m (UDouble a) #
Traversable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) # sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) # mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b) # sequence :: Monad m => UFloat (m a) -> m (UFloat a) #
Traversable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) # sequenceA :: Applicative f => UInt (f a) -> f (UInt a) # mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b) # sequence :: Monad m => UInt (m a) -> m (UInt a) #
Traversable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) # sequenceA :: Applicative f => UWord (f a) -> f (UWord a) # mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b) # sequence :: Monad m => UWord (m a) -> m (UWord a) #
Traversable (V1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b) # sequenceA :: Applicative f => V1 (f a) -> f (V1 a) # mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b) # sequence :: Monad m => V1 (m a) -> m (V1 a) #
Traversable (Map k)	Traverses in order of increasing key.
Instance details Defined in Data.Map.Internal Methods traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) # sequenceA :: Applicative f => Map k (f a) -> f (Map k a) # mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) # sequence :: Monad m => Map k (m a) -> m (Map k a) #
Traversable f => Traversable (Cofree f)
Instance details Defined in Control.Comonad.Cofree Methods traverse :: Applicative f0 => (a -> f0 b) -> Cofree f a -> f0 (Cofree f b) # sequenceA :: Applicative f0 => Cofree f (f0 a) -> f0 (Cofree f a) # mapM :: Monad m => (a -> m b) -> Cofree f a -> m (Cofree f b) # sequence :: Monad m => Cofree f (m a) -> m (Cofree f a) #
Traversable f => Traversable (Free f)
Instance details Defined in Control.Monad.Free Methods traverse :: Applicative f0 => (a -> f0 b) -> Free f a -> f0 (Free f b) # sequenceA :: Applicative f0 => Free f (f0 a) -> f0 (Free f a) # mapM :: Monad m => (a -> m b) -> Free f a -> m (Free f b) # sequence :: Monad m => Free f (m a) -> m (Free f a) #
Traversable f => Traversable (Yoneda f)
Instance details Defined in Data.Functor.Yoneda Methods traverse :: Applicative f0 => (a -> f0 b) -> Yoneda f a -> f0 (Yoneda f b) # sequenceA :: Applicative f0 => Yoneda f (f0 a) -> f0 (Yoneda f a) # mapM :: Monad m => (a -> m b) -> Yoneda f a -> m (Yoneda f b) # sequence :: Monad m => Yoneda f (m a) -> m (Yoneda f a) #
Traversable (SizedList' n)
Instance details Defined in Morley.Util.SizedList Methods traverse :: Applicative f => (a -> f b) -> SizedList' n a -> f (SizedList' n b) # sequenceA :: Applicative f => SizedList' n (f a) -> f (SizedList' n a) # mapM :: Monad m => (a -> m b) -> SizedList' n a -> m (SizedList' n b) # sequence :: Monad m => SizedList' n (m a) -> m (SizedList' n a) #
Traversable (Either e)
Instance details Defined in Data.Strict.Either Methods traverse :: Applicative f => (a -> f b) -> Either e a -> f (Either e b) # sequenceA :: Applicative f => Either e (f a) -> f (Either e a) # mapM :: Monad m => (a -> m b) -> Either e a -> m (Either e b) # sequence :: Monad m => Either e (m a) -> m (Either e a) #
Traversable (These a)
Instance details Defined in Data.Strict.These Methods traverse :: Applicative f => (a0 -> f b) -> These a a0 -> f (These a b) # sequenceA :: Applicative f => These a (f a0) -> f (These a a0) # mapM :: Monad m => (a0 -> m b) -> These a a0 -> m (These a b) # sequence :: Monad m => These a (m a0) -> m (These a a0) #
Traversable (Pair e)
Instance details Defined in Data.Strict.Tuple Methods traverse :: Applicative f => (a -> f b) -> Pair e a -> f (Pair e b) # sequenceA :: Applicative f => Pair e (f a) -> f (Pair e a) # mapM :: Monad m => (a -> m b) -> Pair e a -> m (Pair e b) # sequence :: Monad m => Pair e (m a) -> m (Pair e a) #
Traversable (These a)
Instance details Defined in Data.These Methods traverse :: Applicative f => (a0 -> f b) -> These a a0 -> f (These a b) # sequenceA :: Applicative f => These a (f a0) -> f (These a a0) # mapM :: Monad m => (a0 -> m b) -> These a a0 -> m (These a b) # sequence :: Monad m => These a (m a0) -> m (These a a0) #
Traversable f => Traversable (MaybeT f)
Instance details Defined in Control.Monad.Trans.Maybe Methods traverse :: Applicative f0 => (a -> f0 b) -> MaybeT f a -> f0 (MaybeT f b) # sequenceA :: Applicative f0 => MaybeT f (f0 a) -> f0 (MaybeT f a) # mapM :: Monad m => (a -> m b) -> MaybeT f a -> m (MaybeT f b) # sequence :: Monad m => MaybeT f (m a) -> m (MaybeT f a) #
Traversable (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods traverse :: Applicative f => (a -> f b) -> HashMap k a -> f (HashMap k b) # sequenceA :: Applicative f => HashMap k (f a) -> f (HashMap k a) # mapM :: Monad m => (a -> m b) -> HashMap k a -> m (HashMap k b) # sequence :: Monad m => HashMap k (m a) -> m (HashMap k a) #
Traversable ((,) a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> (a, a0) -> f (a, b) # sequenceA :: Applicative f => (a, f a0) -> f (a, a0) # mapM :: Monad m => (a0 -> m b) -> (a, a0) -> m (a, b) # sequence :: Monad m => (a, m a0) -> m (a, a0) #
Traversable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) # sequenceA :: Applicative f => Const m (f a) -> f (Const m a) # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b) # sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a) #
Traversable f => Traversable (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Ap f a -> f0 (Ap f b) # sequenceA :: Applicative f0 => Ap f (f0 a) -> f0 (Ap f a) # mapM :: Monad m => (a -> m b) -> Ap f a -> m (Ap f b) # sequence :: Monad m => Ap f (m a) -> m (Ap f a) #
Traversable f => Traversable (Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Alt f a -> f0 (Alt f b) # sequenceA :: Applicative f0 => Alt f (f0 a) -> f0 (Alt f a) # mapM :: Monad m => (a -> m b) -> Alt f a -> m (Alt f b) # sequence :: Monad m => Alt f (m a) -> m (Alt f a) #
Traversable f => Traversable (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b) # sequenceA :: Applicative f0 => Rec1 f (f0 a) -> f0 (Rec1 f a) # mapM :: Monad m => (a -> m b) -> Rec1 f a -> m (Rec1 f b) # sequence :: Monad m => Rec1 f (m a) -> m (Rec1 f a) #
Bitraversable p => Traversable (Fix p)
Instance details Defined in Data.Bifunctor.Fix Methods traverse :: Applicative f => (a -> f b) -> Fix p a -> f (Fix p b) # sequenceA :: Applicative f => Fix p (f a) -> f (Fix p a) # mapM :: Monad m => (a -> m b) -> Fix p a -> m (Fix p b) # sequence :: Monad m => Fix p (m a) -> m (Fix p a) #
Bitraversable p => Traversable (Join p)
Instance details Defined in Data.Bifunctor.Join Methods traverse :: Applicative f => (a -> f b) -> Join p a -> f (Join p b) # sequenceA :: Applicative f => Join p (f a) -> f (Join p a) # mapM :: Monad m => (a -> m b) -> Join p a -> m (Join p b) # sequence :: Monad m => Join p (m a) -> m (Join p a) #
Traversable f => Traversable (CofreeF f a)
Instance details Defined in Control.Comonad.Trans.Cofree Methods traverse :: Applicative f0 => (a0 -> f0 b) -> CofreeF f a a0 -> f0 (CofreeF f a b) # sequenceA :: Applicative f0 => CofreeF f a (f0 a0) -> f0 (CofreeF f a a0) # mapM :: Monad m => (a0 -> m b) -> CofreeF f a a0 -> m (CofreeF f a b) # sequence :: Monad m => CofreeF f a (m a0) -> m (CofreeF f a a0) #
(Traversable f, Traversable w) => Traversable (CofreeT f w)
Instance details Defined in Control.Comonad.Trans.Cofree Methods traverse :: Applicative f0 => (a -> f0 b) -> CofreeT f w a -> f0 (CofreeT f w b) # sequenceA :: Applicative f0 => CofreeT f w (f0 a) -> f0 (CofreeT f w a) # mapM :: Monad m => (a -> m b) -> CofreeT f w a -> m (CofreeT f w b) # sequence :: Monad m => CofreeT f w (m a) -> m (CofreeT f w a) #
Traversable f => Traversable (FreeF f a)
Instance details Defined in Control.Monad.Trans.Free Methods traverse :: Applicative f0 => (a0 -> f0 b) -> FreeF f a a0 -> f0 (FreeF f a b) # sequenceA :: Applicative f0 => FreeF f a (f0 a0) -> f0 (FreeF f a a0) # mapM :: Monad m => (a0 -> m b) -> FreeF f a a0 -> m (FreeF f a b) # sequence :: Monad m => FreeF f a (m a0) -> m (FreeF f a a0) #
(Monad m, Traversable m, Traversable f) => Traversable (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods traverse :: Applicative f0 => (a -> f0 b) -> FreeT f m a -> f0 (FreeT f m b) # sequenceA :: Applicative f0 => FreeT f m (f0 a) -> f0 (FreeT f m a) # mapM :: Monad m0 => (a -> m0 b) -> FreeT f m a -> m0 (FreeT f m b) # sequence :: Monad m0 => FreeT f m (m0 a) -> m0 (FreeT f m a) #
Traversable (Tagged s)
Instance details Defined in Data.Tagged Methods traverse :: Applicative f => (a -> f b) -> Tagged s a -> f (Tagged s b) # sequenceA :: Applicative f => Tagged s (f a) -> f (Tagged s a) # mapM :: Monad m => (a -> m b) -> Tagged s a -> m (Tagged s b) # sequence :: Monad m => Tagged s (m a) -> m (Tagged s a) #
(Traversable f, Traversable g) => Traversable (These1 f g)
Instance details Defined in Data.Functor.These Methods traverse :: Applicative f0 => (a -> f0 b) -> These1 f g a -> f0 (These1 f g b) # sequenceA :: Applicative f0 => These1 f g (f0 a) -> f0 (These1 f g a) # mapM :: Monad m => (a -> m b) -> These1 f g a -> m (These1 f g b) # sequence :: Monad m => These1 f g (m a) -> m (These1 f g a) #
Traversable f => Traversable (ErrorT e f)
Instance details Defined in Control.Monad.Trans.Error Methods traverse :: Applicative f0 => (a -> f0 b) -> ErrorT e f a -> f0 (ErrorT e f b) # sequenceA :: Applicative f0 => ErrorT e f (f0 a) -> f0 (ErrorT e f a) # mapM :: Monad m => (a -> m b) -> ErrorT e f a -> m (ErrorT e f b) # sequence :: Monad m => ErrorT e f (m a) -> m (ErrorT e f a) #
Traversable f => Traversable (ExceptT e f)
Instance details Defined in Control.Monad.Trans.Except Methods traverse :: Applicative f0 => (a -> f0 b) -> ExceptT e f a -> f0 (ExceptT e f b) # sequenceA :: Applicative f0 => ExceptT e f (f0 a) -> f0 (ExceptT e f a) # mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b) # sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a) #
Traversable f => Traversable (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods traverse :: Applicative f0 => (a -> f0 b) -> IdentityT f a -> f0 (IdentityT f b) # sequenceA :: Applicative f0 => IdentityT f (f0 a) -> f0 (IdentityT f a) # mapM :: Monad m => (a -> m b) -> IdentityT f a -> m (IdentityT f b) # sequence :: Monad m => IdentityT f (m a) -> m (IdentityT f a) #
Traversable (Const a :: Type -> Type)
Instance details Defined in Data.Vinyl.Functor Methods traverse :: Applicative f => (a0 -> f b) -> Const a a0 -> f (Const a b) # sequenceA :: Applicative f => Const a (f a0) -> f (Const a a0) # mapM :: Monad m => (a0 -> m b) -> Const a a0 -> m (Const a b) # sequence :: Monad m => Const a (m a0) -> m (Const a a0) #
(Traversable f, Traversable g) => Traversable (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods traverse :: Applicative f0 => (a -> f0 b) -> Product f g a -> f0 (Product f g b) # sequenceA :: Applicative f0 => Product f g (f0 a) -> f0 (Product f g a) # mapM :: Monad m => (a -> m b) -> Product f g a -> m (Product f g b) # sequence :: Monad m => Product f g (m a) -> m (Product f g a) #
(Traversable f, Traversable g) => Traversable (Sum f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods traverse :: Applicative f0 => (a -> f0 b) -> Sum f g a -> f0 (Sum f g b) # sequenceA :: Applicative f0 => Sum f g (f0 a) -> f0 (Sum f g a) # mapM :: Monad m => (a -> m b) -> Sum f g a -> m (Sum f g b) # sequence :: Monad m => Sum f g (m a) -> m (Sum f g a) #
(Traversable f, Traversable g) => Traversable (f :*: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) # sequenceA :: Applicative f0 => (f :: g) (f0 a) -> f0 ((f :: g) a) # mapM :: Monad m => (a -> m b) -> (f :: g) a -> m ((f :: g) b) # sequence :: Monad m => (f :: g) (m a) -> m ((f :: g) a) #
(Traversable f, Traversable g) => Traversable (f :+: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) # sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((f :+: g) a) # mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b) # sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a) #
Traversable (K1 i c :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> K1 i c a -> f (K1 i c b) # sequenceA :: Applicative f => K1 i c (f a) -> f (K1 i c a) # mapM :: Monad m => (a -> m b) -> K1 i c a -> m (K1 i c b) # sequence :: Monad m => K1 i c (m a) -> m (K1 i c a) #
(Traversable f, Traversable g) => Traversable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) # sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a) # mapM :: Monad m => (a -> m b) -> Compose f g a -> m (Compose f g b) # sequence :: Monad m => Compose f g (m a) -> m (Compose f g a) #
(Traversable f, Traversable g) => Traversable (f :.: g)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) # sequenceA :: Applicative f0 => (f :.: g) (f0 a) -> f0 ((f :.: g) a) # mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b) # sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a) #
Traversable f => Traversable (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> M1 i c f a -> f0 (M1 i c f b) # sequenceA :: Applicative f0 => M1 i c f (f0 a) -> f0 (M1 i c f a) # mapM :: Monad m => (a -> m b) -> M1 i c f a -> m (M1 i c f b) # sequence :: Monad m => M1 i c f (m a) -> m (M1 i c f a) #
Traversable (Clown f a :: Type -> Type)
Instance details Defined in Data.Bifunctor.Clown Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Clown f a a0 -> f0 (Clown f a b) # sequenceA :: Applicative f0 => Clown f a (f0 a0) -> f0 (Clown f a a0) # mapM :: Monad m => (a0 -> m b) -> Clown f a a0 -> m (Clown f a b) # sequence :: Monad m => Clown f a (m a0) -> m (Clown f a a0) #
Bitraversable p => Traversable (Flip p a)
Instance details Defined in Data.Bifunctor.Flip Methods traverse :: Applicative f => (a0 -> f b) -> Flip p a a0 -> f (Flip p a b) # sequenceA :: Applicative f => Flip p a (f a0) -> f (Flip p a a0) # mapM :: Monad m => (a0 -> m b) -> Flip p a a0 -> m (Flip p a b) # sequence :: Monad m => Flip p a (m a0) -> m (Flip p a a0) #
Traversable g => Traversable (Joker g a)
Instance details Defined in Data.Bifunctor.Joker Methods traverse :: Applicative f => (a0 -> f b) -> Joker g a a0 -> f (Joker g a b) # sequenceA :: Applicative f => Joker g a (f a0) -> f (Joker g a a0) # mapM :: Monad m => (a0 -> m b) -> Joker g a a0 -> m (Joker g a b) # sequence :: Monad m => Joker g a (m a0) -> m (Joker g a a0) #
Bitraversable p => Traversable (WrappedBifunctor p a)
Instance details Defined in Data.Bifunctor.Wrapped Methods traverse :: Applicative f => (a0 -> f b) -> WrappedBifunctor p a a0 -> f (WrappedBifunctor p a b) # sequenceA :: Applicative f => WrappedBifunctor p a (f a0) -> f (WrappedBifunctor p a a0) # mapM :: Monad m => (a0 -> m b) -> WrappedBifunctor p a a0 -> m (WrappedBifunctor p a b) # sequence :: Monad m => WrappedBifunctor p a (m a0) -> m (WrappedBifunctor p a a0) #
(Traversable f, Traversable g) => Traversable (Compose f g)
Instance details Defined in Data.Vinyl.Functor Methods traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) # sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a) # mapM :: Monad m => (a -> m b) -> Compose f g a -> m (Compose f g b) # sequence :: Monad m => Compose f g (m a) -> m (Compose f g a) #
(Traversable f, Bitraversable p) => Traversable (Tannen f p a)
Instance details Defined in Data.Bifunctor.Tannen Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Tannen f p a a0 -> f0 (Tannen f p a b) # sequenceA :: Applicative f0 => Tannen f p a (f0 a0) -> f0 (Tannen f p a a0) # mapM :: Monad m => (a0 -> m b) -> Tannen f p a a0 -> m (Tannen f p a b) # sequence :: Monad m => Tannen f p a (m a0) -> m (Tannen f p a a0) #
(Bitraversable p, Traversable g) => Traversable (Biff p f g a)
Instance details Defined in Data.Bifunctor.Biff Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Biff p f g a a0 -> f0 (Biff p f g a b) # sequenceA :: Applicative f0 => Biff p f g a (f0 a0) -> f0 (Biff p f g a a0) # mapM :: Monad m => (a0 -> m b) -> Biff p f g a a0 -> m (Biff p f g a b) # sequence :: Monad m => Biff p f g a (m a0) -> m (Biff p f g a a0) #

class Generic a #

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Minimal complete definition

from, to

Instances

Instances details

Generic CabalSpecVersion
Instance details Defined in Distribution.CabalSpecVersion Associated Types type Rep CabalSpecVersion :: Type -> Type # Methods from :: CabalSpecVersion -> Rep CabalSpecVersion x # to :: Rep CabalSpecVersion x -> CabalSpecVersion #
Generic PError
Instance details Defined in Distribution.Parsec.Error Associated Types type Rep PError :: Type -> Type # Methods from :: PError -> Rep PError x # to :: Rep PError x -> PError #
Generic Position
Instance details Defined in Distribution.Parsec.Position Associated Types type Rep Position :: Type -> Type # Methods from :: Position -> Rep Position x # to :: Rep Position x -> Position #
Generic PWarnType
Instance details Defined in Distribution.Parsec.Warning Associated Types type Rep PWarnType :: Type -> Type # Methods from :: PWarnType -> Rep PWarnType x # to :: Rep PWarnType x -> PWarnType #
Generic PWarning
Instance details Defined in Distribution.Parsec.Warning Associated Types type Rep PWarning :: Type -> Type # Methods from :: PWarning -> Rep PWarning x # to :: Rep PWarning x -> PWarning #
Generic Structure
Instance details Defined in Distribution.Utils.Structured Associated Types type Rep Structure :: Type -> Type # Methods from :: Structure -> Rep Structure x # to :: Rep Structure x -> Structure #
Generic Extension
Instance details Defined in Language.Haskell.Extension Associated Types type Rep Extension :: Type -> Type # Methods from :: Extension -> Rep Extension x # to :: Rep Extension x -> Extension #
Generic KnownExtension
Instance details Defined in Language.Haskell.Extension Associated Types type Rep KnownExtension :: Type -> Type # Methods from :: KnownExtension -> Rep KnownExtension x # to :: Rep KnownExtension x -> KnownExtension #
Generic Language
Instance details Defined in Language.Haskell.Extension Associated Types type Rep Language :: Type -> Type # Methods from :: Language -> Rep Language x # to :: Rep Language x -> Language #
Generic Value
Instance details Defined in Data.Aeson.Types.Internal Associated Types type Rep Value :: Type -> Type # Methods from :: Value -> Rep Value x # to :: Rep Value x -> Value #
Generic All
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep All :: Type -> Type # Methods from :: All -> Rep All x # to :: Rep All x -> All #
Generic Any
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep Any :: Type -> Type # Methods from :: Any -> Rep Any x # to :: Rep Any x -> Any #
Generic Version
Instance details Defined in Data.Version Associated Types type Rep Version :: Type -> Type # Methods from :: Version -> Rep Version x # to :: Rep Version x -> Version #
Generic Void
Instance details Defined in Data.Void Associated Types type Rep Void :: Type -> Type # Methods from :: Void -> Rep Void x # to :: Rep Void x -> Void #
Generic Fingerprint
Instance details Defined in GHC.Generics Associated Types type Rep Fingerprint :: Type -> Type # Methods from :: Fingerprint -> Rep Fingerprint x # to :: Rep Fingerprint x -> Fingerprint #
Generic Associativity
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type # Methods from :: Associativity -> Rep Associativity x # to :: Rep Associativity x -> Associativity #
Generic DecidedStrictness
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic Fixity
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic SourceStrictness
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic SourceUnpackedness
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic ExitCode
Instance details Defined in GHC.IO.Exception Associated Types type Rep ExitCode :: Type -> Type # Methods from :: ExitCode -> Rep ExitCode x # to :: Rep ExitCode x -> ExitCode #
Generic CCFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep CCFlags :: Type -> Type # Methods from :: CCFlags -> Rep CCFlags x # to :: Rep CCFlags x -> CCFlags #
Generic ConcFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ConcFlags :: Type -> Type # Methods from :: ConcFlags -> Rep ConcFlags x # to :: Rep ConcFlags x -> ConcFlags #
Generic DebugFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DebugFlags :: Type -> Type # Methods from :: DebugFlags -> Rep DebugFlags x # to :: Rep DebugFlags x -> DebugFlags #
Generic DoCostCentres
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoCostCentres :: Type -> Type # Methods from :: DoCostCentres -> Rep DoCostCentres x # to :: Rep DoCostCentres x -> DoCostCentres #
Generic DoHeapProfile
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoHeapProfile :: Type -> Type # Methods from :: DoHeapProfile -> Rep DoHeapProfile x # to :: Rep DoHeapProfile x -> DoHeapProfile #
Generic DoTrace
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoTrace :: Type -> Type # Methods from :: DoTrace -> Rep DoTrace x # to :: Rep DoTrace x -> DoTrace #
Generic GCFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep GCFlags :: Type -> Type # Methods from :: GCFlags -> Rep GCFlags x # to :: Rep GCFlags x -> GCFlags #
Generic GiveGCStats
Instance details Defined in GHC.RTS.Flags Associated Types type Rep GiveGCStats :: Type -> Type # Methods from :: GiveGCStats -> Rep GiveGCStats x # to :: Rep GiveGCStats x -> GiveGCStats #
Generic MiscFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep MiscFlags :: Type -> Type # Methods from :: MiscFlags -> Rep MiscFlags x # to :: Rep MiscFlags x -> MiscFlags #
Generic ParFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ParFlags :: Type -> Type # Methods from :: ParFlags -> Rep ParFlags x # to :: Rep ParFlags x -> ParFlags #
Generic ProfFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ProfFlags :: Type -> Type # Methods from :: ProfFlags -> Rep ProfFlags x # to :: Rep ProfFlags x -> ProfFlags #
Generic RTSFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep RTSFlags :: Type -> Type # Methods from :: RTSFlags -> Rep RTSFlags x # to :: Rep RTSFlags x -> RTSFlags #
Generic TickyFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep TickyFlags :: Type -> Type # Methods from :: TickyFlags -> Rep TickyFlags x # to :: Rep TickyFlags x -> TickyFlags #
Generic TraceFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep TraceFlags :: Type -> Type # Methods from :: TraceFlags -> Rep TraceFlags x # to :: Rep TraceFlags x -> TraceFlags #
Generic SrcLoc
Instance details Defined in GHC.Generics Associated Types type Rep SrcLoc :: Type -> Type # Methods from :: SrcLoc -> Rep SrcLoc x # to :: Rep SrcLoc x -> SrcLoc #
Generic GCDetails
Instance details Defined in GHC.Stats Associated Types type Rep GCDetails :: Type -> Type # Methods from :: GCDetails -> Rep GCDetails x # to :: Rep GCDetails x -> GCDetails #
Generic RTSStats
Instance details Defined in GHC.Stats Associated Types type Rep RTSStats :: Type -> Type # Methods from :: RTSStats -> Rep RTSStats x # to :: Rep RTSStats x -> RTSStats #
Generic GeneralCategory
Instance details Defined in GHC.Generics Associated Types type Rep GeneralCategory :: Type -> Type # Methods from :: GeneralCategory -> Rep GeneralCategory x # to :: Rep GeneralCategory x -> GeneralCategory #
Generic Alphabet
Instance details Defined in Data.ByteString.Base58.Internal Associated Types type Rep Alphabet :: Type -> Type # Methods from :: Alphabet -> Rep Alphabet x # to :: Rep Alphabet x -> Alphabet #
Generic F2Poly
Instance details Defined in Data.Bit.F2Poly Associated Types type Rep F2Poly :: Type -> Type # Methods from :: F2Poly -> Rep F2Poly x # to :: Rep F2Poly x -> F2Poly #
Generic Bit
Instance details Defined in Data.Bit.Internal Associated Types type Rep Bit :: Type -> Type # Methods from :: Bit -> Rep Bit x # to :: Rep Bit x -> Bit #
Generic Clock
Instance details Defined in System.Clock Associated Types type Rep Clock :: Type -> Type # Methods from :: Clock -> Rep Clock x # to :: Rep Clock x -> Clock #
Generic TimeSpec
Instance details Defined in System.Clock Associated Types type Rep TimeSpec :: Type -> Type # Methods from :: TimeSpec -> Rep TimeSpec x # to :: Rep TimeSpec x -> TimeSpec #
Generic ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Associated Types type Rep ForeignSrcLang :: Type -> Type # Methods from :: ForeignSrcLang -> Rep ForeignSrcLang x # to :: Rep ForeignSrcLang x -> ForeignSrcLang #
Generic Extension
Instance details Defined in GHC.LanguageExtensions.Type Associated Types type Rep Extension :: Type -> Type # Methods from :: Extension -> Rep Extension x # to :: Rep Extension x -> Extension #
Generic Ordering
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Generic RefId Source #
Instance details Defined in Indigo.Common.Var Associated Types type Rep RefId :: Type -> Type # Methods from :: RefId -> Rep RefId x # to :: Rep RefId x -> RefId #
Generic UnspecifiedError
Instance details Defined in Lorentz.Errors Associated Types type Rep UnspecifiedError :: Type -> Type # Methods from :: UnspecifiedError -> Rep UnspecifiedError x # to :: Rep UnspecifiedError x -> UnspecifiedError #
Generic EntrypointLookupError
Instance details Defined in Lorentz.UParam Associated Types type Rep EntrypointLookupError :: Type -> Type # Methods from :: EntrypointLookupError -> Rep EntrypointLookupError x # to :: Rep EntrypointLookupError x -> EntrypointLookupError #
Generic Never
Instance details Defined in Lorentz.Value Associated Types type Rep Never :: Type -> Type # Methods from :: Never -> Rep Never x # to :: Rep Never x -> Never #
Generic OpenChest
Instance details Defined in Lorentz.Value Associated Types type Rep OpenChest :: Type -> Type # Methods from :: OpenChest -> Rep OpenChest x # to :: Rep OpenChest x -> OpenChest #
Generic ZSNil
Instance details Defined in Lorentz.Zip Associated Types type Rep ZSNil :: Type -> Type # Methods from :: ZSNil -> Rep ZSNil x # to :: Rep ZSNil x -> ZSNil #
Generic InvalidPosException
Instance details Defined in Text.Megaparsec.Pos Associated Types type Rep InvalidPosException :: Type -> Type # Methods from :: InvalidPosException -> Rep InvalidPosException x # to :: Rep InvalidPosException x -> InvalidPosException #
Generic Pos
Instance details Defined in Text.Megaparsec.Pos Associated Types type Rep Pos :: Type -> Type # Methods from :: Pos -> Rep Pos x # to :: Rep Pos x -> Pos #
Generic SourcePos
Instance details Defined in Text.Megaparsec.Pos Associated Types type Rep SourcePos :: Type -> Type # Methods from :: SourcePos -> Rep SourcePos x # to :: Rep SourcePos x -> SourcePos #
Generic ErrorSrcPos
Instance details Defined in Morley.Michelson.ErrorPos Associated Types type Rep ErrorSrcPos :: Type -> Type # Methods from :: ErrorSrcPos -> Rep ErrorSrcPos x # to :: Rep ErrorSrcPos x -> ErrorSrcPos #
Generic Pos
Instance details Defined in Morley.Michelson.ErrorPos Associated Types type Rep Pos :: Type -> Type # Methods from :: Pos -> Rep Pos x # to :: Rep Pos x -> Pos #
Generic SrcPos
Instance details Defined in Morley.Michelson.ErrorPos Associated Types type Rep SrcPos :: Type -> Type # Methods from :: SrcPos -> Rep SrcPos x # to :: Rep SrcPos x -> SrcPos #
Generic BadViewNameError
Instance details Defined in Morley.Michelson.Internal.ViewName Associated Types type Rep BadViewNameError :: Type -> Type # Methods from :: BadViewNameError -> Rep BadViewNameError x # to :: Rep BadViewNameError x -> BadViewNameError #
Generic ViewName
Instance details Defined in Morley.Michelson.Internal.ViewName Associated Types type Rep ViewName :: Type -> Type # Methods from :: ViewName -> Rep ViewName x # to :: Rep ViewName x -> ViewName #
Generic InterpreterState
Instance details Defined in Morley.Michelson.Interpret Associated Types type Rep InterpreterState :: Type -> Type # Methods from :: InterpreterState -> Rep InterpreterState x # to :: Rep InterpreterState x -> InterpreterState #
Generic MorleyLogs
Instance details Defined in Morley.Michelson.Interpret Associated Types type Rep MorleyLogs :: Type -> Type # Methods from :: MorleyLogs -> Rep MorleyLogs x # to :: Rep MorleyLogs x -> MorleyLogs #
Generic MorleyLogsBuilder
Instance details Defined in Morley.Michelson.Interpret Associated Types type Rep MorleyLogsBuilder :: Type -> Type # Methods from :: MorleyLogsBuilder -> Rep MorleyLogsBuilder x # to :: Rep MorleyLogsBuilder x -> MorleyLogsBuilder #
Generic RemainingSteps
Instance details Defined in Morley.Michelson.Interpret Associated Types type Rep RemainingSteps :: Type -> Type # Methods from :: RemainingSteps -> Rep RemainingSteps x # to :: Rep RemainingSteps x -> RemainingSteps #
Generic CadrStruct
Instance details Defined in Morley.Michelson.Macro Associated Types type Rep CadrStruct :: Type -> Type # Methods from :: CadrStruct -> Rep CadrStruct x # to :: Rep CadrStruct x -> CadrStruct #
Generic Macro
Instance details Defined in Morley.Michelson.Macro Associated Types type Rep Macro :: Type -> Type # Methods from :: Macro -> Rep Macro x # to :: Rep Macro x -> Macro #
Generic PairStruct
Instance details Defined in Morley.Michelson.Macro Associated Types type Rep PairStruct :: Type -> Type # Methods from :: PairStruct -> Rep PairStruct x # to :: Rep PairStruct x -> PairStruct #
Generic ParsedOp
Instance details Defined in Morley.Michelson.Macro Associated Types type Rep ParsedOp :: Type -> Type # Methods from :: ParsedOp -> Rep ParsedOp x # to :: Rep ParsedOp x -> ParsedOp #
Generic UnpairStruct
Instance details Defined in Morley.Michelson.Macro Associated Types type Rep UnpairStruct :: Type -> Type # Methods from :: UnpairStruct -> Rep UnpairStruct x # to :: Rep UnpairStruct x -> UnpairStruct #
Generic CustomParserException
Instance details Defined in Morley.Michelson.Parser.Error Associated Types type Rep CustomParserException :: Type -> Type # Methods from :: CustomParserException -> Rep CustomParserException x # to :: Rep CustomParserException x -> CustomParserException #
Generic StringLiteralParserException
Instance details Defined in Morley.Michelson.Parser.Error Associated Types type Rep StringLiteralParserException :: Type -> Type # Methods from :: StringLiteralParserException -> Rep StringLiteralParserException x # to :: Rep StringLiteralParserException x -> StringLiteralParserException #
Generic BigMapCounter
Instance details Defined in Morley.Michelson.Runtime.GState Associated Types type Rep BigMapCounter :: Type -> Type # Methods from :: BigMapCounter -> Rep BigMapCounter x # to :: Rep BigMapCounter x -> BigMapCounter #
Generic MText
Instance details Defined in Morley.Michelson.Text Associated Types type Rep MText :: Type -> Type # Methods from :: MText -> Rep MText x # to :: Rep MText x -> MText #
Generic ExtError
Instance details Defined in Morley.Michelson.TypeCheck.Error Associated Types type Rep ExtError :: Type -> Type # Methods from :: ExtError -> Rep ExtError x # to :: Rep ExtError x -> ExtError #
Generic StackSize
Instance details Defined in Morley.Michelson.TypeCheck.Error Associated Types type Rep StackSize :: Type -> Type # Methods from :: StackSize -> Rep StackSize x # to :: Rep StackSize x -> StackSize #
Generic TcTypeError
Instance details Defined in Morley.Michelson.TypeCheck.Error Associated Types type Rep TcTypeError :: Type -> Type # Methods from :: TcTypeError -> Rep TcTypeError x # to :: Rep TcTypeError x -> TcTypeError #
Generic TopLevelType
Instance details Defined in Morley.Michelson.TypeCheck.Error Associated Types type Rep TopLevelType :: Type -> Type # Methods from :: TopLevelType -> Rep TopLevelType x # to :: Rep TopLevelType x -> TopLevelType #
Generic TypeContext
Instance details Defined in Morley.Michelson.TypeCheck.Error Associated Types type Rep TypeContext :: Type -> Type # Methods from :: TypeContext -> Rep TypeContext x # to :: Rep TypeContext x -> TypeContext #
Generic MutezArithErrorType
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type Rep MutezArithErrorType :: Type -> Type # Methods from :: MutezArithErrorType -> Rep MutezArithErrorType x # to :: Rep MutezArithErrorType x -> MutezArithErrorType #
Generic ShiftArithErrorType
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type Rep ShiftArithErrorType :: Type -> Type # Methods from :: ShiftArithErrorType -> Rep ShiftArithErrorType x # to :: Rep ShiftArithErrorType x -> ShiftArithErrorType #
Generic ArmCoord
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep ArmCoord :: Type -> Type # Methods from :: ArmCoord -> Rep ArmCoord x # to :: Rep ArmCoord x -> ArmCoord #
Generic EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep EpAddress :: Type -> Type # Methods from :: EpAddress -> Rep EpAddress x # to :: Rep EpAddress x -> EpAddress #
Generic ParamEpError
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep ParamEpError :: Type -> Type # Methods from :: ParamEpError -> Rep ParamEpError x # to :: Rep ParamEpError x -> ParamEpError #
Generic ParseEpAddressError
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep ParseEpAddressError :: Type -> Type # Methods from :: ParseEpAddressError -> Rep ParseEpAddressError x # to :: Rep ParseEpAddressError x -> ParseEpAddressError #
Generic DStorageType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type Rep DStorageType :: Type -> Type # Methods from :: DStorageType -> Rep DStorageType x # to :: Rep DStorageType x -> DStorageType #
Generic MyType2
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product Associated Types type Rep MyType2 :: Type -> Type # Methods from :: MyType2 -> Rep MyType2 x # to :: Rep MyType2 x -> MyType2 #
Generic MyCompoundType
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type Rep MyCompoundType :: Type -> Type # Methods from :: MyCompoundType -> Rep MyCompoundType x # to :: Rep MyCompoundType x -> MyCompoundType #
Generic MyEnum
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type Rep MyEnum :: Type -> Type # Methods from :: MyEnum -> Rep MyEnum x # to :: Rep MyEnum x -> MyEnum #
Generic MyType
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type Rep MyType :: Type -> Type # Methods from :: MyType -> Rep MyType x # to :: Rep MyType x -> MyType #
Generic MyType'
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type Rep MyType' :: Type -> Type # Methods from :: MyType' -> Rep MyType' x # to :: Rep MyType' x -> MyType' #
Generic MyTypeWithNamedField
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type Rep MyTypeWithNamedField :: Type -> Type # Methods from :: MyTypeWithNamedField -> Rep MyTypeWithNamedField x # to :: Rep MyTypeWithNamedField x -> MyTypeWithNamedField #
Generic CommentType
Instance details Defined in Morley.Michelson.Typed.Instr Associated Types type Rep CommentType :: Type -> Type # Methods from :: CommentType -> Rep CommentType x # to :: Rep CommentType x -> CommentType #
Generic OperationHash
Instance details Defined in Morley.Michelson.Typed.Operation Associated Types type Rep OperationHash :: Type -> Type # Methods from :: OperationHash -> Rep OperationHash x # to :: Rep OperationHash x -> OperationHash #
Generic BadTypeForScope
Instance details Defined in Morley.Michelson.Typed.Scope Associated Types type Rep BadTypeForScope :: Type -> Type # Methods from :: BadTypeForScope -> Rep BadTypeForScope x # to :: Rep BadTypeForScope x -> BadTypeForScope #
Generic T
Instance details Defined in Morley.Michelson.Typed.T Associated Types type Rep T :: Type -> Type # Methods from :: T -> Rep T x # to :: Rep T x -> T #
Generic SetDelegate
Instance details Defined in Morley.Michelson.Typed.Value Associated Types type Rep SetDelegate :: Type -> Type # Methods from :: SetDelegate -> Rep SetDelegate x # to :: Rep SetDelegate x -> SetDelegate #
Generic AnyAnn
Instance details Defined in Morley.Michelson.Untyped.Annotation Associated Types type Rep AnyAnn :: Type -> Type # Methods from :: AnyAnn -> Rep AnyAnn x # to :: Rep AnyAnn x -> AnyAnn #
Generic VarAnns
Instance details Defined in Morley.Michelson.Untyped.Annotation Associated Types type Rep VarAnns :: Type -> Type # Methods from :: VarAnns -> Rep VarAnns x # to :: Rep VarAnns x -> VarAnns #
Generic Entry
Instance details Defined in Morley.Michelson.Untyped.Contract Associated Types type Rep Entry :: Type -> Type # Methods from :: Entry -> Rep Entry x # to :: Rep Entry x -> Entry #
Generic EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Associated Types type Rep EpName :: Type -> Type # Methods from :: EpName -> Rep EpName x # to :: Rep EpName x -> EpName #
Generic EpNameFromRefAnnError
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Associated Types type Rep EpNameFromRefAnnError :: Type -> Type # Methods from :: EpNameFromRefAnnError -> Rep EpNameFromRefAnnError x # to :: Rep EpNameFromRefAnnError x -> EpNameFromRefAnnError #
Generic PrintComment
Instance details Defined in Morley.Michelson.Untyped.Ext Associated Types type Rep PrintComment :: Type -> Type # Methods from :: PrintComment -> Rep PrintComment x # to :: Rep PrintComment x -> PrintComment #
Generic StackRef
Instance details Defined in Morley.Michelson.Untyped.Ext Associated Types type Rep StackRef :: Type -> Type # Methods from :: StackRef -> Rep StackRef x # to :: Rep StackRef x -> StackRef #
Generic StackTypePattern
Instance details Defined in Morley.Michelson.Untyped.Ext Associated Types type Rep StackTypePattern :: Type -> Type # Methods from :: StackTypePattern -> Rep StackTypePattern x # to :: Rep StackTypePattern x -> StackTypePattern #
Generic TyVar
Instance details Defined in Morley.Michelson.Untyped.Ext Associated Types type Rep TyVar :: Type -> Type # Methods from :: TyVar -> Rep TyVar x # to :: Rep TyVar x -> TyVar #
Generic Var
Instance details Defined in Morley.Michelson.Untyped.Ext Associated Types type Rep Var :: Type -> Type # Methods from :: Var -> Rep Var x # to :: Rep Var x -> Var #
Generic ExpandedOp
Instance details Defined in Morley.Michelson.Untyped.Instr Associated Types type Rep ExpandedOp :: Type -> Type # Methods from :: ExpandedOp -> Rep ExpandedOp x # to :: Rep ExpandedOp x -> ExpandedOp #
Generic ParameterType
Instance details Defined in Morley.Michelson.Untyped.Type Associated Types type Rep ParameterType :: Type -> Type # Methods from :: ParameterType -> Rep ParameterType x # to :: Rep ParameterType x -> ParameterType #
Generic T
Instance details Defined in Morley.Michelson.Untyped.Type Associated Types type Rep T :: Type -> Type # Methods from :: T -> Rep T x # to :: Rep T x -> T #
Generic Ty
Instance details Defined in Morley.Michelson.Untyped.Type Associated Types type Rep Ty :: Type -> Type # Methods from :: Ty -> Rep Ty x # to :: Rep Ty x -> Ty #
Generic InternalByteString
Instance details Defined in Morley.Michelson.Untyped.Value Associated Types type Rep InternalByteString :: Type -> Type # Methods from :: InternalByteString -> Rep InternalByteString x # to :: Rep InternalByteString x -> InternalByteString #
Generic GlobalCounter
Instance details Defined in Morley.Tezos.Address Associated Types type Rep GlobalCounter :: Type -> Type # Methods from :: GlobalCounter -> Rep GlobalCounter x # to :: Rep GlobalCounter x -> GlobalCounter #
Generic ParseAddressError
Instance details Defined in Morley.Tezos.Address Associated Types type Rep ParseAddressError :: Type -> Type # Methods from :: ParseAddressError -> Rep ParseAddressError x # to :: Rep ParseAddressError x -> ParseAddressError #
Generic ParseAddressRawError
Instance details Defined in Morley.Tezos.Address Associated Types type Rep ParseAddressRawError :: Type -> Type # Methods from :: ParseAddressRawError -> Rep ParseAddressRawError x # to :: Rep ParseAddressRawError x -> ParseAddressRawError #
Generic AddressKind
Instance details Defined in Morley.Tezos.Address.Kinds Associated Types type Rep AddressKind :: Type -> Type # Methods from :: AddressKind -> Rep AddressKind x # to :: Rep AddressKind x -> AddressKind #
Generic ChainId
Instance details Defined in Morley.Tezos.Core Associated Types type Rep ChainId :: Type -> Type # Methods from :: ChainId -> Rep ChainId x # to :: Rep ChainId x -> ChainId #
Generic Mutez
Instance details Defined in Morley.Tezos.Core Associated Types type Rep Mutez :: Type -> Type # Methods from :: Mutez -> Rep Mutez x # to :: Rep Mutez x -> Mutez #
Generic Timestamp
Instance details Defined in Morley.Tezos.Core Associated Types type Rep Timestamp :: Type -> Type # Methods from :: Timestamp -> Rep Timestamp x # to :: Rep Timestamp x -> Timestamp #
Generic KeyType
Instance details Defined in Morley.Tezos.Crypto Associated Types type Rep KeyType :: Type -> Type # Methods from :: KeyType -> Rep KeyType x # to :: Rep KeyType x -> KeyType #
Generic ParseSignatureRawError
Instance details Defined in Morley.Tezos.Crypto Associated Types type Rep ParseSignatureRawError :: Type -> Type # Methods from :: ParseSignatureRawError -> Rep ParseSignatureRawError x # to :: Rep ParseSignatureRawError x -> ParseSignatureRawError #
Generic PublicKey
Instance details Defined in Morley.Tezos.Crypto Associated Types type Rep PublicKey :: Type -> Type # Methods from :: PublicKey -> Rep PublicKey x # to :: Rep PublicKey x -> PublicKey #
Generic SecretKey
Instance details Defined in Morley.Tezos.Crypto Associated Types type Rep SecretKey :: Type -> Type # Methods from :: SecretKey -> Rep SecretKey x # to :: Rep SecretKey x -> SecretKey #
Generic Signature
Instance details Defined in Morley.Tezos.Crypto Associated Types type Rep Signature :: Type -> Type # Methods from :: Signature -> Rep Signature x # to :: Rep Signature x -> Signature #
Generic PublicKey
Instance details Defined in Morley.Tezos.Crypto.BLS Associated Types type Rep PublicKey :: Type -> Type # Methods from :: PublicKey -> Rep PublicKey x # to :: Rep PublicKey x -> PublicKey #
Generic SecretKey
Instance details Defined in Morley.Tezos.Crypto.BLS Associated Types type Rep SecretKey :: Type -> Type # Methods from :: SecretKey -> Rep SecretKey x # to :: Rep SecretKey x -> SecretKey #
Generic Signature
Instance details Defined in Morley.Tezos.Crypto.BLS Associated Types type Rep Signature :: Type -> Type # Methods from :: Signature -> Rep Signature x # to :: Rep Signature x -> Signature #
Generic DeserializationError
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Associated Types type Rep DeserializationError :: Type -> Type # Methods from :: DeserializationError -> Rep DeserializationError x # to :: Rep DeserializationError x -> DeserializationError #
Generic PublicKey
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Associated Types type Rep PublicKey :: Type -> Type # Methods from :: PublicKey -> Rep PublicKey x # to :: Rep PublicKey x -> PublicKey #
Generic SecretKey
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Associated Types type Rep SecretKey :: Type -> Type # Methods from :: SecretKey -> Rep SecretKey x # to :: Rep SecretKey x -> SecretKey #
Generic Signature
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Associated Types type Rep Signature :: Type -> Type # Methods from :: Signature -> Rep Signature x # to :: Rep Signature x -> Signature #
Generic PublicKey
Instance details Defined in Morley.Tezos.Crypto.P256 Associated Types type Rep PublicKey :: Type -> Type # Methods from :: PublicKey -> Rep PublicKey x # to :: Rep PublicKey x -> PublicKey #
Generic SecretKey
Instance details Defined in Morley.Tezos.Crypto.P256 Associated Types type Rep SecretKey :: Type -> Type # Methods from :: SecretKey -> Rep SecretKey x # to :: Rep SecretKey x -> SecretKey #
Generic Signature
Instance details Defined in Morley.Tezos.Crypto.P256 Associated Types type Rep Signature :: Type -> Type # Methods from :: Signature -> Rep Signature x # to :: Rep Signature x -> Signature #
Generic PublicKey
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Associated Types type Rep PublicKey :: Type -> Type # Methods from :: PublicKey -> Rep PublicKey x # to :: Rep PublicKey x -> PublicKey #
Generic SecretKey
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Associated Types type Rep SecretKey :: Type -> Type # Methods from :: SecretKey -> Rep SecretKey x # to :: Rep SecretKey x -> SecretKey #
Generic Signature
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Associated Types type Rep Signature :: Type -> Type # Methods from :: Signature -> Rep Signature x # to :: Rep Signature x -> Signature #
Generic Chest
Instance details Defined in Morley.Tezos.Crypto.Timelock Associated Types type Rep Chest :: Type -> Type # Methods from :: Chest -> Rep Chest x # to :: Rep Chest x -> Chest #
Generic ChestKey
Instance details Defined in Morley.Tezos.Crypto.Timelock Associated Types type Rep ChestKey :: Type -> Type # Methods from :: ChestKey -> Rep ChestKey x # to :: Rep ChestKey x -> ChestKey #
Generic Ciphertext
Instance details Defined in Morley.Tezos.Crypto.Timelock Associated Types type Rep Ciphertext :: Type -> Type # Methods from :: Ciphertext -> Rep Ciphertext x # to :: Rep Ciphertext x -> Ciphertext #
Generic HexJSONByteString
Instance details Defined in Morley.Util.ByteString Associated Types type Rep HexJSONByteString :: Type -> Type # Methods from :: HexJSONByteString -> Rep HexJSONByteString x # to :: Rep HexJSONByteString x -> HexJSONByteString #
Generic Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Mode :: Type -> Type # Methods from :: Mode -> Rep Mode x # to :: Rep Mode x -> Mode #
Generic Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Style :: Type -> Type # Methods from :: Style -> Rep Style x # to :: Rep Style x -> Style #
Generic TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep TextDetails :: Type -> Type # Methods from :: TextDetails -> Rep TextDetails x # to :: Rep TextDetails x -> TextDetails #
Generic Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Associated Types type Rep Doc :: Type -> Type # Methods from :: Doc -> Rep Doc x # to :: Rep Doc x -> Doc #
Generic Mod2
Instance details Defined in Data.Semiring Associated Types type Rep Mod2 :: Type -> Type # Methods from :: Mod2 -> Rep Mod2 x # to :: Rep Mod2 x -> Mod2 #
Generic Outcome
Instance details Defined in Test.Tasty.Core Associated Types type Rep Outcome :: Type -> Type # Methods from :: Outcome -> Rep Outcome x # to :: Rep Outcome x -> Outcome #
Generic Expr
Instance details Defined in Test.Tasty.Patterns.Types Associated Types type Rep Expr :: Type -> Type # Methods from :: Expr -> Rep Expr x # to :: Rep Expr x -> Expr #
Generic AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnLookup :: Type -> Type # Methods from :: AnnLookup -> Rep AnnLookup x # to :: Rep AnnLookup x -> AnnLookup #
Generic AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnTarget :: Type -> Type # Methods from :: AnnTarget -> Rep AnnTarget x # to :: Rep AnnTarget x -> AnnTarget #
Generic Bang
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bang :: Type -> Type # Methods from :: Bang -> Rep Bang x # to :: Rep Bang x -> Bang #
Generic Body
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Body :: Type -> Type # Methods from :: Body -> Rep Body x # to :: Rep Body x -> Body #
Generic Bytes
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bytes :: Type -> Type # Methods from :: Bytes -> Rep Bytes x # to :: Rep Bytes x -> Bytes #
Generic Callconv
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Callconv :: Type -> Type # Methods from :: Callconv -> Rep Callconv x # to :: Rep Callconv x -> Callconv #
Generic Clause
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Clause :: Type -> Type # Methods from :: Clause -> Rep Clause x # to :: Rep Clause x -> Clause #
Generic Con
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Con :: Type -> Type # Methods from :: Con -> Rep Con x # to :: Rep Con x -> Con #
Generic Dec
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Dec :: Type -> Type # Methods from :: Dec -> Rep Dec x # to :: Rep Dec x -> Dec #
Generic DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivClause :: Type -> Type # Methods from :: DerivClause -> Rep DerivClause x # to :: Rep DerivClause x -> DerivClause #
Generic DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivStrategy :: Type -> Type # Methods from :: DerivStrategy -> Rep DerivStrategy x # to :: Rep DerivStrategy x -> DerivStrategy #
Generic Exp
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Exp :: Type -> Type # Methods from :: Exp -> Rep Exp x # to :: Rep Exp x -> Exp #
Generic FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FamilyResultSig :: Type -> Type # Methods from :: FamilyResultSig -> Rep FamilyResultSig x # to :: Rep FamilyResultSig x -> FamilyResultSig #
Generic Fixity
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FixityDirection :: Type -> Type # Methods from :: FixityDirection -> Rep FixityDirection x # to :: Rep FixityDirection x -> FixityDirection #
Generic Foreign
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Foreign :: Type -> Type # Methods from :: Foreign -> Rep Foreign x # to :: Rep Foreign x -> Foreign #
Generic FunDep
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FunDep :: Type -> Type # Methods from :: FunDep -> Rep FunDep x # to :: Rep FunDep x -> FunDep #
Generic Guard
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Guard :: Type -> Type # Methods from :: Guard -> Rep Guard x # to :: Rep Guard x -> Guard #
Generic Info
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Info :: Type -> Type # Methods from :: Info -> Rep Info x # to :: Rep Info x -> Info #
Generic InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep InjectivityAnn :: Type -> Type # Methods from :: InjectivityAnn -> Rep InjectivityAnn x # to :: Rep InjectivityAnn x -> InjectivityAnn #
Generic Inline
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Inline :: Type -> Type # Methods from :: Inline -> Rep Inline x # to :: Rep Inline x -> Inline #
Generic Lit
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Lit :: Type -> Type # Methods from :: Lit -> Rep Lit x # to :: Rep Lit x -> Lit #
Generic Loc
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Loc :: Type -> Type # Methods from :: Loc -> Rep Loc x # to :: Rep Loc x -> Loc #
Generic Match
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Match :: Type -> Type # Methods from :: Match -> Rep Match x # to :: Rep Match x -> Match #
Generic ModName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModName :: Type -> Type # Methods from :: ModName -> Rep ModName x # to :: Rep ModName x -> ModName #
Generic Module
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Module :: Type -> Type # Methods from :: Module -> Rep Module x # to :: Rep Module x -> Module #
Generic ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModuleInfo :: Type -> Type # Methods from :: ModuleInfo -> Rep ModuleInfo x # to :: Rep ModuleInfo x -> ModuleInfo #
Generic Name
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Name :: Type -> Type # Methods from :: Name -> Rep Name x # to :: Rep Name x -> Name #
Generic NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameFlavour :: Type -> Type # Methods from :: NameFlavour -> Rep NameFlavour x # to :: Rep NameFlavour x -> NameFlavour #
Generic NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameSpace :: Type -> Type # Methods from :: NameSpace -> Rep NameSpace x # to :: Rep NameSpace x -> NameSpace #
Generic OccName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep OccName :: Type -> Type # Methods from :: OccName -> Rep OccName x # to :: Rep OccName x -> OccName #
Generic Overlap
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Overlap :: Type -> Type # Methods from :: Overlap -> Rep Overlap x # to :: Rep Overlap x -> Overlap #
Generic Pat
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pat :: Type -> Type # Methods from :: Pat -> Rep Pat x # to :: Rep Pat x -> Pat #
Generic PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynArgs :: Type -> Type # Methods from :: PatSynArgs -> Rep PatSynArgs x # to :: Rep PatSynArgs x -> PatSynArgs #
Generic PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynDir :: Type -> Type # Methods from :: PatSynDir -> Rep PatSynDir x # to :: Rep PatSynDir x -> PatSynDir #
Generic Phases
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Phases :: Type -> Type # Methods from :: Phases -> Rep Phases x # to :: Rep Phases x -> Phases #
Generic PkgName
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PkgName :: Type -> Type # Methods from :: PkgName -> Rep PkgName x # to :: Rep PkgName x -> PkgName #
Generic Pragma
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pragma :: Type -> Type # Methods from :: Pragma -> Rep Pragma x # to :: Rep Pragma x -> Pragma #
Generic Range
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Range :: Type -> Type # Methods from :: Range -> Rep Range x # to :: Rep Range x -> Range #
Generic Role
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Role :: Type -> Type # Methods from :: Role -> Rep Role x # to :: Rep Role x -> Role #
Generic RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleBndr :: Type -> Type # Methods from :: RuleBndr -> Rep RuleBndr x # to :: Rep RuleBndr x -> RuleBndr #
Generic RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleMatch :: Type -> Type # Methods from :: RuleMatch -> Rep RuleMatch x # to :: Rep RuleMatch x -> RuleMatch #
Generic Safety
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Safety :: Type -> Type # Methods from :: Safety -> Rep Safety x # to :: Rep Safety x -> Safety #
Generic SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic Specificity
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Specificity :: Type -> Type # Methods from :: Specificity -> Rep Specificity x # to :: Rep Specificity x -> Specificity #
Generic Stmt
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Stmt :: Type -> Type # Methods from :: Stmt -> Rep Stmt x # to :: Rep Stmt x -> Stmt #
Generic TyLit
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyLit :: Type -> Type # Methods from :: TyLit -> Rep TyLit x # to :: Rep TyLit x -> TyLit #
Generic TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TySynEqn :: Type -> Type # Methods from :: TySynEqn -> Rep TySynEqn x # to :: Rep TySynEqn x -> TySynEqn #
Generic Type
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Type :: Type -> Type # Methods from :: Type -> Rep Type x # to :: Rep Type x -> Type #
Generic TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TypeFamilyHead :: Type -> Type # Methods from :: TypeFamilyHead -> Rep TypeFamilyHead x # to :: Rep TypeFamilyHead x -> TypeFamilyHead #
Generic ConstructorInfo
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep ConstructorInfo :: Type -> Type # Methods from :: ConstructorInfo -> Rep ConstructorInfo x # to :: Rep ConstructorInfo x -> ConstructorInfo #
Generic ConstructorVariant
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep ConstructorVariant :: Type -> Type # Methods from :: ConstructorVariant -> Rep ConstructorVariant x # to :: Rep ConstructorVariant x -> ConstructorVariant #
Generic DatatypeInfo
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep DatatypeInfo :: Type -> Type # Methods from :: DatatypeInfo -> Rep DatatypeInfo x # to :: Rep DatatypeInfo x -> DatatypeInfo #
Generic DatatypeVariant
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep DatatypeVariant :: Type -> Type # Methods from :: DatatypeVariant -> Rep DatatypeVariant x # to :: Rep DatatypeVariant x -> DatatypeVariant #
Generic FieldStrictness
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep FieldStrictness :: Type -> Type # Methods from :: FieldStrictness -> Rep FieldStrictness x # to :: Rep FieldStrictness x -> FieldStrictness #
Generic Strictness
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep Strictness :: Type -> Type # Methods from :: Strictness -> Rep Strictness x # to :: Rep Strictness x -> Strictness #
Generic Unpackedness
Instance details Defined in Language.Haskell.TH.Datatype Associated Types type Rep Unpackedness :: Type -> Type # Methods from :: Unpackedness -> Rep Unpackedness x # to :: Rep Unpackedness x -> Unpackedness #
Generic DClause
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DClause :: Type -> Type # Methods from :: DClause -> Rep DClause x # to :: Rep DClause x -> DClause #
Generic DCon
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DCon :: Type -> Type # Methods from :: DCon -> Rep DCon x # to :: Rep DCon x -> DCon #
Generic DConFields
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DConFields :: Type -> Type # Methods from :: DConFields -> Rep DConFields x # to :: Rep DConFields x -> DConFields #
Generic DDec
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DDec :: Type -> Type # Methods from :: DDec -> Rep DDec x # to :: Rep DDec x -> DDec #
Generic DDerivClause
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DDerivClause :: Type -> Type # Methods from :: DDerivClause -> Rep DDerivClause x # to :: Rep DDerivClause x -> DDerivClause #
Generic DDerivStrategy
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DDerivStrategy :: Type -> Type # Methods from :: DDerivStrategy -> Rep DDerivStrategy x # to :: Rep DDerivStrategy x -> DDerivStrategy #
Generic DExp
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DExp :: Type -> Type # Methods from :: DExp -> Rep DExp x # to :: Rep DExp x -> DExp #
Generic DFamilyResultSig
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DFamilyResultSig :: Type -> Type # Methods from :: DFamilyResultSig -> Rep DFamilyResultSig x # to :: Rep DFamilyResultSig x -> DFamilyResultSig #
Generic DForallTelescope
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DForallTelescope :: Type -> Type # Methods from :: DForallTelescope -> Rep DForallTelescope x # to :: Rep DForallTelescope x -> DForallTelescope #
Generic DForeign
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DForeign :: Type -> Type # Methods from :: DForeign -> Rep DForeign x # to :: Rep DForeign x -> DForeign #
Generic DInfo
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DInfo :: Type -> Type # Methods from :: DInfo -> Rep DInfo x # to :: Rep DInfo x -> DInfo #
Generic DLetDec
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DLetDec :: Type -> Type # Methods from :: DLetDec -> Rep DLetDec x # to :: Rep DLetDec x -> DLetDec #
Generic DMatch
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DMatch :: Type -> Type # Methods from :: DMatch -> Rep DMatch x # to :: Rep DMatch x -> DMatch #
Generic DPat
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DPat :: Type -> Type # Methods from :: DPat -> Rep DPat x # to :: Rep DPat x -> DPat #
Generic DPatSynDir
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DPatSynDir :: Type -> Type # Methods from :: DPatSynDir -> Rep DPatSynDir x # to :: Rep DPatSynDir x -> DPatSynDir #
Generic DPragma
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DPragma :: Type -> Type # Methods from :: DPragma -> Rep DPragma x # to :: Rep DPragma x -> DPragma #
Generic DRuleBndr
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DRuleBndr :: Type -> Type # Methods from :: DRuleBndr -> Rep DRuleBndr x # to :: Rep DRuleBndr x -> DRuleBndr #
Generic DTySynEqn
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DTySynEqn :: Type -> Type # Methods from :: DTySynEqn -> Rep DTySynEqn x # to :: Rep DTySynEqn x -> DTySynEqn #
Generic DType
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DType :: Type -> Type # Methods from :: DType -> Rep DType x # to :: Rep DType x -> DType #
Generic DTypeFamilyHead
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep DTypeFamilyHead :: Type -> Type # Methods from :: DTypeFamilyHead -> Rep DTypeFamilyHead x # to :: Rep DTypeFamilyHead x -> DTypeFamilyHead #
Generic NewOrData
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep NewOrData :: Type -> Type # Methods from :: NewOrData -> Rep NewOrData x # to :: Rep NewOrData x -> NewOrData #
Generic DFunArgs
Instance details Defined in Language.Haskell.TH.Desugar.Core Associated Types type Rep DFunArgs :: Type -> Type # Methods from :: DFunArgs -> Rep DFunArgs x # to :: Rep DFunArgs x -> DFunArgs #
Generic DTypeArg
Instance details Defined in Language.Haskell.TH.Desugar.Core Associated Types type Rep DTypeArg :: Type -> Type # Methods from :: DTypeArg -> Rep DTypeArg x # to :: Rep DTypeArg x -> DTypeArg #
Generic DVisFunArg
Instance details Defined in Language.Haskell.TH.Desugar.Core Associated Types type Rep DVisFunArg :: Type -> Type # Methods from :: DVisFunArg -> Rep DVisFunArg x # to :: Rep DVisFunArg x -> DVisFunArg #
Generic Undefined
Instance details Defined in Universum.Debug Associated Types type Rep Undefined :: Type -> Type # Methods from :: Undefined -> Rep Undefined x # to :: Rep Undefined x -> Undefined #
Generic ()
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type # Methods from :: () -> Rep () x # to :: Rep () x -> () #
Generic Bool
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
Generic (Last' a)
Instance details Defined in Distribution.Compat.Semigroup Associated Types type Rep (Last' a) :: Type -> Type # Methods from :: Last' a -> Rep (Last' a) x # to :: Rep (Last' a) x -> Last' a #
Generic (Option' a)
Instance details Defined in Distribution.Compat.Semigroup Associated Types type Rep (Option' a) :: Type -> Type # Methods from :: Option' a -> Rep (Option' a) x # to :: Rep (Option' a) x -> Option' a #
Generic (ZipList a)
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type # Methods from :: ZipList a -> Rep (ZipList a) x # to :: Rep (ZipList a) x -> ZipList a #
Generic (Complex a)
Instance details Defined in Data.Complex Associated Types type Rep (Complex a) :: Type -> Type # Methods from :: Complex a -> Rep (Complex a) x # to :: Rep (Complex a) x -> Complex a #
Generic (Identity a)
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Generic (First a)
Instance details Defined in Data.Monoid Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a)
Instance details Defined in Data.Monoid Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (Down a)
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type # Methods from :: Down a -> Rep (Down a) x # to :: Rep (Down a) x -> Down a #
Generic (First a)
Instance details Defined in Data.Semigroup Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (Max a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Max a) :: Type -> Type # Methods from :: Max a -> Rep (Max a) x # to :: Rep (Max a) x -> Max a #
Generic (Min a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Min a) :: Type -> Type # Methods from :: Min a -> Rep (Min a) x # to :: Rep (Min a) x -> Min a #
Generic (Option a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Option a) :: Type -> Type # Methods from :: Option a -> Rep (Option a) x # to :: Rep (Option a) x -> Option a #
Generic (WrappedMonoid m)
Instance details Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m #
Generic (Dual a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Dual a) :: Type -> Type # Methods from :: Dual a -> Rep (Dual a) x # to :: Rep (Dual a) x -> Dual a #
Generic (Endo a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Endo a) :: Type -> Type # Methods from :: Endo a -> Rep (Endo a) x # to :: Rep (Endo a) x -> Endo a #
Generic (Product a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Product a) :: Type -> Type # Methods from :: Product a -> Rep (Product a) x # to :: Rep (Product a) x -> Product a #
Generic (Sum a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Sum a) :: Type -> Type # Methods from :: Sum a -> Rep (Sum a) x # to :: Rep (Sum a) x -> Sum a #
Generic (NonEmpty a)
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type # Methods from :: NonEmpty a -> Rep (NonEmpty a) x # to :: Rep (NonEmpty a) x -> NonEmpty a #
Generic (Par1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (Par1 p) :: Type -> Type # Methods from :: Par1 p -> Rep (Par1 p) x # to :: Rep (Par1 p) x -> Par1 p #
Generic (SCC vertex)
Instance details Defined in Data.Graph Associated Types type Rep (SCC vertex) :: Type -> Type # Methods from :: SCC vertex -> Rep (SCC vertex) x # to :: Rep (SCC vertex) x -> SCC vertex #
Generic (Digit a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Digit a) :: Type -> Type # Methods from :: Digit a -> Rep (Digit a) x # to :: Rep (Digit a) x -> Digit a #
Generic (Elem a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Elem a) :: Type -> Type # Methods from :: Elem a -> Rep (Elem a) x # to :: Rep (Elem a) x -> Elem a #
Generic (FingerTree a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (FingerTree a) :: Type -> Type # Methods from :: FingerTree a -> Rep (FingerTree a) x # to :: Rep (FingerTree a) x -> FingerTree a #
Generic (Node a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Node a) :: Type -> Type # Methods from :: Node a -> Rep (Node a) x # to :: Rep (Node a) x -> Node a #
Generic (ViewL a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewL a) :: Type -> Type # Methods from :: ViewL a -> Rep (ViewL a) x # to :: Rep (ViewL a) x -> ViewL a #
Generic (ViewR a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewR a) :: Type -> Type # Methods from :: ViewR a -> Rep (ViewR a) x # to :: Rep (ViewR a) x -> ViewR a #
Generic (Tree a)
Instance details Defined in Data.Tree Associated Types type Rep (Tree a) :: Type -> Type # Methods from :: Tree a -> Rep (Tree a) x # to :: Rep (Tree a) x -> Tree a #
Generic (Fix f)
Instance details Defined in Data.Fix Associated Types type Rep (Fix f) :: Type -> Type # Methods from :: Fix f -> Rep (Fix f) x # to :: Rep (Fix f) x -> Fix f #
Generic (Binary p)
Instance details Defined in Data.Field.Galois.Binary Associated Types type Rep (Binary p) :: Type -> Type # Methods from :: Binary p -> Rep (Binary p) x # to :: Rep (Binary p) x -> Binary p #
Generic (Prime p)
Instance details Defined in Data.Field.Galois.Prime Associated Types type Rep (Prime p) :: Type -> Type # Methods from :: Prime p -> Rep (Prime p) x # to :: Rep (Prime p) x -> Prime p #
Generic (ChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type Rep (ChestT a) :: Type -> Type # Methods from :: ChestT a -> Rep (ChestT a) x # to :: Rep (ChestT a) x -> ChestT a #
Generic (OpenChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type Rep (OpenChestT a) :: Type -> Type # Methods from :: OpenChestT a -> Rep (OpenChestT a) x # to :: Rep (OpenChestT a) x -> OpenChestT a #
Generic (Packed a)
Instance details Defined in Lorentz.Bytes Associated Types type Rep (Packed a) :: Type -> Type # Methods from :: Packed a -> Rep (Packed a) x # to :: Rep (Packed a) x -> Packed a #
Generic (TSignature a)
Instance details Defined in Lorentz.Bytes Associated Types type Rep (TSignature a) :: Type -> Type # Methods from :: TSignature a -> Rep (TSignature a) x # to :: Rep (TSignature a) x -> TSignature a #
Generic (ShouldHaveEntrypoints a)
Instance details Defined in Lorentz.Entrypoints.Helpers Associated Types type Rep (ShouldHaveEntrypoints a) :: Type -> Type # Methods from :: ShouldHaveEntrypoints a -> Rep (ShouldHaveEntrypoints a) x # to :: Rep (ShouldHaveEntrypoints a) x -> ShouldHaveEntrypoints a #
Generic (VoidResult r)
Instance details Defined in Lorentz.Macro Associated Types type Rep (VoidResult r) :: Type -> Type # Methods from :: VoidResult r -> Rep (VoidResult r) x # to :: Rep (VoidResult r) x -> VoidResult r #
Generic (UParam entries)
Instance details Defined in Lorentz.UParam Associated Types type Rep (UParam entries) :: Type -> Type # Methods from :: UParam entries -> Rep (UParam entries) x # to :: Rep (UParam entries) x -> UParam entries #
Generic (ReadTicket a)
Instance details Defined in Lorentz.Value Associated Types type Rep (ReadTicket a) :: Type -> Type # Methods from :: ReadTicket a -> Rep (ReadTicket a) x # to :: Rep (ReadTicket a) x -> ReadTicket a #
Generic (ErrorFancy e)
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ErrorFancy e) :: Type -> Type # Methods from :: ErrorFancy e -> Rep (ErrorFancy e) x # to :: Rep (ErrorFancy e) x -> ErrorFancy e #
Generic (ErrorItem t)
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ErrorItem t) :: Type -> Type # Methods from :: ErrorItem t -> Rep (ErrorItem t) x # to :: Rep (ErrorItem t) x -> ErrorItem t #
Generic (PosState s)
Instance details Defined in Text.Megaparsec.State Associated Types type Rep (PosState s) :: Type -> Type # Methods from :: PosState s -> Rep (PosState s) x # to :: Rep (PosState s) x -> PosState s #
Generic (Mod m)
Instance details Defined in Data.Mod Associated Types type Rep (Mod m) :: Type -> Type # Methods from :: Mod m -> Rep (Mod m) x # to :: Rep (Mod m) x -> Mod m #
Generic (StringEncode a)
Instance details Defined in Morley.Micheline.Json Associated Types type Rep (StringEncode a) :: Type -> Type # Methods from :: StringEncode a -> Rep (StringEncode a) x # to :: Rep (StringEncode a) x -> StringEncode a #
Generic (InterpretError ext)
Instance details Defined in Morley.Michelson.Interpret Associated Types type Rep (InterpretError ext) :: Type -> Type # Methods from :: InterpretError ext -> Rep (InterpretError ext) x # to :: Rep (InterpretError ext) x -> InterpretError ext #
Generic (MichelsonFailureWithStack ext)
Instance details Defined in Morley.Michelson.Interpret Associated Types type Rep (MichelsonFailureWithStack ext) :: Type -> Type # Methods from :: MichelsonFailureWithStack ext -> Rep (MichelsonFailureWithStack ext) x # to :: Rep (MichelsonFailureWithStack ext) x -> MichelsonFailureWithStack ext #
Generic (ResultStateLogs res)
Instance details Defined in Morley.Michelson.Interpret Associated Types type Rep (ResultStateLogs res) :: Type -> Type # Methods from :: ResultStateLogs res -> Rep (ResultStateLogs res) x # to :: Rep (ResultStateLogs res) x -> ResultStateLogs res #
Generic (TcError' op)
Instance details Defined in Morley.Michelson.TypeCheck.Error Associated Types type Rep (TcError' op) :: Type -> Type # Methods from :: TcError' op -> Rep (TcError' op) x # to :: Rep (TcError' op) x -> TcError' op #
Generic (IllTypedInstr op)
Instance details Defined in Morley.Michelson.TypeCheck.TypeCheckedOp Associated Types type Rep (IllTypedInstr op) :: Type -> Type # Methods from :: IllTypedInstr op -> Rep (IllTypedInstr op) x # to :: Rep (IllTypedInstr op) x -> IllTypedInstr op #
Generic (ParamNotes t)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep (ParamNotes t) :: Type -> Type # Methods from :: ParamNotes t -> Rep (ParamNotes t) x # to :: Rep (ParamNotes t) x -> ParamNotes t #
Generic (ExtInstr s)
Instance details Defined in Morley.Michelson.Typed.Instr Associated Types type Rep (ExtInstr s) :: Type -> Type # Methods from :: ExtInstr s -> Rep (ExtInstr s) x # to :: Rep (ExtInstr s) x -> ExtInstr s #
Generic (PrintComment st)
Instance details Defined in Morley.Michelson.Typed.Instr Associated Types type Rep (PrintComment st) :: Type -> Type # Methods from :: PrintComment st -> Rep (PrintComment st) x # to :: Rep (PrintComment st) x -> PrintComment st #
Generic (Contract' op)
Instance details Defined in Morley.Michelson.Untyped.Contract Associated Types type Rep (Contract' op) :: Type -> Type # Methods from :: Contract' op -> Rep (Contract' op) x # to :: Rep (Contract' op) x -> Contract' op #
Generic (ExtInstrAbstract op)
Instance details Defined in Morley.Michelson.Untyped.Ext Associated Types type Rep (ExtInstrAbstract op) :: Type -> Type # Methods from :: ExtInstrAbstract op -> Rep (ExtInstrAbstract op) x # to :: Rep (ExtInstrAbstract op) x -> ExtInstrAbstract op #
Generic (TestAssert op)
Instance details Defined in Morley.Michelson.Untyped.Ext Associated Types type Rep (TestAssert op) :: Type -> Type # Methods from :: TestAssert op -> Rep (TestAssert op) x # to :: Rep (TestAssert op) x -> TestAssert op #
Generic (InstrAbstract op)
Instance details Defined in Morley.Michelson.Untyped.Instr Associated Types type Rep (InstrAbstract op) :: Type -> Type # Methods from :: InstrAbstract op -> Rep (InstrAbstract op) x # to :: Rep (InstrAbstract op) x -> InstrAbstract op #
Generic (Elt op)
Instance details Defined in Morley.Michelson.Untyped.Value Associated Types type Rep (Elt op) :: Type -> Type # Methods from :: Elt op -> Rep (Elt op) x # to :: Rep (Elt op) x -> Elt op #
Generic (Value' op)
Instance details Defined in Morley.Michelson.Untyped.Value Associated Types type Rep (Value' op) :: Type -> Type # Methods from :: Value' op -> Rep (Value' op) x # to :: Rep (Value' op) x -> Value' op #
Generic (View' op)
Instance details Defined in Morley.Michelson.Untyped.View Associated Types type Rep (View' op) :: Type -> Type # Methods from :: View' op -> Rep (View' op) x # to :: Rep (View' op) x -> View' op #
Generic (Hash kind)
Instance details Defined in Morley.Tezos.Crypto Associated Types type Rep (Hash kind) :: Type -> Type # Methods from :: Hash kind -> Rep (Hash kind) x # to :: Rep (Hash kind) x -> Hash kind #
Generic (MismatchError a)
Instance details Defined in Morley.Util.MismatchError Associated Types type Rep (MismatchError a) :: Type -> Type # Methods from :: MismatchError a -> Rep (MismatchError a) x # to :: Rep (MismatchError a) x -> MismatchError a #
Generic (All a)
Instance details Defined in Morley.Prelude.Boolean Associated Types type Rep (All a) :: Type -> Type # Methods from :: All a -> Rep (All a) x # to :: Rep (All a) x -> All a #
Generic (Any a)
Instance details Defined in Morley.Prelude.Boolean Associated Types type Rep (Any a) :: Type -> Type # Methods from :: Any a -> Rep (Any a) x # to :: Rep (Any a) x -> Any a #
Generic (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep (Doc a) :: Type -> Type # Methods from :: Doc a -> Rep (Doc a) x # to :: Rep (Doc a) x -> Doc a #
Generic (Add a)
Instance details Defined in Data.Semiring Associated Types type Rep (Add a) :: Type -> Type # Methods from :: Add a -> Rep (Add a) x # to :: Rep (Add a) x -> Add a #
Generic (IntSetOf a)
Instance details Defined in Data.Semiring Associated Types type Rep (IntSetOf a) :: Type -> Type # Methods from :: IntSetOf a -> Rep (IntSetOf a) x # to :: Rep (IntSetOf a) x -> IntSetOf a #
Generic (Mul a)
Instance details Defined in Data.Semiring Associated Types type Rep (Mul a) :: Type -> Type # Methods from :: Mul a -> Rep (Mul a) x # to :: Rep (Mul a) x -> Mul a #
Generic (WrappedNum a)
Instance details Defined in Data.Semiring Associated Types type Rep (WrappedNum a) :: Type -> Type # Methods from :: WrappedNum a -> Rep (WrappedNum a) x # to :: Rep (WrappedNum a) x -> WrappedNum a #
Generic (Maybe a)
Instance details Defined in Data.Strict.Maybe Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Generic (TyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep (TyVarBndr flag) :: Type -> Type # Methods from :: TyVarBndr flag -> Rep (TyVarBndr flag) x # to :: Rep (TyVarBndr flag) x -> TyVarBndr flag #
Generic (DTyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Desugar.AST Associated Types type Rep (DTyVarBndr flag) :: Type -> Type # Methods from :: DTyVarBndr flag -> Rep (DTyVarBndr flag) x # to :: Rep (DTyVarBndr flag) x -> DTyVarBndr flag #
KnownSymbol s => Generic (ElField '(s, a))
Instance details Defined in Data.Vinyl.Functor Associated Types type Rep (ElField '(s, a)) :: Type -> Type # Methods from :: ElField '(s, a) -> Rep (ElField '(s, a)) x # to :: Rep (ElField '(s, a)) x -> ElField '(s, a) #
Generic (Identity a)
Instance details Defined in Data.Vinyl.Functor Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Generic (Maybe a)
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Generic (a)
Instance details Defined in GHC.Generics Associated Types type Rep (a) :: Type -> Type # Methods from :: (a) -> Rep (a) x # to :: Rep (a) x -> (a) #
Generic [a]
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type # Methods from :: [a] -> Rep [a] x # to :: Rep [a] x -> [a] #
Generic (WrappedMonad m a)
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type # Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a #
Generic (Either a b)
Instance details Defined in GHC.Generics Associated Types type Rep (Either a b) :: Type -> Type # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
Generic (Proxy t)
Instance details 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 #
Generic (Arg a b)
Instance details Defined in Data.Semigroup Associated Types type Rep (Arg a b) :: Type -> Type # Methods from :: Arg a b -> Rep (Arg a b) x # to :: Rep (Arg a b) x -> Arg a b #
Generic (U1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (U1 p) :: Type -> Type # Methods from :: U1 p -> Rep (U1 p) x # to :: Rep (U1 p) x -> U1 p #
Generic (V1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (V1 p) :: Type -> Type # Methods from :: V1 p -> Rep (V1 p) x # to :: Rep (V1 p) x -> V1 p #
Generic (ListN n a)
Instance details Defined in Basement.Sized.List Associated Types type Rep (ListN n a) :: Type -> Type # Methods from :: ListN n a -> Rep (ListN n a) x # to :: Rep (ListN n a) x -> ListN n a #
Generic (Bimap a b)
Instance details Defined in Data.Bimap Associated Types type Rep (Bimap a b) :: Type -> Type # Methods from :: Bimap a b -> Rep (Bimap a b) x # to :: Rep (Bimap a b) x -> Bimap a b #
Generic (Cofree f a)
Instance details Defined in Control.Comonad.Cofree Associated Types type Rep (Cofree f a) :: Type -> Type # Methods from :: Cofree f a -> Rep (Cofree f a) x # to :: Rep (Cofree f a) x -> Cofree f a #
Generic (Free f a)
Instance details Defined in Control.Monad.Free Associated Types type Rep (Free f a) :: Type -> Type # Methods from :: Free f a -> Rep (Free f a) x # to :: Rep (Free f a) x -> Free f a #
Generic (Extension p k)
Instance details Defined in Data.Field.Galois.Extension Associated Types type Rep (Extension p k) :: Type -> Type # Methods from :: Extension p k -> Rep (Extension p k) x # to :: Rep (Extension p k) x -> Extension p k #
Generic (RootsOfUnity n k)
Instance details Defined in Data.Field.Galois.Unity Associated Types type Rep (RootsOfUnity n k) :: Type -> Type # Methods from :: RootsOfUnity n k -> Rep (RootsOfUnity n k) x # to :: Rep (RootsOfUnity n k) x -> RootsOfUnity n k #
Generic (Var a) Source #
Instance details Defined in Indigo.Common.Var Associated Types type Rep (Var a) :: Type -> Type # Methods from :: Var a -> Rep (Var a) x # to :: Rep (Var a) x -> Var a #
Generic (TAddress p vd)
Instance details Defined in Lorentz.Address Associated Types type Rep (TAddress p vd) :: Type -> Type # Methods from :: TAddress p vd -> Rep (TAddress p vd) x # to :: Rep (TAddress p vd) x -> TAddress p vd #
Generic (Hash alg a)
Instance details Defined in Lorentz.Bytes Associated Types type Rep (Hash alg a) :: Type -> Type # Methods from :: Hash alg a -> Rep (Hash alg a) x # to :: Rep (Hash alg a) x -> Hash alg a #
Generic (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type Rep (ParameterWrapper deriv cp) :: Type -> Type # Methods from :: ParameterWrapper deriv cp -> Rep (ParameterWrapper deriv cp) x # to :: Rep (ParameterWrapper deriv cp) x -> ParameterWrapper deriv cp #
Generic (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Associated Types type Rep (WrappedLambda i o) :: Type -> Type # Methods from :: WrappedLambda i o -> Rep (WrappedLambda i o) x # to :: Rep (WrappedLambda i o) x -> WrappedLambda i o #
Generic (View_ a r)
Instance details Defined in Lorentz.Macro Associated Types type Rep (View_ a r) :: Type -> Type # Methods from :: View_ a r -> Rep (View_ a r) x # to :: Rep (View_ a r) x -> View_ a r #
Generic (Void_ a b)
Instance details Defined in Lorentz.Macro Associated Types type Rep (Void_ a b) :: Type -> Type # Methods from :: Void_ a b -> Rep (Void_ a b) x # to :: Rep (Void_ a b) x -> Void_ a b #
Generic (ZippedStackRepr a b)
Instance details Defined in Lorentz.Zip Associated Types type Rep (ZippedStackRepr a b) :: Type -> Type # Methods from :: ZippedStackRepr a b -> Rep (ZippedStackRepr a b) x # to :: Rep (ZippedStackRepr a b) x -> ZippedStackRepr a b #
Generic (ParseError s e)
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ParseError s e) :: Type -> Type # Methods from :: ParseError s e -> Rep (ParseError s e) x # to :: Rep (ParseError s e) x -> ParseError s e #
Generic (ParseErrorBundle s e)
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ParseErrorBundle s e) :: Type -> Type # Methods from :: ParseErrorBundle s e -> Rep (ParseErrorBundle s e) x # to :: Rep (ParseErrorBundle s e) x -> ParseErrorBundle s e #
Generic (State s e)
Instance details Defined in Text.Megaparsec.State Associated Types type Rep (State s e) :: Type -> Type # Methods from :: State s e -> Rep (State s e) x # to :: Rep (State s e) x -> State s e #
Generic (ArithError n m)
Instance details Defined in Morley.Michelson.Typed.Arith Associated Types type Rep (ArithError n m) :: Type -> Type # Methods from :: ArithError n m -> Rep (ArithError n m) x # to :: Rep (ArithError n m) x -> ArithError n m #
Generic (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type Rep (BigMap k v) :: Type -> Type # Methods from :: BigMap k v -> Rep (BigMap k v) x # to :: Rep (BigMap k v) x -> BigMap k v #
Generic (TransferTokens instr p)
Instance details Defined in Morley.Michelson.Typed.Value Associated Types type Rep (TransferTokens instr p) :: Type -> Type # Methods from :: TransferTokens instr p -> Rep (TransferTokens instr p) x # to :: Rep (TransferTokens instr p) x -> TransferTokens instr p #
Generic (Annotation tag)
Instance details Defined in Morley.Michelson.Untyped.Annotation Associated Types type Rep (Annotation tag) :: Type -> Type # Methods from :: Annotation tag -> Rep (Annotation tag) x # to :: Rep (Annotation tag) x -> Annotation tag #
Generic (IntMapOf k v)
Instance details Defined in Data.Semiring Associated Types type Rep (IntMapOf k v) :: Type -> Type # Methods from :: IntMapOf k v -> Rep (IntMapOf k v) x # to :: Rep (IntMapOf k v) x -> IntMapOf k v #
Generic (Either a b)
Instance details Defined in Data.Strict.Either Associated Types type Rep (Either a b) :: Type -> Type # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
Generic (These a b)
Instance details Defined in Data.Strict.These Associated Types type Rep (These a b) :: Type -> Type # Methods from :: These a b -> Rep (These a b) x # to :: Rep (These a b) x -> These a b #
Generic (Pair a b)
Instance details Defined in Data.Strict.Tuple Associated Types type Rep (Pair a b) :: Type -> Type # Methods from :: Pair a b -> Rep (Pair a b) x # to :: Rep (Pair a b) x -> Pair a b #
Generic (These a b)
Instance details Defined in Data.These Associated Types type Rep (These a b) :: Type -> Type # Methods from :: These a b -> Rep (These a b) x # to :: Rep (These a b) x -> These a b #
Generic (a, b)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b) :: Type -> Type # Methods from :: (a, b) -> Rep (a, b) x # to :: Rep (a, b) x -> (a, b) #
Generic (WrappedArrow a b c)
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type # Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c #
Generic (Kleisli m a b)
Instance details Defined in Control.Arrow Associated Types type Rep (Kleisli m a b) :: Type -> Type # Methods from :: Kleisli m a b -> Rep (Kleisli m a b) x # to :: Rep (Kleisli m a b) x -> Kleisli m a b #
Generic (Const a b)
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type # Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Generic (Ap f a)
Instance details Defined in Data.Monoid Associated Types type Rep (Ap f a) :: Type -> Type # Methods from :: Ap f a -> Rep (Ap f a) x # to :: Rep (Ap f a) x -> Ap f a #
Generic (Alt f a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Alt f a) :: Type -> Type # Methods from :: Alt f a -> Rep (Alt f a) x # to :: Rep (Alt f a) x -> Alt f a #
Generic (Rec1 f p)
Instance details Defined in GHC.Generics Associated Types type Rep (Rec1 f p) :: Type -> Type # Methods from :: Rec1 f p -> Rep (Rec1 f p) x # to :: Rep (Rec1 f p) x -> Rec1 f p #
Generic (URec (Ptr ()) p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p #
Generic (URec Char p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
Generic (URec Double p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
Generic (URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
Generic (URec Int p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
Generic (URec Word p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
Generic (Fix p a)
Instance details Defined in Data.Bifunctor.Fix Associated Types type Rep (Fix p a) :: Type -> Type # Methods from :: Fix p a -> Rep (Fix p a) x # to :: Rep (Fix p a) x -> Fix p a #
Generic (Join p a)
Instance details Defined in Data.Bifunctor.Join Associated Types type Rep (Join p a) :: Type -> Type # Methods from :: Join p a -> Rep (Join p a) x # to :: Rep (Join p a) x -> Join p a #
Generic (CofreeF f a b)
Instance details Defined in Control.Comonad.Trans.Cofree Associated Types type Rep (CofreeF f a b) :: Type -> Type # Methods from :: CofreeF f a b -> Rep (CofreeF f a b) x # to :: Rep (CofreeF f a b) x -> CofreeF f a b #
Generic (FreeF f a b)
Instance details Defined in Control.Monad.Trans.Free Associated Types type Rep (FreeF f a b) :: Type -> Type # Methods from :: FreeF f a b -> Rep (FreeF f a b) x # to :: Rep (FreeF f a b) x -> FreeF f a b #
Generic (Tagged s b)
Instance details Defined in Data.Tagged Associated Types type Rep (Tagged s b) :: Type -> Type # Methods from :: Tagged s b -> Rep (Tagged s b) x # to :: Rep (Tagged s b) x -> Tagged s b #
Generic (These1 f g a)
Instance details Defined in Data.Functor.These Associated Types type Rep (These1 f g a) :: Type -> Type # Methods from :: These1 f g a -> Rep (These1 f g a) x # to :: Rep (These1 f g a) x -> These1 f g a #
Generic (Rec f rs) => Generic (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Associated Types type Rep (Rec f (r ': rs)) :: Type -> Type # Methods from :: Rec f (r ': rs) -> Rep (Rec f (r ': rs)) x # to :: Rep (Rec f (r ': rs)) x -> Rec f (r ': rs) #
Generic (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Associated Types type Rep (Rec f '[]) :: Type -> Type # Methods from :: Rec f '[] -> Rep (Rec f '[]) x # to :: Rep (Rec f '[]) x -> Rec f '[] #
Generic (Const a b)
Instance details Defined in Data.Vinyl.Functor Associated Types type Rep (Const a b) :: Type -> Type # Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Generic (a, b, c)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c) :: Type -> Type # Methods from :: (a, b, c) -> Rep (a, b, c) x # to :: Rep (a, b, c) x -> (a, b, c) #
Generic (Product f g a)
Instance details Defined in Data.Functor.Product Associated Types type Rep (Product f g a) :: Type -> Type # Methods from :: Product f g a -> Rep (Product f g a) x # to :: Rep (Product f g a) x -> Product f g a #
Generic (Sum f g a)
Instance details Defined in Data.Functor.Sum Associated Types type Rep (Sum f g a) :: Type -> Type # Methods from :: Sum f g a -> Rep (Sum f g a) x # to :: Rep (Sum f g a) x -> Sum f g a #
Generic ((f :*: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :: g) p) :: Type -> Type # Methods from :: (f :: g) p -> Rep ((f :: g) p) x # to :: Rep ((f :: g) p) x -> (f :*: g) p #
Generic ((f :+: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x # to :: Rep ((f :+: g) p) x -> (f :+: g) p #
Generic (K1 i c p)
Instance details Defined in GHC.Generics Associated Types type Rep (K1 i c p) :: Type -> Type # Methods from :: K1 i c p -> Rep (K1 i c p) x # to :: Rep (K1 i c p) x -> K1 i c p #
Generic (a, b, c, d)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d) :: Type -> Type # Methods from :: (a, b, c, d) -> Rep (a, b, c, d) x # to :: Rep (a, b, c, d) x -> (a, b, c, d) #
Generic (Compose f g a)
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type # Methods from :: Compose f g a -> Rep (Compose f g a) x # to :: Rep (Compose f g a) x -> Compose f g a #
Generic ((f :.: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x # to :: Rep ((f :.: g) p) x -> (f :.: g) p #
Generic (M1 i c f p)
Instance details Defined in GHC.Generics Associated Types type Rep (M1 i c f p) :: Type -> Type # Methods from :: M1 i c f p -> Rep (M1 i c f p) x # to :: Rep (M1 i c f p) x -> M1 i c f p #
Generic (Clown f a b)
Instance details Defined in Data.Bifunctor.Clown Associated Types type Rep (Clown f a b) :: Type -> Type # Methods from :: Clown f a b -> Rep (Clown f a b) x # to :: Rep (Clown f a b) x -> Clown f a b #
Generic (Flip p a b)
Instance details Defined in Data.Bifunctor.Flip Associated Types type Rep (Flip p a b) :: Type -> Type # Methods from :: Flip p a b -> Rep (Flip p a b) x # to :: Rep (Flip p a b) x -> Flip p a b #
Generic (Joker g a b)
Instance details Defined in Data.Bifunctor.Joker Associated Types type Rep (Joker g a b) :: Type -> Type # Methods from :: Joker g a b -> Rep (Joker g a b) x # to :: Rep (Joker g a b) x -> Joker g a b #
Generic (WrappedBifunctor p a b)
Instance details Defined in Data.Bifunctor.Wrapped Associated Types type Rep (WrappedBifunctor p a b) :: Type -> Type # Methods from :: WrappedBifunctor p a b -> Rep (WrappedBifunctor p a b) x # to :: Rep (WrappedBifunctor p a b) x -> WrappedBifunctor p a b #
Generic (Compose f g x)
Instance details Defined in Data.Vinyl.Functor Associated Types type Rep (Compose f g x) :: Type -> Type # Methods from :: Compose f g x -> Rep (Compose f g x) x0 # to :: Rep (Compose f g x) x0 -> Compose f g x #
Generic (a, b, c, d, e)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e) :: Type -> Type # Methods from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x # to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) #
Generic (Product f g a b)
Instance details Defined in Data.Bifunctor.Product Associated Types type Rep (Product f g a b) :: Type -> Type # Methods from :: Product f g a b -> Rep (Product f g a b) x # to :: Rep (Product f g a b) x -> Product f g a b #
Generic (Sum p q a b)
Instance details Defined in Data.Bifunctor.Sum Associated Types type Rep (Sum p q a b) :: Type -> Type # Methods from :: Sum p q a b -> Rep (Sum p q a b) x # to :: Rep (Sum p q a b) x -> Sum p q a b #
Generic (a, b, c, d, e, f)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f) :: Type -> Type # Methods from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x # to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f) #
Generic (Tannen f p a b)
Instance details Defined in Data.Bifunctor.Tannen Associated Types type Rep (Tannen f p a b) :: Type -> Type # Methods from :: Tannen f p a b -> Rep (Tannen f p a b) x # to :: Rep (Tannen f p a b) x -> Tannen f p a b #
Generic (a, b, c, d, e, f, g)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g) :: Type -> Type # Methods from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x # to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g) #
Generic (Biff p f g a b)
Instance details Defined in Data.Bifunctor.Biff Associated Types type Rep (Biff p f g a b) :: Type -> Type # Methods from :: Biff p f g a b -> Rep (Biff p f g a b) x # to :: Rep (Biff p f g a b) x -> Biff p f g a b #

class KnownNat (n :: Nat) #

This class gives the integer associated with a type-level natural. There are instances of the class for every concrete literal: 0, 1, 2, etc.

Since: base-4.7.0.0

Minimal complete definition

natSing

class IsLabel (x :: Symbol) a where #

Methods

fromLabel :: a #

Instances

Instances details

name ~ name' => IsLabel name' (Name name)
Instance details Defined in Named.Internal Methods fromLabel :: Name name #
(KnownSymbol name, s ~ name) => IsLabel s (Label name)
Instance details Defined in Morley.Util.Label Methods fromLabel :: Label name #
(name ~ name', a ~ a', InjValue f) => IsLabel name (a -> NamedF f a' name')
Instance details Defined in Named.Internal Methods fromLabel :: a -> NamedF f a' name' #
(p ~ NamedF f a name, InjValue f) => IsLabel name (a -> Param p)
Instance details Defined in Named.Internal Methods fromLabel :: a -> Param p #

class Semigroup a where #

The class of semigroups (types with an associative binary operation).

Instances should satisfy the following:

Associativity: x <> (y <> z) = (x <> y) <> z

Since: base-4.9.0.0

Minimal complete definition

(<>)

Methods

sconcat :: NonEmpty a -> a #

Reduce a non-empty list with <>

The default definition should be sufficient, but this can be overridden for efficiency.

>>> import Data.List.NonEmpty (NonEmpty (..))
>>> sconcat $ "Hello" :| [" ", "Haskell", "!"]
"Hello Haskell!"

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

Repeat a value n times.

Given that this works on a Semigroup it is allowed to fail if you request 0 or fewer repetitions, and the default definition will do so.

By making this a member of the class, idempotent semigroups and monoids can upgrade this to execute in $\mathcal{O}(1)$ by picking stimes = stimesIdempotent or stimes = stimesIdempotentMonoid respectively.

>>> stimes 4 [1]
[1,1,1,1]

Instances

Instances details

Semigroup More
Instance details Defined in Data.Attoparsec.Internal.Types Methods (<>) :: More -> More -> More # sconcat :: NonEmpty More -> More # stimes :: Integral b => b -> More -> More #
Semigroup All	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # stimes :: Integral b => b -> All -> All #
Semigroup Any	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Any -> Any -> Any # sconcat :: NonEmpty Any -> Any # stimes :: Integral b => b -> Any -> Any #
Semigroup Void	Since: base-4.9.0.0
Instance details Defined in Data.Void Methods (<>) :: Void -> Void -> Void # sconcat :: NonEmpty Void -> Void # stimes :: Integral b => b -> Void -> Void #
Semigroup AsciiString
Instance details Defined in Basement.Types.AsciiString Methods (<>) :: AsciiString -> AsciiString -> AsciiString # sconcat :: NonEmpty AsciiString -> AsciiString # stimes :: Integral b => b -> AsciiString -> AsciiString #
Semigroup String
Instance details Defined in Basement.UTF8.Base Methods (<>) :: String -> String -> String # sconcat :: NonEmpty String -> String # stimes :: Integral b => b -> String -> String #
Semigroup Builder
Instance details Defined in Data.ByteString.Builder.Internal Methods (<>) :: Builder -> Builder -> Builder # sconcat :: NonEmpty Builder -> Builder # stimes :: Integral b => b -> Builder -> Builder #
Semigroup ByteString
Instance details Defined in Data.ByteString.Internal Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Semigroup ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Semigroup ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods (<>) :: ShortByteString -> ShortByteString -> ShortByteString # sconcat :: NonEmpty ShortByteString -> ShortByteString # stimes :: Integral b => b -> ShortByteString -> ShortByteString #
Semigroup IntSet	Since: containers-0.5.7
Instance details Defined in Data.IntSet.Internal Methods (<>) :: IntSet -> IntSet -> IntSet # sconcat :: NonEmpty IntSet -> IntSet # stimes :: Integral b => b -> IntSet -> IntSet #
Semigroup Ordering	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Semigroup GenCodeHooks Source #
Instance details Defined in Indigo.Common.State Methods (<>) :: GenCodeHooks -> GenCodeHooks -> GenCodeHooks # sconcat :: NonEmpty GenCodeHooks -> GenCodeHooks # stimes :: Integral b => b -> GenCodeHooks -> GenCodeHooks #
Semigroup CommentHooks Source #
Instance details Defined in Indigo.Compilation.Hooks Methods (<>) :: CommentHooks -> CommentHooks -> CommentHooks # sconcat :: NonEmpty CommentHooks -> CommentHooks # stimes :: Integral b => b -> CommentHooks -> CommentHooks #
Semigroup SequentialHooks Source #
Instance details Defined in Indigo.Compilation.Sequential.Types Methods (<>) :: SequentialHooks -> SequentialHooks -> SequentialHooks # sconcat :: NonEmpty SequentialHooks -> SequentialHooks # stimes :: Integral b => b -> SequentialHooks -> SequentialHooks #
Semigroup Pos
Instance details Defined in Text.Megaparsec.Pos Methods (<>) :: Pos -> Pos -> Pos # sconcat :: NonEmpty Pos -> Pos # stimes :: Integral b => b -> Pos -> Pos #
Semigroup AnalyzerRes
Instance details Defined in Morley.Michelson.Analyzer Methods (<>) :: AnalyzerRes -> AnalyzerRes -> AnalyzerRes # sconcat :: NonEmpty AnalyzerRes -> AnalyzerRes # stimes :: Integral b => b -> AnalyzerRes -> AnalyzerRes #
Semigroup ContractDoc	Contract documentation assembly primarily relies on this instance.
Instance details Defined in Morley.Michelson.Doc Methods (<>) :: ContractDoc -> ContractDoc -> ContractDoc # sconcat :: NonEmpty ContractDoc -> ContractDoc # stimes :: Integral b => b -> ContractDoc -> ContractDoc #
Semigroup MorleyLogs
Instance details Defined in Morley.Michelson.Interpret Methods (<>) :: MorleyLogs -> MorleyLogs -> MorleyLogs # sconcat :: NonEmpty MorleyLogs -> MorleyLogs # stimes :: Integral b => b -> MorleyLogs -> MorleyLogs #
Semigroup MorleyLogsBuilder
Instance details Defined in Morley.Michelson.Interpret Methods (<>) :: MorleyLogsBuilder -> MorleyLogsBuilder -> MorleyLogsBuilder # sconcat :: NonEmpty MorleyLogsBuilder -> MorleyLogsBuilder # stimes :: Integral b => b -> MorleyLogsBuilder -> MorleyLogsBuilder #
Semigroup Ruleset
Instance details Defined in Morley.Michelson.Optimizer Methods (<>) :: Ruleset -> Ruleset -> Ruleset # sconcat :: NonEmpty Ruleset -> Ruleset # stimes :: Integral b => b -> Ruleset -> Ruleset #
Semigroup MText
Instance details Defined in Morley.Michelson.Text Methods (<>) :: MText -> MText -> MText # sconcat :: NonEmpty MText -> MText # stimes :: Integral b => b -> MText -> MText #
Semigroup AnnotationSet
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods (<>) :: AnnotationSet -> AnnotationSet -> AnnotationSet # sconcat :: NonEmpty AnnotationSet -> AnnotationSet # stimes :: Integral b => b -> AnnotationSet -> AnnotationSet #
Semigroup VarAnn
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods (<>) :: VarAnn -> VarAnn -> VarAnn # sconcat :: NonEmpty VarAnn -> VarAnn # stimes :: Integral b => b -> VarAnn -> VarAnn #
Semigroup Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods (<>) :: Doc -> Doc -> Doc # sconcat :: NonEmpty Doc -> Doc # stimes :: Integral b => b -> Doc -> Doc #
Semigroup ByteArray
Instance details Defined in Data.Primitive.ByteArray Methods (<>) :: ByteArray -> ByteArray -> ByteArray # sconcat :: NonEmpty ByteArray -> ByteArray # stimes :: Integral b => b -> ByteArray -> ByteArray #
Semigroup PromDPatInfos
Instance details Defined in Data.Singletons.TH.Syntax Methods (<>) :: PromDPatInfos -> PromDPatInfos -> PromDPatInfos # sconcat :: NonEmpty PromDPatInfos -> PromDPatInfos # stimes :: Integral b => b -> PromDPatInfos -> PromDPatInfos #
Semigroup ULetDecEnv
Instance details Defined in Data.Singletons.TH.Syntax Methods (<>) :: ULetDecEnv -> ULetDecEnv -> ULetDecEnv # sconcat :: NonEmpty ULetDecEnv -> ULetDecEnv # stimes :: Integral b => b -> ULetDecEnv -> ULetDecEnv #
Semigroup Builder
Instance details Defined in Data.Text.Internal.Builder Methods (<>) :: Builder -> Builder -> Builder # sconcat :: NonEmpty Builder -> Builder # stimes :: Integral b => b -> Builder -> Builder #
Semigroup ShortText
Instance details Defined in Data.Text.Short.Internal Methods (<>) :: ShortText -> ShortText -> ShortText # sconcat :: NonEmpty ShortText -> ShortText # stimes :: Integral b => b -> ShortText -> ShortText #
Semigroup ()	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: () -> () -> () # sconcat :: NonEmpty () -> () # stimes :: Integral b => b -> () -> () #
() :=> (Semigroup (Dict a))
Instance details Defined in Data.Constraint Methods ins :: () :- Semigroup (Dict a) #
() :=> (Semigroup Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Semigroup Ordering #
() :=> (Semigroup ())
Instance details Defined in Data.Constraint Methods ins :: () :- Semigroup () #
() :=> (Semigroup [a])
Instance details Defined in Data.Constraint Methods ins :: () :- Semigroup [a] #
Class () (Semigroup a)
Instance details Defined in Data.Constraint Methods cls :: Semigroup a :- () #
Semigroup (First' a)
Instance details Defined in Distribution.Compat.Semigroup Methods (<>) :: First' a -> First' a -> First' a # sconcat :: NonEmpty (First' a) -> First' a # stimes :: Integral b => b -> First' a -> First' a #
Semigroup (Last' a)
Instance details Defined in Distribution.Compat.Semigroup Methods (<>) :: Last' a -> Last' a -> Last' a # sconcat :: NonEmpty (Last' a) -> Last' a # stimes :: Integral b => b -> Last' a -> Last' a #
Semigroup a => Semigroup (Option' a)
Instance details Defined in Distribution.Compat.Semigroup Methods (<>) :: Option' a -> Option' a -> Option' a # sconcat :: NonEmpty (Option' a) -> Option' a # stimes :: Integral b => b -> Option' a -> Option' a #
Semigroup (KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods (<>) :: KeyMap v -> KeyMap v -> KeyMap v # sconcat :: NonEmpty (KeyMap v) -> KeyMap v # stimes :: Integral b => b -> KeyMap v -> KeyMap v #
Semigroup (IResult a)
Instance details Defined in Data.Aeson.Types.Internal Methods (<>) :: IResult a -> IResult a -> IResult a # sconcat :: NonEmpty (IResult a) -> IResult a # stimes :: Integral b => b -> IResult a -> IResult a #
Semigroup (Parser a)
Instance details Defined in Data.Aeson.Types.Internal Methods (<>) :: Parser a -> Parser a -> Parser a # sconcat :: NonEmpty (Parser a) -> Parser a # stimes :: Integral b => b -> Parser a -> Parser a #
Semigroup (Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods (<>) :: Result a -> Result a -> Result a # sconcat :: NonEmpty (Result a) -> Result a # stimes :: Integral b => b -> Result a -> Result a #
Semigroup a => Semigroup (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Semigroup (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Monoid Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Monoid Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Semigroup a => Semigroup (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (<>) :: Down a -> Down a -> Down a # sconcat :: NonEmpty (Down a) -> Down a # stimes :: Integral b => b -> Down a -> Down a #
Semigroup (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Ord a => Semigroup (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Max a -> Max a -> Max a # sconcat :: NonEmpty (Max a) -> Max a # stimes :: Integral b => b -> Max a -> Max a #
Ord a => Semigroup (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Min a -> Min a -> Min a # sconcat :: NonEmpty (Min a) -> Min a # stimes :: Integral b => b -> Min a -> Min a #
Semigroup a => Semigroup (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Option a -> Option a -> Option a # sconcat :: NonEmpty (Option a) -> Option a # stimes :: Integral b => b -> Option a -> Option a #
Monoid m => Semigroup (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m # stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m #
Semigroup a => Semigroup (Dual a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Dual a -> Dual a -> Dual a # sconcat :: NonEmpty (Dual a) -> Dual a # stimes :: Integral b => b -> Dual a -> Dual a #
Semigroup (Endo a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Endo a -> Endo a -> Endo a # sconcat :: NonEmpty (Endo a) -> Endo a # stimes :: Integral b => b -> Endo a -> Endo a #
Num a => Semigroup (Product a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Product a -> Product a -> Product a # sconcat :: NonEmpty (Product a) -> Product a # stimes :: Integral b => b -> Product a -> Product a #
Num a => Semigroup (Sum a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Sum a -> Sum a -> Sum a # sconcat :: NonEmpty (Sum a) -> Sum a # stimes :: Integral b => b -> Sum a -> Sum a #
Semigroup (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #
Semigroup p => Semigroup (Par1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: Par1 p -> Par1 p -> Par1 p # sconcat :: NonEmpty (Par1 p) -> Par1 p # stimes :: Integral b => b -> Par1 p -> Par1 p #
PrimType ty => Semigroup (Block ty)
Instance details Defined in Basement.Block.Base Methods (<>) :: Block ty -> Block ty -> Block ty # sconcat :: NonEmpty (Block ty) -> Block ty # stimes :: Integral b => b -> Block ty -> Block ty #
Semigroup (Array a)
Instance details Defined in Basement.BoxedArray Methods (<>) :: Array a -> Array a -> Array a # sconcat :: NonEmpty (Array a) -> Array a # stimes :: Integral b => b -> Array a -> Array a #
Semigroup (CountOf ty)
Instance details Defined in Basement.Types.OffsetSize Methods (<>) :: CountOf ty -> CountOf ty -> CountOf ty # sconcat :: NonEmpty (CountOf ty) -> CountOf ty # stimes :: Integral b => b -> CountOf ty -> CountOf ty #
PrimType ty => Semigroup (UArray ty)
Instance details Defined in Basement.UArray.Base Methods (<>) :: UArray ty -> UArray ty -> UArray ty # sconcat :: NonEmpty (UArray ty) -> UArray ty # stimes :: Integral b => b -> UArray ty -> UArray ty #
Semigroup (Dict a)
Instance details 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 #
Semigroup (IntMap a)	Since: containers-0.5.7
Instance details Defined in Data.IntMap.Internal Methods (<>) :: IntMap a -> IntMap a -> IntMap a # sconcat :: NonEmpty (IntMap a) -> IntMap a # stimes :: Integral b => b -> IntMap a -> IntMap a #
Semigroup (Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods (<>) :: Seq a -> Seq a -> Seq a # sconcat :: NonEmpty (Seq a) -> Seq a # stimes :: Integral b => b -> Seq a -> Seq a #
Semigroup (MergeSet a)
Instance details Defined in Data.Set.Internal Methods (<>) :: MergeSet a -> MergeSet a -> MergeSet a # sconcat :: NonEmpty (MergeSet a) -> MergeSet a # stimes :: Integral b => b -> MergeSet a -> MergeSet a #
Ord a => Semigroup (Set a)	Since: containers-0.5.7
Instance details Defined in Data.Set.Internal Methods (<>) :: Set a -> Set a -> Set a # sconcat :: NonEmpty (Set a) -> Set a # stimes :: Integral b => b -> Set a -> Set a #
Semigroup (DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods (<>) :: DNonEmpty a -> DNonEmpty a -> DNonEmpty a # sconcat :: NonEmpty (DNonEmpty a) -> DNonEmpty a # stimes :: Integral b => b -> DNonEmpty a -> DNonEmpty a #
Semigroup (DList a)
Instance details Defined in Data.DList.Internal Methods (<>) :: DList a -> DList a -> DList a # sconcat :: NonEmpty (DList a) -> DList a # stimes :: Integral b => b -> DList a -> DList a #
KnownNat p => Semigroup (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods (<>) :: Binary p -> Binary p -> Binary p # sconcat :: NonEmpty (Binary p) -> Binary p # stimes :: Integral b => b -> Binary p -> Binary p #
KnownNat p => Semigroup (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods (<>) :: Prime p -> Prime p -> Prime p # sconcat :: NonEmpty (Prime p) -> Prime p # stimes :: Integral b => b -> Prime p -> Prime p #
Semigroup a => Semigroup (IO a)	Since: base-4.10.0.0
Instance details Defined in GHC.Base Methods (<>) :: IO a -> IO a -> IO a # sconcat :: NonEmpty (IO a) -> IO a # stimes :: Integral b => b -> IO a -> IO a #
Semigroup a => Semigroup (May a)
Instance details Defined in Lens.Micro.Mtl.Internal Methods (<>) :: May a -> May a -> May a # sconcat :: NonEmpty (May a) -> May a # stimes :: Integral b => b -> May a -> May a #
Semigroup (PrintComment st)
Instance details Defined in Morley.Michelson.Typed.Instr Methods (<>) :: PrintComment st -> PrintComment st -> PrintComment st # sconcat :: NonEmpty (PrintComment st) -> PrintComment st # stimes :: Integral b => b -> PrintComment st -> PrintComment st #
Semigroup (SomeSizedList a)
Instance details Defined in Morley.Util.SizedList Methods (<>) :: SomeSizedList a -> SomeSizedList a -> SomeSizedList a # sconcat :: NonEmpty (SomeSizedList a) -> SomeSizedList a # stimes :: Integral b => b -> SomeSizedList a -> SomeSizedList a #
Boolean a => Semigroup (All a)
Instance details Defined in Morley.Prelude.Boolean Methods (<>) :: All a -> All a -> All a # sconcat :: NonEmpty (All a) -> All a # stimes :: Integral b => b -> All a -> All a #
Boolean a => Semigroup (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods (<>) :: Any a -> Any a -> Any a # sconcat :: NonEmpty (Any a) -> Any a # stimes :: Integral b => b -> Any a -> Any a #
Semigroup (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (<>) :: Doc a -> Doc a -> Doc a # sconcat :: NonEmpty (Doc a) -> Doc a # stimes :: Integral b => b -> Doc a -> Doc a #
Semigroup (Array a)	Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.Array Methods (<>) :: Array a -> Array a -> Array a # sconcat :: NonEmpty (Array a) -> Array a # stimes :: Integral b => b -> Array a -> Array a #
Semigroup (PrimArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods (<>) :: PrimArray a -> PrimArray a -> PrimArray a # sconcat :: NonEmpty (PrimArray a) -> PrimArray a # stimes :: Integral b => b -> PrimArray a -> PrimArray a #
Semigroup (SmallArray a)	Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.SmallArray Methods (<>) :: SmallArray a -> SmallArray a -> SmallArray a # sconcat :: NonEmpty (SmallArray a) -> SmallArray a # stimes :: Integral b => b -> SmallArray a -> SmallArray a #
Semiring a => Semigroup (Add a)
Instance details Defined in Data.Semiring Methods (<>) :: Add a -> Add a -> Add a # sconcat :: NonEmpty (Add a) -> Add a # stimes :: Integral b => b -> Add a -> Add a #
Semiring a => Semigroup (Add' a)
Instance details Defined in Data.Semiring Methods (<>) :: Add' a -> Add' a -> Add' a # sconcat :: NonEmpty (Add' a) -> Add' a # stimes :: Integral b => b -> Add' a -> Add' a #
Semigroup (IntSetOf a)
Instance details Defined in Data.Semiring Methods (<>) :: IntSetOf a -> IntSetOf a -> IntSetOf a # sconcat :: NonEmpty (IntSetOf a) -> IntSetOf a # stimes :: Integral b => b -> IntSetOf a -> IntSetOf a #
Semiring a => Semigroup (Mul a)
Instance details Defined in Data.Semiring Methods (<>) :: Mul a -> Mul a -> Mul a # sconcat :: NonEmpty (Mul a) -> Mul a # stimes :: Integral b => b -> Mul a -> Mul a #
Semigroup a => Semigroup (Maybe a)
Instance details Defined in Data.Strict.Maybe Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Semigroup a => Semigroup (Q a)	Since: template-haskell-2.17.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods (<>) :: Q a -> Q a -> Q a # sconcat :: NonEmpty (Q a) -> Q a # stimes :: Integral b => b -> Q a -> Q a #
(Hashable a, Eq a) => Semigroup (HashSet a)	`<>` = `union` O(n+m) To obtain good performance, the smaller set must be presented as the first argument. Examples Expand `>>>` `fromList [1,2] <> fromList [2,3]`fromList [1,2,3]
Instance details Defined in Data.HashSet.Internal Methods (<>) :: HashSet a -> HashSet a -> HashSet a # sconcat :: NonEmpty (HashSet a) -> HashSet a # stimes :: Integral b => b -> HashSet a -> HashSet a #
Semigroup (Vector a)
Instance details Defined in Data.Vector Methods (<>) :: Vector a -> Vector a -> Vector a # sconcat :: NonEmpty (Vector a) -> Vector a # stimes :: Integral b => b -> Vector a -> Vector a #
Prim a => Semigroup (Vector a)
Instance details Defined in Data.Vector.Primitive Methods (<>) :: Vector a -> Vector a -> Vector a # sconcat :: NonEmpty (Vector a) -> Vector a # stimes :: Integral b => b -> Vector a -> Vector a #
Storable a => Semigroup (Vector a)
Instance details Defined in Data.Vector.Storable Methods (<>) :: Vector a -> Vector a -> Vector a # sconcat :: NonEmpty (Vector a) -> Vector a # stimes :: Integral b => b -> Vector a -> Vector a #
Semigroup t => Semigroup (ElField '(s, t))
Instance details Defined in Data.Vinyl.Functor Methods (<>) :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # sconcat :: NonEmpty (ElField '(s, t)) -> ElField '(s, t) # stimes :: Integral b => b -> ElField '(s, t) -> ElField '(s, t) #
Semigroup a => Semigroup (Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Semigroup a => Semigroup (a)	Since: base-4.15
Instance details Defined in GHC.Base Methods (<>) :: (a) -> (a) -> (a) # sconcat :: NonEmpty (a) -> (a) # stimes :: Integral b => b -> (a) -> (a) #
Semigroup [a]	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: [a] -> [a] -> [a] # sconcat :: NonEmpty [a] -> [a] # stimes :: Integral b => b -> [a] -> [a] #
(Semigroup a) :=> (Semigroup (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Semigroup a :- Semigroup (Const a b) #
(Semigroup a) :=> (Semigroup (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Semigroup a :- Semigroup (Identity a) #
(Semigroup a) :=> (Semigroup (IO a))
Instance details Defined in Data.Constraint Methods ins :: Semigroup a :- Semigroup (IO a) #
(Semigroup a) :=> (Semigroup (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Semigroup a :- Semigroup (Maybe a) #
Class (Semigroup a) (Monoid a)
Instance details Defined in Data.Constraint Methods cls :: Monoid a :- Semigroup a #
Semigroup (Parser i a)
Instance details Defined in Data.Attoparsec.Internal.Types Methods (<>) :: Parser i a -> Parser i a -> Parser i a # sconcat :: NonEmpty (Parser i a) -> Parser i a # stimes :: Integral b => b -> Parser i a -> Parser i a #
Semigroup (Either a b)	Since: base-4.9.0.0
Instance details Defined in Data.Either Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b0 => b0 -> Either a b -> Either a b #
Semigroup (Proxy s)	Since: base-4.9.0.0
Instance details 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 #
Semigroup (U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: U1 p -> U1 p -> U1 p # sconcat :: NonEmpty (U1 p) -> U1 p # stimes :: Integral b => b -> U1 p -> U1 p #
Semigroup (V1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: V1 p -> V1 p -> V1 p # sconcat :: NonEmpty (V1 p) -> V1 p # stimes :: Integral b => b -> V1 p -> V1 p #
Semigroup a => Semigroup (ST s a)	Since: base-4.11.0.0
Instance details Defined in GHC.ST Methods (<>) :: ST s a -> ST s a -> ST s a # sconcat :: NonEmpty (ST s a) -> ST s a # stimes :: Integral b => b -> ST s a -> ST s a #
Ord k => Semigroup (Map k v)
Instance details Defined in Data.Map.Internal Methods (<>) :: Map k v -> Map k v -> Map k v # sconcat :: NonEmpty (Map k v) -> Map k v # stimes :: Integral b => b -> Map k v -> Map k v #
IrreducibleMonic p k => Semigroup (Extension p k)
Instance details Defined in Data.Field.Galois.Extension Methods (<>) :: Extension p k -> Extension p k -> Extension p k # sconcat :: NonEmpty (Extension p k) -> Extension p k # stimes :: Integral b => b -> Extension p k -> Extension p k #
(KnownNat n, GaloisField k) => Semigroup (RootsOfUnity n k)
Instance details Defined in Data.Field.Galois.Unity Methods (<>) :: RootsOfUnity n k -> RootsOfUnity n k -> RootsOfUnity n k # sconcat :: NonEmpty (RootsOfUnity n k) -> RootsOfUnity n k # stimes :: Integral b => b -> RootsOfUnity n k -> RootsOfUnity n k #
Semigroup (f a) => Semigroup (Indexing f a)
Instance details Defined in Control.Lens.Internal.Indexed Methods (<>) :: Indexing f a -> Indexing f a -> Indexing f a # sconcat :: NonEmpty (Indexing f a) -> Indexing f a # stimes :: Integral b => b -> Indexing f a -> Indexing f a #
Semigroup (ReifiedFold s a)
Instance details Defined in Control.Lens.Reified Methods (<>) :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a # sconcat :: NonEmpty (ReifiedFold s a) -> ReifiedFold s a # stimes :: Integral b => b -> ReifiedFold s a -> ReifiedFold s a #
Semigroup (s :-> s)
Instance details Defined in Lorentz.Base Methods (<>) :: (s :-> s) -> (s :-> s) -> s :-> s # sconcat :: NonEmpty (s :-> s) -> s :-> s # stimes :: Integral b => b -> (s :-> s) -> s :-> s #
(Stream s, Ord e) => Semigroup (ParseError s e)
Instance details Defined in Text.Megaparsec.Error Methods (<>) :: ParseError s e -> ParseError s e -> ParseError s e # sconcat :: NonEmpty (ParseError s e) -> ParseError s e # stimes :: Integral b => b -> ParseError s e -> ParseError s e #
Semigroup a => Semigroup (Err e a)
Instance details Defined in Lens.Micro.Mtl.Internal Methods (<>) :: Err e a -> Err e a -> Err e a # sconcat :: NonEmpty (Err e a) -> Err e a # stimes :: Integral b => b -> Err e a -> Err e a #
Ord k => Semigroup (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (<>) :: BigMap k v -> BigMap k v -> BigMap k v # sconcat :: NonEmpty (BigMap k v) -> BigMap k v # stimes :: Integral b => b -> BigMap k v -> BigMap k v #
Semigroup (Instr s s)
Instance details Defined in Morley.Michelson.Typed.Instr Methods (<>) :: Instr s s -> Instr s s -> Instr s s # sconcat :: NonEmpty (Instr s s) -> Instr s s # stimes :: Integral b => b -> Instr s s -> Instr s s #
Semigroup (IntMapOf k v)
Instance details Defined in Data.Semiring Methods (<>) :: IntMapOf k v -> IntMapOf k v -> IntMapOf k v # sconcat :: NonEmpty (IntMapOf k v) -> IntMapOf k v # stimes :: Integral b => b -> IntMapOf k v -> IntMapOf k v #
Semigroup (Either a b)
Instance details Defined in Data.Strict.Either Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b0 => b0 -> Either a b -> Either a b #
(Semigroup a, Semigroup b) => Semigroup (These a b)
Instance details Defined in Data.Strict.These Methods (<>) :: These a b -> These a b -> These a b # sconcat :: NonEmpty (These a b) -> These a b # stimes :: Integral b0 => b0 -> These a b -> These a b #
(Semigroup a, Semigroup b) => Semigroup (Pair a b)
Instance details Defined in Data.Strict.Tuple Methods (<>) :: Pair a b -> Pair a b -> Pair a b # sconcat :: NonEmpty (Pair a b) -> Pair a b # stimes :: Integral b0 => b0 -> Pair a b -> Pair a b #
(Semigroup a, Semigroup b) => Semigroup (These a b)
Instance details Defined in Data.These Methods (<>) :: These a b -> These a b -> These a b # sconcat :: NonEmpty (These a b) -> These a b # stimes :: Integral b0 => b0 -> These a b -> These a b #
(Eq k, Hashable k) => Semigroup (HashMap k v)	`<>` = `union` If a key occurs in both maps, the mapping from the first will be the mapping in the result. Examples Expand `>>>` `fromList [(1,'a'),(2,'b')] <> fromList [(2,'c'),(3,'d')]`fromList [(1,'a'),(2,'b'),(3,'d')]
Instance details Defined in Data.HashMap.Internal Methods (<>) :: HashMap k v -> HashMap k v -> HashMap k v # sconcat :: NonEmpty (HashMap k v) -> HashMap k v # stimes :: Integral b => b -> HashMap k v -> HashMap k v #
Semigroup b => Semigroup (a -> b)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a -> b) -> (a -> b) -> a -> b # sconcat :: NonEmpty (a -> b) -> a -> b # stimes :: Integral b0 => b0 -> (a -> b) -> a -> b #
(Semigroup a, Semigroup b) => Semigroup (a, b)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b) -> (a, b) -> (a, b) # sconcat :: NonEmpty (a, b) -> (a, b) # stimes :: Integral b0 => b0 -> (a, b) -> (a, b) #
(Semigroup a, Semigroup b) :=> (Semigroup (a, b))
Instance details Defined in Data.Constraint Methods ins :: (Semigroup a, Semigroup b) :- Semigroup (a, b) #
Semigroup a => Semigroup (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (<>) :: Const a b -> Const a b -> Const a b # sconcat :: NonEmpty (Const a b) -> Const a b # stimes :: Integral b0 => b0 -> Const a b -> Const a b #
(Applicative f, Semigroup a) => Semigroup (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods (<>) :: Ap f a -> Ap f a -> Ap f a # sconcat :: NonEmpty (Ap f a) -> Ap f a # stimes :: Integral b => b -> Ap f a -> Ap f a #
Alternative f => Semigroup (Alt f a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Alt f a -> Alt f a -> Alt f a # sconcat :: NonEmpty (Alt f a) -> Alt f a # stimes :: Integral b => b -> Alt f a -> Alt f a #
Semigroup (f p) => Semigroup (Rec1 f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: Rec1 f p -> Rec1 f p -> Rec1 f p # sconcat :: NonEmpty (Rec1 f p) -> Rec1 f p # stimes :: Integral b => b -> Rec1 f p -> Rec1 f p #
Semigroup (ReifiedIndexedFold i s a)
Instance details Defined in Control.Lens.Reified Methods (<>) :: ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a # sconcat :: NonEmpty (ReifiedIndexedFold i s a) -> ReifiedIndexedFold i s a # stimes :: Integral b => b -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a #
(Monad m, Semigroup r) => Semigroup (Effect m r a)
Instance details Defined in Lens.Micro.Mtl.Internal Methods (<>) :: Effect m r a -> Effect m r a -> Effect m r a # sconcat :: NonEmpty (Effect m r a) -> Effect m r a # stimes :: Integral b => b -> Effect m r a -> Effect m r a #
Reifies s (ReifiedMonoid a) => Semigroup (ReflectedMonoid a s)
Instance details Defined in Data.Reflection Methods (<>) :: ReflectedMonoid a s -> ReflectedMonoid a s -> ReflectedMonoid a s # sconcat :: NonEmpty (ReflectedMonoid a s) -> ReflectedMonoid a s # stimes :: Integral b => b -> ReflectedMonoid a s -> ReflectedMonoid a s #
Semigroup a => Semigroup (Tagged s a)
Instance details Defined in Data.Tagged Methods (<>) :: Tagged s a -> Tagged s a -> Tagged s a # sconcat :: NonEmpty (Tagged s a) -> Tagged s a # stimes :: Integral b => b -> Tagged s a -> Tagged s a #
(Semigroup (f r), Semigroup (Rec f rs)) => Semigroup (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Methods (<>) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) # sconcat :: NonEmpty (Rec f (r ': rs)) -> Rec f (r ': rs) # stimes :: Integral b => b -> Rec f (r ': rs) -> Rec f (r ': rs) #
Semigroup (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Methods (<>) :: Rec f '[] -> Rec f '[] -> Rec f '[] # sconcat :: NonEmpty (Rec f '[]) -> Rec f '[] # stimes :: Integral b => b -> Rec f '[] -> Rec f '[] #
(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b, c) -> (a, b, c) -> (a, b, c) # sconcat :: NonEmpty (a, b, c) -> (a, b, c) # stimes :: Integral b0 => b0 -> (a, b, c) -> (a, b, c) #
(Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: (f :: g) p -> (f :: g) p -> (f :: g) p # sconcat :: NonEmpty ((f :: g) p) -> (f :: g) p # stimes :: Integral b => b -> (f :: g) p -> (f :*: g) p #
Semigroup c => Semigroup (K1 i c p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: K1 i c p -> K1 i c p -> K1 i c p # sconcat :: NonEmpty (K1 i c p) -> K1 i c p # stimes :: Integral b => b -> K1 i c p -> K1 i c p #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d) # stimes :: Integral b0 => b0 -> (a, b, c, d) -> (a, b, c, d) #
Semigroup (f (g p)) => Semigroup ((f :.: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # sconcat :: NonEmpty ((f :.: g) p) -> (f :.: g) p # stimes :: Integral b => b -> (f :.: g) p -> (f :.: g) p #
Semigroup (f p) => Semigroup (M1 i c f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: M1 i c f p -> M1 i c f p -> M1 i c f p # sconcat :: NonEmpty (M1 i c f p) -> M1 i c f p # stimes :: Integral b => b -> M1 i c f p -> M1 i c f p #
Semigroup (f (g a)) => Semigroup (Compose f g a)
Instance details Defined in Data.Vinyl.Functor Methods (<>) :: Compose f g a -> Compose f g a -> Compose f g a # sconcat :: NonEmpty (Compose f g a) -> Compose f g a # stimes :: Integral b => b -> Compose f g a -> Compose f g a #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e) # stimes :: Integral b0 => b0 -> (a, b, c, d, e) -> (a, b, c, d, e) #
Curve f c e q r => Semigroup (Point f c e q r)
Instance details Defined in Data.Curve Methods (<>) :: Point f c e q r -> Point f c e q r -> Point f c e q r # sconcat :: NonEmpty (Point f c e q r) -> Point f c e q r # stimes :: Integral b => b -> Point f c e q r -> Point f c e q r #

class Semigroup a => Monoid a where #

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following:

Right identity: x <> mempty = x
Left identity: mempty <> x = x
Associativity: x <> (y <> z) = (x <> y) <> z (Semigroup law)
Concatenation: mconcat = foldr (<>) mempty

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.

Minimal complete definition

mempty

Methods

mempty :: a #

Identity of mappend

>>> "Hello world" <> mempty
"Hello world"

mappend :: a -> a -> a #

An associative operation

NOTE: This method is redundant and has the default implementation mappend = (<>) since base-4.11.0.0. Should it be implemented manually, since mappend is a synonym for (<>), it is expected that the two functions are defined the same way. In a future GHC release mappend will be removed from Monoid.

mconcat :: [a] -> a #

Fold a list using the monoid.

For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

>>> mconcat ["Hello", " ", "Haskell", "!"]
"Hello Haskell!"

Instances

Instances details

Monoid More
Instance details Defined in Data.Attoparsec.Internal.Types Methods mempty :: More # mappend :: More -> More -> More # mconcat :: [More] -> More #
Monoid All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid AsciiString
Instance details Defined in Basement.Types.AsciiString Methods mempty :: AsciiString # mappend :: AsciiString -> AsciiString -> AsciiString # mconcat :: [AsciiString] -> AsciiString #
Monoid String
Instance details Defined in Basement.UTF8.Base Methods mempty :: String # mappend :: String -> String -> String # mconcat :: [String] -> String #
Monoid Builder
Instance details Defined in Data.ByteString.Builder.Internal Methods mempty :: Builder # mappend :: Builder -> Builder -> Builder # mconcat :: [Builder] -> Builder #
Monoid ByteString
Instance details Defined in Data.ByteString.Internal Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods mempty :: ShortByteString # mappend :: ShortByteString -> ShortByteString -> ShortByteString # mconcat :: [ShortByteString] -> ShortByteString #
Monoid IntSet
Instance details Defined in Data.IntSet.Internal Methods mempty :: IntSet # mappend :: IntSet -> IntSet -> IntSet # mconcat :: [IntSet] -> IntSet #
Monoid Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid GenCodeHooks Source #
Instance details Defined in Indigo.Common.State Methods mempty :: GenCodeHooks # mappend :: GenCodeHooks -> GenCodeHooks -> GenCodeHooks # mconcat :: [GenCodeHooks] -> GenCodeHooks #
Monoid CommentHooks Source #
Instance details Defined in Indigo.Compilation.Hooks Methods mempty :: CommentHooks # mappend :: CommentHooks -> CommentHooks -> CommentHooks # mconcat :: [CommentHooks] -> CommentHooks #
Monoid SequentialHooks Source #
Instance details Defined in Indigo.Compilation.Sequential.Types Methods mempty :: SequentialHooks # mappend :: SequentialHooks -> SequentialHooks -> SequentialHooks # mconcat :: [SequentialHooks] -> SequentialHooks #
Monoid AnalyzerRes
Instance details Defined in Morley.Michelson.Analyzer Methods mempty :: AnalyzerRes # mappend :: AnalyzerRes -> AnalyzerRes -> AnalyzerRes # mconcat :: [AnalyzerRes] -> AnalyzerRes #
Monoid ContractDoc
Instance details Defined in Morley.Michelson.Doc Methods mempty :: ContractDoc # mappend :: ContractDoc -> ContractDoc -> ContractDoc # mconcat :: [ContractDoc] -> ContractDoc #
Monoid MorleyLogs
Instance details Defined in Morley.Michelson.Interpret Methods mempty :: MorleyLogs # mappend :: MorleyLogs -> MorleyLogs -> MorleyLogs # mconcat :: [MorleyLogs] -> MorleyLogs #
Monoid MorleyLogsBuilder
Instance details Defined in Morley.Michelson.Interpret Methods mempty :: MorleyLogsBuilder # mappend :: MorleyLogsBuilder -> MorleyLogsBuilder -> MorleyLogsBuilder # mconcat :: [MorleyLogsBuilder] -> MorleyLogsBuilder #
Monoid Ruleset
Instance details Defined in Morley.Michelson.Optimizer Methods mempty :: Ruleset # mappend :: Ruleset -> Ruleset -> Ruleset # mconcat :: [Ruleset] -> Ruleset #
Monoid MText
Instance details Defined in Morley.Michelson.Text Methods mempty :: MText # mappend :: MText -> MText -> MText # mconcat :: [MText] -> MText #
Monoid AnnotationSet
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods mempty :: AnnotationSet # mappend :: AnnotationSet -> AnnotationSet -> AnnotationSet # mconcat :: [AnnotationSet] -> AnnotationSet #
Monoid VarAnn
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods mempty :: VarAnn # mappend :: VarAnn -> VarAnn -> VarAnn # mconcat :: [VarAnn] -> VarAnn #
Monoid Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods mempty :: Doc # mappend :: Doc -> Doc -> Doc # mconcat :: [Doc] -> Doc #
Monoid ByteArray
Instance details Defined in Data.Primitive.ByteArray Methods mempty :: ByteArray # mappend :: ByteArray -> ByteArray -> ByteArray # mconcat :: [ByteArray] -> ByteArray #
Monoid PromDPatInfos
Instance details Defined in Data.Singletons.TH.Syntax Methods mempty :: PromDPatInfos # mappend :: PromDPatInfos -> PromDPatInfos -> PromDPatInfos # mconcat :: [PromDPatInfos] -> PromDPatInfos #
Monoid ULetDecEnv
Instance details Defined in Data.Singletons.TH.Syntax Methods mempty :: ULetDecEnv # mappend :: ULetDecEnv -> ULetDecEnv -> ULetDecEnv # mconcat :: [ULetDecEnv] -> ULetDecEnv #
Monoid Builder
Instance details Defined in Data.Text.Internal.Builder Methods mempty :: Builder # mappend :: Builder -> Builder -> Builder # mconcat :: [Builder] -> Builder #
Monoid ShortText
Instance details Defined in Data.Text.Short.Internal Methods mempty :: ShortText # mappend :: ShortText -> ShortText -> ShortText # mconcat :: [ShortText] -> ShortText #
Monoid ()	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
() :=> (Monoid Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Monoid Ordering #
() :=> (Monoid ())
Instance details Defined in Data.Constraint Methods ins :: () :- Monoid () #
() :=> (Monoid [a])
Instance details Defined in Data.Constraint Methods ins :: () :- Monoid [a] #
a :=> (Monoid (Dict a))
Instance details Defined in Data.Constraint Methods ins :: a :- Monoid (Dict a) #
Semigroup a => Monoid (Option' a)
Instance details Defined in Distribution.Compat.Semigroup Methods mempty :: Option' a # mappend :: Option' a -> Option' a -> Option' a # mconcat :: [Option' a] -> Option' a #
Monoid (KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods mempty :: KeyMap v # mappend :: KeyMap v -> KeyMap v -> KeyMap v # mconcat :: [KeyMap v] -> KeyMap v #
Monoid (IResult a)
Instance details Defined in Data.Aeson.Types.Internal Methods mempty :: IResult a # mappend :: IResult a -> IResult a -> IResult a # mconcat :: [IResult a] -> IResult a #
Monoid (Parser a)
Instance details Defined in Data.Aeson.Types.Internal Methods mempty :: Parser a # mappend :: Parser a -> Parser a -> Parser a # mconcat :: [Parser a] -> Parser a #
Monoid (Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods mempty :: Result a # mappend :: Result a -> Result a -> Result a # mconcat :: [Result a] -> Result a #
Monoid a => Monoid (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Monoid (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid a => Monoid (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods mempty :: Down a # mappend :: Down a -> Down a -> Down a # mconcat :: [Down a] -> Down a #
(Ord a, Bounded a) => Monoid (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
(Ord a, Bounded a) => Monoid (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
Semigroup a => Monoid (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Monoid m => Monoid (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
Monoid a => Monoid (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Monoid (Endo a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Num a => Monoid (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Num a => Monoid (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Monoid p => Monoid (Par1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Par1 p # mappend :: Par1 p -> Par1 p -> Par1 p # mconcat :: [Par1 p] -> Par1 p #
PrimType ty => Monoid (Block ty)
Instance details Defined in Basement.Block.Base Methods mempty :: Block ty # mappend :: Block ty -> Block ty -> Block ty # mconcat :: [Block ty] -> Block ty #
Monoid (Array a)
Instance details Defined in Basement.BoxedArray Methods mempty :: Array a # mappend :: Array a -> Array a -> Array a # mconcat :: [Array a] -> Array a #
Monoid (CountOf ty)
Instance details Defined in Basement.Types.OffsetSize Methods mempty :: CountOf ty # mappend :: CountOf ty -> CountOf ty -> CountOf ty # mconcat :: [CountOf ty] -> CountOf ty #
PrimType ty => Monoid (UArray ty)
Instance details Defined in Basement.UArray.Base Methods mempty :: UArray ty # mappend :: UArray ty -> UArray ty -> UArray ty # mconcat :: [UArray ty] -> UArray ty #
a => Monoid (Dict a)
Instance details Defined in Data.Constraint Methods mempty :: Dict a # mappend :: Dict a -> Dict a -> Dict a # mconcat :: [Dict a] -> Dict a #
Monoid (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods mempty :: IntMap a # mappend :: IntMap a -> IntMap a -> IntMap a # mconcat :: [IntMap a] -> IntMap a #
Monoid (Seq a)
Instance details Defined in Data.Sequence.Internal Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
Monoid (MergeSet a)
Instance details Defined in Data.Set.Internal Methods mempty :: MergeSet a # mappend :: MergeSet a -> MergeSet a -> MergeSet a # mconcat :: [MergeSet a] -> MergeSet a #
Ord a => Monoid (Set a)
Instance details Defined in Data.Set.Internal Methods mempty :: Set a # mappend :: Set a -> Set a -> Set a # mconcat :: [Set a] -> Set a #
Monoid (DList a)
Instance details Defined in Data.DList.Internal Methods mempty :: DList a # mappend :: DList a -> DList a -> DList a # mconcat :: [DList a] -> DList a #
KnownNat p => Monoid (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods mempty :: Binary p # mappend :: Binary p -> Binary p -> Binary p # mconcat :: [Binary p] -> Binary p #
KnownNat p => Monoid (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods mempty :: Prime p # mappend :: Prime p -> Prime p -> Prime p # mconcat :: [Prime p] -> Prime p #
Monoid a => Monoid (IO a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Monoid a => Monoid (May a)
Instance details Defined in Lens.Micro.Mtl.Internal Methods mempty :: May a # mappend :: May a -> May a -> May a # mconcat :: [May a] -> May a #
Monoid (PrintComment st)
Instance details Defined in Morley.Michelson.Typed.Instr Methods mempty :: PrintComment st # mappend :: PrintComment st -> PrintComment st -> PrintComment st # mconcat :: [PrintComment st] -> PrintComment st #
Monoid (SomeSizedList a)
Instance details Defined in Morley.Util.SizedList Methods mempty :: SomeSizedList a # mappend :: SomeSizedList a -> SomeSizedList a -> SomeSizedList a # mconcat :: [SomeSizedList a] -> SomeSizedList a #
BooleanMonoid a => Monoid (All a)
Instance details Defined in Morley.Prelude.Boolean Methods mempty :: All a # mappend :: All a -> All a -> All a # mconcat :: [All a] -> All a #
BooleanMonoid a => Monoid (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods mempty :: Any a # mappend :: Any a -> Any a -> Any a # mconcat :: [Any a] -> Any a #
Monoid (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods mempty :: Doc a # mappend :: Doc a -> Doc a -> Doc a # mconcat :: [Doc a] -> Doc a #
Monoid (Array a)
Instance details Defined in Data.Primitive.Array Methods mempty :: Array a # mappend :: Array a -> Array a -> Array a # mconcat :: [Array a] -> Array a #
Monoid (PrimArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods mempty :: PrimArray a # mappend :: PrimArray a -> PrimArray a -> PrimArray a # mconcat :: [PrimArray a] -> PrimArray a #
Monoid (SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods mempty :: SmallArray a # mappend :: SmallArray a -> SmallArray a -> SmallArray a # mconcat :: [SmallArray a] -> SmallArray a #
Semiring a => Monoid (Add a)
Instance details Defined in Data.Semiring Methods mempty :: Add a # mappend :: Add a -> Add a -> Add a # mconcat :: [Add a] -> Add a #
Monoid (IntSetOf a)
Instance details Defined in Data.Semiring Methods mempty :: IntSetOf a # mappend :: IntSetOf a -> IntSetOf a -> IntSetOf a # mconcat :: [IntSetOf a] -> IntSetOf a #
Semiring a => Monoid (Mul a)
Instance details Defined in Data.Semiring Methods mempty :: Mul a # mappend :: Mul a -> Mul a -> Mul a # mconcat :: [Mul a] -> Mul a #
Semigroup a => Monoid (Maybe a)
Instance details Defined in Data.Strict.Maybe Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (Q a)	Since: template-haskell-2.17.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods mempty :: Q a # mappend :: Q a -> Q a -> Q a # mconcat :: [Q a] -> Q a #
(Hashable a, Eq a) => Monoid (HashSet a)	`mempty` = `empty` `mappend` = `union` O(n+m) To obtain good performance, the smaller set must be presented as the first argument. Examples Expand `>>>` `mappend (fromList [1,2]) (fromList [2,3])`fromList [1,2,3]
Instance details Defined in Data.HashSet.Internal Methods mempty :: HashSet a # mappend :: HashSet a -> HashSet a -> HashSet a # mconcat :: [HashSet a] -> HashSet a #
Monoid (Vector a)
Instance details Defined in Data.Vector Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
Prim a => Monoid (Vector a)
Instance details Defined in Data.Vector.Primitive Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
Storable a => Monoid (Vector a)
Instance details Defined in Data.Vector.Storable Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
(KnownSymbol s, Monoid t) => Monoid (ElField '(s, t))
Instance details Defined in Data.Vinyl.Functor Methods mempty :: ElField '(s, t) # mappend :: ElField '(s, t) -> ElField '(s, t) -> ElField '(s, t) # mconcat :: [ElField '(s, t)] -> ElField '(s, t) #
Semigroup a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: base-2.1*
Instance details Defined in GHC.Base Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (a)	Since: base-4.15
Instance details Defined in GHC.Base Methods mempty :: (a) # mappend :: (a) -> (a) -> (a) # mconcat :: [(a)] -> (a) #
Monoid [a]	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: [a] # mappend :: [a] -> [a] -> [a] # mconcat :: [[a]] -> [a] #
(Monoid a) :=> (Applicative (Const a :: Type -> Type))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Applicative (Const a) #
(Monoid a) :=> (Applicative ((,) a))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Applicative ((,) a) #
(Monoid a) :=> (Monoid (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Monoid (Const a b) #
(Monoid a) :=> (Monoid (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Monoid (Identity a) #
(Monoid a) :=> (Monoid (IO a))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Monoid (IO a) #
(Monoid a) :=> (Monoid (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Monoid (Maybe a) #
Class (Semigroup a) (Monoid a)
Instance details Defined in Data.Constraint Methods cls :: Monoid a :- Semigroup a #
Monoid (Parser i a)
Instance details Defined in Data.Attoparsec.Internal.Types Methods mempty :: Parser i a # mappend :: Parser i a -> Parser i a -> Parser i a # mconcat :: [Parser i a] -> Parser i a #
Monoid (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods mempty :: Proxy s # mappend :: Proxy s -> Proxy s -> Proxy s # mconcat :: [Proxy s] -> Proxy s #
Monoid (U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: U1 p # mappend :: U1 p -> U1 p -> U1 p # mconcat :: [U1 p] -> U1 p #
Monoid a => Monoid (ST s a)	Since: base-4.11.0.0
Instance details Defined in GHC.ST Methods mempty :: ST s a # mappend :: ST s a -> ST s a -> ST s a # mconcat :: [ST s a] -> ST s a #
Ord k => Monoid (Map k v)
Instance details Defined in Data.Map.Internal Methods mempty :: Map k v # mappend :: Map k v -> Map k v -> Map k v # mconcat :: [Map k v] -> Map k v #
IrreducibleMonic p k => Monoid (Extension p k)
Instance details Defined in Data.Field.Galois.Extension Methods mempty :: Extension p k # mappend :: Extension p k -> Extension p k -> Extension p k # mconcat :: [Extension p k] -> Extension p k #
(KnownNat n, GaloisField k) => Monoid (RootsOfUnity n k)
Instance details Defined in Data.Field.Galois.Unity Methods mempty :: RootsOfUnity n k # mappend :: RootsOfUnity n k -> RootsOfUnity n k -> RootsOfUnity n k # mconcat :: [RootsOfUnity n k] -> RootsOfUnity n k #
Monoid (f a) => Monoid (Indexing f a)	`>>>` `"cat" ^@.. (folded <> folded)`[(0,'c'),(1,'a'),(2,'t'),(0,'c'),(1,'a'),(2,'t')] `>>>` `"cat" ^@.. indexing (folded <> folded)`[(0,'c'),(1,'a'),(2,'t'),(3,'c'),(4,'a'),(5,'t')]
Instance details Defined in Control.Lens.Internal.Indexed Methods mempty :: Indexing f a # mappend :: Indexing f a -> Indexing f a -> Indexing f a # mconcat :: [Indexing f a] -> Indexing f a #
Monoid (ReifiedFold s a)
Instance details Defined in Control.Lens.Reified Methods mempty :: ReifiedFold s a # mappend :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a # mconcat :: [ReifiedFold s a] -> ReifiedFold s a #
Monoid (s :-> s)
Instance details Defined in Lorentz.Base Methods mempty :: s :-> s # mappend :: (s :-> s) -> (s :-> s) -> s :-> s # mconcat :: [s :-> s] -> s :-> s #
(Stream s, Ord e) => Monoid (ParseError s e)
Instance details Defined in Text.Megaparsec.Error Methods mempty :: ParseError s e # mappend :: ParseError s e -> ParseError s e -> ParseError s e # mconcat :: [ParseError s e] -> ParseError s e #
Monoid a => Monoid (Err e a)
Instance details Defined in Lens.Micro.Mtl.Internal Methods mempty :: Err e a # mappend :: Err e a -> Err e a -> Err e a # mconcat :: [Err e a] -> Err e a #
Monoid (Instr s s)
Instance details Defined in Morley.Michelson.Typed.Instr Methods mempty :: Instr s s # mappend :: Instr s s -> Instr s s -> Instr s s # mconcat :: [Instr s s] -> Instr s s #
Monoid (IntMapOf k v)
Instance details Defined in Data.Semiring Methods mempty :: IntMapOf k v # mappend :: IntMapOf k v -> IntMapOf k v -> IntMapOf k v # mconcat :: [IntMapOf k v] -> IntMapOf k v #
(Monoid a, Monoid b) => Monoid (Pair a b)
Instance details Defined in Data.Strict.Tuple Methods mempty :: Pair a b # mappend :: Pair a b -> Pair a b -> Pair a b # mconcat :: [Pair a b] -> Pair a b #
(Eq k, Hashable k) => Monoid (HashMap k v)	`mempty` = `empty` `mappend` = `union` If a key occurs in both maps, the mapping from the first will be the mapping in the result. Examples Expand `>>>` `mappend (fromList [(1,'a'),(2,'b')]) (fromList [(2,'c'),(3,'d')])`fromList [(1,'a'),(2,'b'),(3,'d')]
Instance details Defined in Data.HashMap.Internal Methods mempty :: HashMap k v # mappend :: HashMap k v -> HashMap k v -> HashMap k v # mconcat :: [HashMap k v] -> HashMap k v #
Monoid b => Monoid (a -> b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
(Monoid a, Monoid b) => Monoid (a, b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
(Monoid a, Monoid b) :=> (Monoid (a, b))
Instance details Defined in Data.Constraint Methods ins :: (Monoid a, Monoid b) :- Monoid (a, b) #
Monoid a => Monoid (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods mempty :: Const a b # mappend :: Const a b -> Const a b -> Const a b # mconcat :: [Const a b] -> Const a b #
(Applicative f, Monoid a) => Monoid (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mempty :: Ap f a # mappend :: Ap f a -> Ap f a -> Ap f a # mconcat :: [Ap f a] -> Ap f a #
Alternative f => Monoid (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Alt f a # mappend :: Alt f a -> Alt f a -> Alt f a # mconcat :: [Alt f a] -> Alt f a #
Monoid (f p) => Monoid (Rec1 f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Rec1 f p # mappend :: Rec1 f p -> Rec1 f p -> Rec1 f p # mconcat :: [Rec1 f p] -> Rec1 f p #
Monoid (ReifiedIndexedFold i s a)
Instance details Defined in Control.Lens.Reified Methods mempty :: ReifiedIndexedFold i s a # mappend :: ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a # mconcat :: [ReifiedIndexedFold i s a] -> ReifiedIndexedFold i s a #
(Monad m, Monoid r) => Monoid (Effect m r a)
Instance details Defined in Lens.Micro.Mtl.Internal Methods mempty :: Effect m r a # mappend :: Effect m r a -> Effect m r a -> Effect m r a # mconcat :: [Effect m r a] -> Effect m r a #
Reifies s (ReifiedMonoid a) => Monoid (ReflectedMonoid a s)
Instance details Defined in Data.Reflection Methods mempty :: ReflectedMonoid a s # mappend :: ReflectedMonoid a s -> ReflectedMonoid a s -> ReflectedMonoid a s # mconcat :: [ReflectedMonoid a s] -> ReflectedMonoid a s #
(Semigroup a, Monoid a) => Monoid (Tagged s a)
Instance details Defined in Data.Tagged Methods mempty :: Tagged s a # mappend :: Tagged s a -> Tagged s a -> Tagged s a # mconcat :: [Tagged s a] -> Tagged s a #
(Monoid (f r), Monoid (Rec f rs)) => Monoid (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Methods mempty :: Rec f (r ': rs) # mappend :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) # mconcat :: [Rec f (r ': rs)] -> Rec f (r ': rs) #
Monoid (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Methods mempty :: Rec f '[] # mappend :: Rec f '[] -> Rec f '[] -> Rec f '[] # mconcat :: [Rec f '[]] -> Rec f '[] #
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b, c) # mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) # mconcat :: [(a, b, c)] -> (a, b, c) #
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: (f :: g) p # mappend :: (f :: g) p -> (f :: g) p -> (f :: g) p # mconcat :: [(f :: g) p] -> (f :: g) p #
Monoid c => Monoid (K1 i c p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: K1 i c p # mappend :: K1 i c p -> K1 i c p -> K1 i c p # mconcat :: [K1 i c p] -> K1 i c p #
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b, c, d) # mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # mconcat :: [(a, b, c, d)] -> (a, b, c, d) #
Monoid (f (g p)) => Monoid ((f :.: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: (f :.: g) p # mappend :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # mconcat :: [(f :.: g) p] -> (f :.: g) p #
Monoid (f p) => Monoid (M1 i c f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: M1 i c f p # mappend :: M1 i c f p -> M1 i c f p -> M1 i c f p # mconcat :: [M1 i c f p] -> M1 i c f p #
Monoid (f (g a)) => Monoid (Compose f g a)
Instance details Defined in Data.Vinyl.Functor Methods mempty :: Compose f g a # mappend :: Compose f g a -> Compose f g a -> Compose f g a # mconcat :: [Compose f g a] -> Compose f g a #
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b, c, d, e) # mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) #
Curve f c e q r => Monoid (Point f c e q r)
Instance details Defined in Data.Curve Methods mempty :: Point f c e q r # mappend :: Point f c e q r -> Point f c e q r -> Point f c e q r # mconcat :: [Point f c e q r] -> Point f c e q r #

data Bool #

Constructors

False
True

Instances

Instances details

Structured Bool
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Bool -> Structure # structureHash' :: Tagged Bool MD5
Bits Bool	Interpret `Bool` as 1-bit bit-field Since: base-4.7.0.0
Instance details Defined in Data.Bits Methods (.&.) :: Bool -> Bool -> Bool # (.\|.) :: Bool -> Bool -> Bool # xor :: Bool -> Bool -> Bool # complement :: Bool -> Bool # shift :: Bool -> Int -> Bool # rotate :: Bool -> Int -> Bool # zeroBits :: Bool # bit :: Int -> Bool # setBit :: Bool -> Int -> Bool # clearBit :: Bool -> Int -> Bool # complementBit :: Bool -> Int -> Bool # testBit :: Bool -> Int -> Bool # bitSizeMaybe :: Bool -> Maybe Int # bitSize :: Bool -> Int # isSigned :: Bool -> Bool # shiftL :: Bool -> Int -> Bool # unsafeShiftL :: Bool -> Int -> Bool # shiftR :: Bool -> Int -> Bool # unsafeShiftR :: Bool -> Int -> Bool # rotateL :: Bool -> Int -> Bool # rotateR :: Bool -> Int -> Bool # popCount :: Bool -> Int #
FiniteBits Bool	Since: base-4.7.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Bool -> Int # countLeadingZeros :: Bool -> Int # countTrailingZeros :: Bool -> Int #
Storable Bool	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Bool -> Int # alignment :: Bool -> Int # peekElemOff :: Ptr Bool -> Int -> IO Bool # pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () # peekByteOff :: Ptr b -> Int -> IO Bool # pokeByteOff :: Ptr b -> Int -> Bool -> IO () # peek :: Ptr Bool -> IO Bool # poke :: Ptr Bool -> Bool -> IO () #
Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool # maxBound :: Bool #
Enum Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Bool -> Bool # pred :: Bool -> Bool # toEnum :: Int -> Bool # fromEnum :: Bool -> Int # enumFrom :: Bool -> [Bool] # enumFromThen :: Bool -> Bool -> [Bool] # enumFromTo :: Bool -> Bool -> [Bool] # enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #
Generic Bool
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
SingKind Bool	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep Bool Methods fromSing :: forall (a :: Bool). Sing a -> DemoteRep Bool
Read Bool	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Bool # readList :: ReadS [Bool] # readPrec :: ReadPrec Bool # readListPrec :: ReadPrec [Bool] #
Show Bool	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
BitOps Bool
Instance details Defined in Basement.Bits Methods (.&.) :: Bool -> Bool -> Bool # (.\|.) :: Bool -> Bool -> Bool # (.^.) :: Bool -> Bool -> Bool # (.<<.) :: Bool -> CountOf Bool -> Bool # (.>>.) :: Bool -> CountOf Bool -> Bool # bit :: Offset Bool -> Bool # isBitSet :: Bool -> Offset Bool -> Bool # setBit :: Bool -> Offset Bool -> Bool # clearBit :: Bool -> Offset Bool -> Bool #
FiniteBitsOps Bool
Instance details Defined in Basement.Bits Methods numberOfBits :: Bool -> CountOf Bool # rotateL :: Bool -> CountOf Bool -> Bool # rotateR :: Bool -> CountOf Bool -> Bool # popCount :: Bool -> CountOf Bool # bitFlip :: Bool -> Bool # countLeadingZeros :: Bool -> CountOf Bool # countTrailingZeros :: Bool -> CountOf Bool #
NFData Bool
Instance details Defined in Control.DeepSeq Methods rnf :: Bool -> () #
Buildable Bool
Instance details Defined in Formatting.Buildable Methods build :: Bool -> Builder #
Eq Bool
Instance details Defined in GHC.Classes Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Ord Bool
Instance details Defined in GHC.Classes Methods compare :: Bool -> Bool -> Ordering # (<) :: Bool -> Bool -> Bool # (<=) :: Bool -> Bool -> Bool # (>) :: Bool -> Bool -> Bool # (>=) :: Bool -> Bool -> Bool # max :: Bool -> Bool -> Bool # min :: Bool -> Bool -> Bool #
Hashable Bool
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Bool -> Int # hash :: Bool -> Int #
HasAnnotation Bool
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Bool) # annOptions :: Maybe AnnOptions #
HasRPCRepr Bool
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Bool #
TypeHasDoc Bool
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Bool :: FieldDescriptions # Methods typeDocName :: Proxy Bool -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Bool -> WithinParens -> Markdown # typeDocDependencies :: Proxy Bool -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Bool # typeDocMichelsonRep :: TypeDocMichelsonRep Bool #
IsoValue Bool
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bool :: T # Methods toVal :: Bool -> Value (ToT Bool) # fromVal :: Value (ToT Bool) -> Bool #
Boolean Bool
Instance details Defined in Morley.Prelude.Boolean Methods (&&) :: Bool -> Bool -> Bool # (\|\|) :: Bool -> Bool -> Bool # not :: Bool -> Bool #
BooleanMonoid Bool
Instance details Defined in Morley.Prelude.Boolean Methods false :: Bool # true :: Bool #
Uniform Bool
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Bool #
UniformRange Bool
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Bool, Bool) -> g -> m Bool #
Semiring Bool
Instance details Defined in Data.Semiring Methods plus :: Bool -> Bool -> Bool # zero :: Bool # times :: Bool -> Bool -> Bool # one :: Bool # fromNatural :: Natural -> Bool #
PEq Bool
Instance details Defined in Data.Eq.Singletons Associated Types type arg == arg1 :: Bool # type arg /= arg1 :: Bool #
SEq Bool
Instance details Defined in Data.Eq.Singletons Methods (%==) :: forall (t1 :: Bool) (t2 :: Bool). Sing t1 -> Sing t2 -> Sing (Apply (Apply (==@#@$) t1) t2) # (%/=) :: forall (t1 :: Bool) (t2 :: Bool). Sing t1 -> Sing t2 -> Sing (Apply (Apply (/=@#@$) t1) t2) #
POrd Bool
Instance details Defined in Data.Ord.Singletons Associated Types type Compare arg arg1 :: Ordering # type arg < arg1 :: Bool # type arg <= arg1 :: Bool # type arg > arg1 :: Bool # type arg >= arg1 :: Bool # type Max arg arg1 :: a # type Min arg arg1 :: a #
SOrd Bool
Instance details Defined in Data.Ord.Singletons Methods sCompare :: forall (t1 :: Bool) (t2 :: Bool). Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2) # (%<) :: forall (t1 :: Bool) (t2 :: Bool). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) # (%<=) :: forall (t1 :: Bool) (t2 :: Bool). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2) # (%>) :: forall (t1 :: Bool) (t2 :: Bool). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%>=) :: forall (t1 :: Bool) (t2 :: Bool). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2) # sMax :: forall (t1 :: Bool) (t2 :: Bool). Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2) # sMin :: forall (t1 :: Bool) (t2 :: Bool). Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2) #
PBounded Bool
Instance details Defined in Data.Singletons.Base.Enum Associated Types type MinBound :: a # type MaxBound :: a #
PEnum Bool
Instance details Defined in Data.Singletons.Base.Enum Associated Types type Succ arg :: a # type Pred arg :: a # type ToEnum arg :: a # type FromEnum arg :: Nat # type EnumFromTo arg arg1 :: [a] # type EnumFromThenTo arg arg1 arg2 :: [a] #
SBounded Bool
Instance details Defined in Data.Singletons.Base.Enum Methods sMinBound :: Sing MinBoundSym0 # sMaxBound :: Sing MaxBoundSym0 #
SEnum Bool
Instance details Defined in Data.Singletons.Base.Enum Methods sSucc :: forall (t :: Bool). Sing t -> Sing (Apply SuccSym0 t) # sPred :: forall (t :: Bool). Sing t -> Sing (Apply PredSym0 t) # sToEnum :: forall (t :: Nat). Sing t -> Sing (Apply ToEnumSym0 t) # sFromEnum :: forall (t :: Bool). Sing t -> Sing (Apply FromEnumSym0 t) # sEnumFromTo :: forall (t1 :: Bool) (t2 :: Bool). Sing t1 -> Sing t2 -> Sing (Apply (Apply EnumFromToSym0 t1) t2) # sEnumFromThenTo :: forall (t1 :: Bool) (t2 :: Bool) (t3 :: Bool). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply EnumFromThenToSym0 t1) t2) t3) #
PShow Bool
Instance details Defined in Text.Show.Singletons Associated Types type ShowsPrec arg arg1 arg2 :: Symbol # type Show_ arg :: Symbol # type ShowList arg arg1 :: Symbol #
SShow Bool
Instance details Defined in Text.Show.Singletons Methods sShowsPrec :: forall (t1 :: Nat) (t2 :: Bool) (t3 :: Symbol). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3) # sShow_ :: forall (t :: Bool). Sing t -> Sing (Apply Show_Sym0 t) # sShowList :: forall (t1 :: [Bool]) (t2 :: Symbol). Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2) #
Unbox Bool
Instance details Defined in Data.Vector.Unboxed.Base
TestCoercion SBool
Instance details Defined in Data.Singletons.Base.Instances Methods testCoercion :: forall (a :: k) (b :: k). SBool a -> SBool b -> Maybe (Coercion a b) #
TestEquality SBool
Instance details Defined in Data.Singletons.Base.Instances Methods testEquality :: forall (a :: k) (b :: k). SBool a -> SBool b -> Maybe (a :~: b) #
SingI 'False	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing 'False
SingI 'True	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing 'True
UnaryArithOpHs Not Bool
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Not Bool # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Bool ': s) :-> (UnaryArithResHs Not Bool ': s) #
Lift Bool
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Bool -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Bool -> Code m Bool #
Vector Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool) # basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool) # basicLength :: Vector Bool -> Int # basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool # basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m () # elemseq :: Vector Bool -> Bool -> b -> b #
MVector MVector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Bool -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool # basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool) # basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool) #
r ~ Bool => ArithOpHs And Bool Bool r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bool ': (Bool ': s)) :-> (r ': s) #
r ~ Bool => ArithOpHs Or Bool Bool r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bool ': (Bool ': s)) :-> (r ': s) #
r ~ Bool => ArithOpHs Xor Bool Bool r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bool ': (Bool ': s)) :-> (r ': s) #
() :=> (Bits Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Bits Bool #
() :=> (Bounded Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Bool #
() :=> (Enum Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Bool #
() :=> (Read Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Bool #
() :=> (Show Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Bool #
() :=> (Eq Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Bool #
() :=> (Ord Bool)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Bool #
SingI GetAllSym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetAllSym0 #
SingI GetAnySym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetAnySym0 #
SingI AllSym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing AllSym0 #
SingI All_Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods sing :: Sing All_Sym0 #
SingI AnySym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing AnySym0 #
SingI Any_Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods sing :: Sing Any_Sym0 #
SingI ShowParenSym0
Instance details Defined in Text.Show.Singletons Methods sing :: Sing ShowParenSym0 #
SingI AndSym0
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing AndSym0 #
SingI OrSym0
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing OrSym0 #
SingI ContainsBigMapSym
Instance details Defined in Morley.Michelson.Typed.Scope Methods sing :: Sing ContainsBigMapSym #
SingI ContainsContractSym
Instance details Defined in Morley.Michelson.Typed.Scope Methods sing :: Sing ContainsContractSym #
SingI ContainsNestedBigMapsSym
Instance details Defined in Morley.Michelson.Typed.Scope Methods sing :: Sing ContainsNestedBigMapsSym #
SingI ContainsOpSym
Instance details Defined in Morley.Michelson.Typed.Scope Methods sing :: Sing ContainsOpSym #
SingI ContainsTicketSym
Instance details Defined in Morley.Michelson.Typed.Scope Methods sing :: Sing ContainsTicketSym #
SingI (&&@#@$)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing (&&@#@$) #
SingI (\|\|@#@$)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing (\|\|@#@$) #
SingI NotSym0
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing NotSym0 #
SingI (<=?@#@$)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods sing :: Sing (<=?@#@$) #
SuppressUnusedWarnings TFHelper_6989586621679606123Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings GetAllSym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings TFHelper_6989586621679606140Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings GetAnySym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings TFHelper_6989586621679130639Sym0
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings TFHelper_6989586621679131028Sym0
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings TFHelper_6989586621679131037Sym0
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings AllSym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings All_Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings AnySym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings Any_Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ShowParenSym0
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings Compare_6989586621679181840Sym0
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (&&@#@$)
Instance details Defined in Data.Bool.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (\|\|@#@$)
Instance details Defined in Data.Bool.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings TFHelper_6989586621679131019Sym0
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings NotSym0
Instance details Defined in Data.Bool.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings FromEnum_6989586621679544301Sym0
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ShowsPrec_6989586621680071834Sym0
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (<=?@#@$)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ToEnum_6989586621679544288Sym0
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings AndSym0
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings OrSym0
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SingI (DeleteFirstsBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing DeleteFirstsBySym0 #
SingI (IntersectBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IntersectBySym0 #
SingI (UnionBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing UnionBySym0 #
SingI (GroupBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [[a]]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing GroupBySym0 #
SingI (NubBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing NubBySym0 #
SingI (ListnubBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListnubBySym0 #
SingI (Elem_bySym0 :: TyFun (a ~> (a ~> Bool)) (a ~> ([a] ~> Bool)) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing Elem_bySym0 #
SingI (DeleteBySym0 :: TyFun (a ~> (a ~> Bool)) (a ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing DeleteBySym0 #
SingI (UntilSym0 :: TyFun (a ~> Bool) ((a ~> a) ~> (a ~> a)) -> Type)
Instance details Defined in GHC.Base.Singletons Methods sing :: Sing UntilSym0 #
SingI (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing FindIndexSym0 #
SingI (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing FindSym0 #
SingI (BreakSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing BreakSym0 #
SingI (PartitionSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing PartitionSym0 #
SingI (SpanSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing SpanSym0 #
SingI (ListpartitionSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListpartitionSym0 #
SingI (ListspanSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListspanSym0 #
SingI (AllSym0 :: TyFun (a ~> Bool) ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing AllSym0 #
SingI (AnySym0 :: TyFun (a ~> Bool) ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing AnySym0 #
SingI (FindIndicesSym0 :: TyFun (a ~> Bool) ([a] ~> [Nat]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing FindIndicesSym0 #
SingI (DropWhileEndSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing DropWhileEndSym0 #
SingI (DropWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing DropWhileSym0 #
SingI (FilterSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing FilterSym0 #
SingI (TakeWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing TakeWhileSym0 #
SingI (ListdropWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListdropWhileSym0 #
SingI (ListfilterSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListfilterSym0 #
SingI (ListtakeWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListtakeWhileSym0 #
SingI (SelectSym0 :: TyFun (a ~> Bool) (a ~> (([a], [a]) ~> ([a], [a]))) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing SelectSym0 #
SingI (IsJustSym0 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing IsJustSym0 #
SingI (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing IsNothingSym0 #
SApplicative f => SingI (UnlessSym0 :: TyFun Bool (f () ~> f ()) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing UnlessSym0 #
SApplicative f => SingI (WhenSym0 :: TyFun Bool (f () ~> f ()) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing WhenSym0 #
SAlternative f => SingI (GuardSym0 :: TyFun Bool (f ()) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods sing :: Sing GuardSym0 #
SEq a => SingI (IsInfixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IsInfixOfSym0 #
SEq a => SingI (IsPrefixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IsPrefixOfSym0 #
SEq a => SingI (IsSuffixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing IsSuffixOfSym0 #
SEq a => SingI (ListisPrefixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListisPrefixOfSym0 #
SingI (NullSym0 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing NullSym0 #
SingI (ListnullSym0 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListnullSym0 #
SEq a => SingI (ElemSym0 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ElemSym0 #
SEq a => SingI (NotElemSym0 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing NotElemSym0 #
SEq a => SingI (ListelemSym0 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListelemSym0 #
SingI (Bool_Sym0 :: TyFun a (a ~> (Bool ~> a)) -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing Bool_Sym0 #
SEq a => SingI ((/=@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods sing :: Sing (/=@#@$) #
SEq a => SingI ((==@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods sing :: Sing (==@#@$) #
SOrd a => SingI ((<=@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (<=@#@$) #
SOrd a => SingI ((<@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (<@#@$) #
SOrd a => SingI ((>=@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (>=@#@$) #
SOrd a => SingI ((>@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (>@#@$) #
SFoldable t => SingI (AndSym0 :: TyFun (t Bool) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing AndSym0 #
SFoldable t => SingI (OrSym0 :: TyFun (t Bool) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing OrSym0 #
SingI (IfSym0 :: TyFun Bool (k ~> (k ~> k)) -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing IfSym0 #
SingI x => SingI ((&&@#@$$) x :: TyFun Bool Bool -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing ((&&@#@$$) x) #
SingI x => SingI ((\|\|@#@$$) x :: TyFun Bool Bool -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing ((\|\|@#@$$) x) #
SingI x => SingI ((<=?@#@$$) x :: TyFun Nat Bool -> Type)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods sing :: Sing ((<=?@#@$$) x) #
SuppressUnusedWarnings (TFHelper_6989586621679131006Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680392273Sym0 :: TyFun (Identity a) Bool -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680109664Sym0 :: TyFun (First a) (First a ~> Bool) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680109684Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679179231Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606240Sym0 :: TyFun (First a) (First a ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606260Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606220Sym0 :: TyFun (Max a) (Max a ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606200Sym0 :: TyFun (Min a) (Min a ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606280Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606123Sym1 a6989586621679606128 :: TyFun All Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606140Sym1 a6989586621679606145 :: TyFun Any Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606106Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680194400Sym0 :: TyFun (Dual a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606180Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680194750Sym0 :: TyFun (Product a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606160Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680194575Sym0 :: TyFun (Sum a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130639Sym1 a6989586621679130644 :: TyFun Void Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130622Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679131028Sym1 a6989586621679131033 :: TyFun Ordering Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (DeleteFirstsBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IntersectBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (UnionBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GroupBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [[a]]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (NubBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListnubBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_bySym0 :: TyFun (a ~> (a ~> Bool)) (a ~> ([a] ~> Bool)) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (DeleteBySym0 :: TyFun (a ~> (a ~> Bool)) (a ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (UntilSym0 :: TyFun (a ~> Bool) ((a ~> a) ~> (a ~> a)) -> Type)
Instance details Defined in GHC.Base.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (BreakSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (PartitionSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (SpanSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListpartitionSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListspanSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (AllSym0 :: TyFun (a ~> Bool) ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (AnySym0 :: TyFun (a ~> Bool) ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FindIndicesSym0 :: TyFun (a ~> Bool) ([a] ~> [Nat]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (DropWhileEndSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (DropWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FilterSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TakeWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListdropWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListfilterSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListtakeWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (SelectSym0 :: TyFun (a ~> Bool) (a ~> (([a], [a]) ~> ([a], [a]))) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731296X_6989586621679731297Sym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] ([k], [k]) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731331X_6989586621679731332Sym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] ([k], [k]) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731296YsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731296ZsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731331YsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731331ZsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130516Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsJustSym0 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679131037Sym1 a6989586621679131042 :: TyFun () Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181840Sym1 a6989586621679181845 :: TyFun Bool Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680071834Sym1 a6989586621680071844 :: TyFun Bool (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (UnlessSym0 :: TyFun Bool (f () ~> f ()) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (WhenSym0 :: TyFun Bool (f () ~> f ()) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IfSym0 :: TyFun Bool (k ~> (k ~> k)) -> Type)
Instance details Defined in Data.Bool.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((&&@#@$$) a6989586621679122836 :: TyFun Bool Bool -> Type)
Instance details Defined in Data.Bool.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((\|\|@#@$$) a6989586621679123482 :: TyFun Bool Bool -> Type)
Instance details Defined in Data.Bool.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679131019Sym1 a6989586621679131024 :: TyFun Bool Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GuardSym0 :: TyFun Bool (f ()) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((<=?@#@$$) a6989586621679462422 :: TyFun Nat Bool -> Type)
Instance details Defined in GHC.TypeLits.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130547Sym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsInfixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsPrefixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsSuffixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListisPrefixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680193994Sym0 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (NullSym0 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListnullSym0 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680392157Sym0 :: TyFun a (Identity a ~> Bool) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194236Sym0 :: TyFun a (Proxy a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194268Sym0 :: TyFun a (Dual a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194618Sym0 :: TyFun a (Product a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194443Sym0 :: TyFun a (Sum a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680193860Sym0 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ElemSym0 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (NotElemSym0 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListelemSym0 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Bool_Sym0 :: TyFun a (a ~> (Bool ~> a)) -> Type)
Instance details Defined in Data.Bool.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((/=@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((==@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679127817Sym0 :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679127828Sym0 :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((<=@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((<@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((>=@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((>@#@$) :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679166153Sym0 :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679166169Sym0 :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679166185Sym0 :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679166201Sym0 :: TyFun a (a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (DefaultEqSym0 :: TyFun k (k ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184051Scrutinee_6989586621680184015Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184075Scrutinee_6989586621680184017Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166141Scrutinee_6989586621679163721Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166145Scrutinee_6989586621679163723Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166226Scrutinee_6989586621679163733Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166242Scrutinee_6989586621679163735Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680163560Scrutinee_6989586621680162757Sym0 :: TyFun k1 Bool -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (AndSym0 :: TyFun (t Bool) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (OrSym0 :: TyFun (t Bool) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SingI (IsLeftSym0 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing IsLeftSym0 #
SingI (IsRightSym0 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing IsRightSym0 #
SMonadPlus m => SingI (MfilterSym0 :: TyFun (a ~> Bool) (m a ~> m a) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing MfilterSym0 #
SFoldable t => SingI (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing FindSym0 #
SFoldable t => SingI (AllSym0 :: TyFun (a ~> Bool) (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing AllSym0 #
SFoldable t => SingI (AnySym0 :: TyFun (a ~> Bool) (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing AnySym0 #
SApplicative m => SingI (FilterMSym0 :: TyFun (a ~> m Bool) ([a] ~> m [a]) -> Type)
Instance details Defined in Control.Monad.Singletons Methods sing :: Sing FilterMSym0 #
SingI d => SingI (AllSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (AllSym1 d) #
SingI d => SingI (AnySym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (AnySym1 d) #
(SEq a, SingI d) => SingI (ElemSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ElemSym1 d) #
(SEq a, SingI d) => SingI (IsInfixOfSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IsInfixOfSym1 d) #
(SEq a, SingI d) => SingI (IsPrefixOfSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IsPrefixOfSym1 d) #
(SEq a, SingI d) => SingI (IsSuffixOfSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (IsSuffixOfSym1 d) #
(SEq a, SingI d) => SingI (NotElemSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (NotElemSym1 d) #
(SEq a, SingI d) => SingI (ListelemSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListelemSym1 d) #
(SEq a, SingI d) => SingI (ListisPrefixOfSym1 d :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing (ListisPrefixOfSym1 d) #
SingI d => SingI (Bool_Sym1 d :: TyFun a (Bool ~> a) -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing (Bool_Sym1 d) #
SingI d => SingI (Elem_bySym1 d :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Elem_bySym1 d) #
(SFoldable t, SEq a) => SingI (ElemSym0 :: TyFun a (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing ElemSym0 #
(SFoldable t, SEq a) => SingI (NotElemSym0 :: TyFun a (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing NotElemSym0 #
(SEq a, SingI d) => SingI ((/=@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods sing :: Sing ((/=@#@$$) d) #
(SEq a, SingI d) => SingI ((==@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods sing :: Sing ((==@#@$$) d) #
(SOrd a, SingI d) => SingI ((<=@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ((<=@#@$$) d) #
(SOrd a, SingI d) => SingI ((<@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ((<@#@$$) d) #
(SOrd a, SingI d) => SingI ((>=@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ((>=@#@$$) d) #
(SOrd a, SingI d) => SingI ((>@#@$$) d :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ((>@#@$$) d) #
SuppressUnusedWarnings (TFHelper_6989586621679130594Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsLeftSym0 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Either.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsRightSym0 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Either.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680194155Sym0 :: TyFun (Either a1 a2) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679131006Sym1 a6989586621679131011 :: TyFun (Identity a) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680392157Sym1 a6989586621680392162 :: TyFun (Identity a) Bool -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680109664Sym1 a6989586621680109669 :: TyFun (First a) Bool -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680109684Sym1 a6989586621680109689 :: TyFun (Last a) Bool -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679179231Sym1 a6989586621679179236 :: TyFun (Down a) Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194236Sym1 a6989586621680194241 :: TyFun (Proxy a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680194229Sym0 :: TyFun (Proxy a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680163384Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680605296Sym0 :: TyFun (Arg a b) (Arg a b ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606240Sym1 a6989586621679606245 :: TyFun (First a) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606260Sym1 a6989586621679606265 :: TyFun (Last a) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606220Sym1 a6989586621679606225 :: TyFun (Max a) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606200Sym1 a6989586621679606205 :: TyFun (Min a) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606280Sym1 a6989586621679606285 :: TyFun (WrappedMonoid m) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194268Sym1 a6989586621680194277 :: TyFun (Dual a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606106Sym1 a6989586621679606111 :: TyFun (Dual a) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194618Sym1 a6989586621680194627 :: TyFun (Product a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606180Sym1 a6989586621679606185 :: TyFun (Product a) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194443Sym1 a6989586621680194452 :: TyFun (Sum a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606160Sym1 a6989586621679606165 :: TyFun (Sum a) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130622Sym1 a6989586621679130627 :: TyFun (NonEmpty a) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MfilterSym0 :: TyFun (a ~> Bool) (m a ~> m a) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (AllSym0 :: TyFun (a ~> Bool) (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (AnySym0 :: TyFun (a ~> Bool) (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680193283Sym0 :: TyFun (a ~> Bool) (TyFun k (TyFun a (First a) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621679731359Sym0 :: TyFun (a ~> Bool) (TyFun k (TyFun a (TyFun [a] [a] -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FilterMSym0 :: TyFun (a ~> m Bool) ([a] ~> m [a]) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731198X_6989586621679731199Sym0 :: TyFun (k1 ~> (a ~> Bool)) (TyFun k1 (TyFun [a] ([a], [a]) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731198YsSym0 :: TyFun (k1 ~> (a ~> Bool)) (TyFun k1 (TyFun [a] [a] -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731198ZsSym0 :: TyFun (k1 ~> (a ~> Bool)) (TyFun k1 (TyFun [a] [a] -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731064NubBy'Sym0 :: TyFun (k1 ~> (k1 ~> Bool)) (TyFun k (TyFun [k1] ([k1] ~> [k1]) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679248372GoSym0 :: TyFun (k1 ~> Bool) (TyFun (k1 ~> k1) (TyFun k2 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type)
Instance details Defined in GHC.Base.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130516Sym1 a6989586621679130521 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130662Sym0 :: TyFun (a, b) ((a, b) ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130547Sym1 a6989586621679130552 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680193860Sym1 a6989586621680193869 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (AllSym1 a6989586621679732047 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (AnySym1 a6989586621679732039 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ElemSym1 a6989586621679731822 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsInfixOfSym1 a6989586621679731830 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsPrefixOfSym1 a6989586621679731844 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsSuffixOfSym1 a6989586621679731837 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (NotElemSym1 a6989586621679731814 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListelemSym1 a6989586621680002068 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListisPrefixOfSym1 a6989586621680002140 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Bool_Sym1 a6989586621679120954 :: TyFun a (Bool ~> a) -> Type)
Instance details Defined in Data.Bool.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_bySym1 a6989586621679731050 :: TyFun a ([a] ~> Bool) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ElemSym0 :: TyFun a (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680193750Sym0 :: TyFun a (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (NotElemSym0 :: TyFun a (t a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((/=@#@$$) a6989586621679127813 :: TyFun a Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((==@#@$$) a6989586621679127808 :: TyFun a Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679127817Sym1 a6989586621679127822 :: TyFun a Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679127828Sym1 a6989586621679127833 :: TyFun a Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((<=@#@$$) a6989586621679166108 :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((<@#@$$) a6989586621679166103 :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((>=@#@$$) a6989586621679166118 :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((>@#@$$) a6989586621679166113 :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679166153Sym1 a6989586621679166158 :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679166169Sym1 a6989586621679166174 :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679166185Sym1 a6989586621679166190 :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679166201Sym1 a6989586621679166206 :: TyFun a Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (DefaultEqSym1 a6989586621679130155 :: TyFun k Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731119Scrutinee_6989586621679727564Sym0 :: TyFun k1 (TyFun k Bool -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184051Scrutinee_6989586621680184015Sym1 x6989586621680184046 :: TyFun k1 Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184075Scrutinee_6989586621680184017Sym1 x6989586621680184070 :: TyFun k1 Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166141Scrutinee_6989586621679163721Sym1 x6989586621679166139 :: TyFun k1 Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166145Scrutinee_6989586621679163723Sym1 x6989586621679166139 :: TyFun k1 Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166226Scrutinee_6989586621679163733Sym1 x6989586621679166224 :: TyFun k1 Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166242Scrutinee_6989586621679163735Sym1 x6989586621679166240 :: TyFun k1 Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
(SingI d1, SingI d2) => SingI (Bool_Sym2 d1 d2 :: TyFun Bool a -> Type)
Instance details Defined in Data.Bool.Singletons Methods sing :: Sing (Bool_Sym2 d1 d2) #
(SingI d1, SingI d2) => SingI (Elem_bySym2 d1 d2 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (Elem_bySym2 d1 d2) #
(SFoldable t, SingI d) => SingI (AllSym1 d :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (AllSym1 d) #
(SFoldable t, SingI d) => SingI (AnySym1 d :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (AnySym1 d) #
(SFoldable t, SEq a, SingI d) => SingI (ElemSym1 d :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (ElemSym1 d) #
(SFoldable t, SEq a, SingI d) => SingI (NotElemSym1 d :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (NotElemSym1 d) #
SFoldable t => SingI (NullSym0 :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing NullSym0 #
SuppressUnusedWarnings (TFHelper_6989586621679130594Sym1 a6989586621679130599 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428549Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680163384Sym1 a6989586621680163389 :: TyFun (Proxy s) Bool -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680605296Sym1 a6989586621680605301 :: TyFun (Arg a b) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680892564Sym0 :: TyFun (k1 ~> Bool) (TyFun k (TyFun k1 (m k1) -> Type) -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680892726Sym0 :: TyFun (k2 ~> f Bool) (TyFun k3 (TyFun k2 (f [k2] ~> f [k2]) -> Type) -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130662Sym1 a6989586621679130667 :: TyFun (a, b) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130700Sym0 :: TyFun (a, b, c) ((a, b, c) ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Bool_Sym2 a6989586621679120954 a6989586621679120955 :: TyFun Bool a -> Type)
Instance details Defined in Data.Bool.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_bySym2 a6989586621679731050 a6989586621679731051 :: TyFun [a] Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731119Scrutinee_6989586621679727564Sym1 n6989586621679731117 :: TyFun k Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731363Scrutinee_6989586621679727542Sym0 :: TyFun k1 (TyFun [a] (TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731185Scrutinee_6989586621679727560Sym0 :: TyFun k1 (TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731071Scrutinee_6989586621679727570Sym0 :: TyFun k1 (TyFun k2 (TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731087Scrutinee_6989586621679727568Sym0 :: TyFun k1 (TyFun k2 (TyFun [k1] (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680892729Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680193722Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731100Scrutinee_6989586621679727566Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731262Scrutinee_6989586621679727550Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731275Scrutinee_6989586621679727548Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (AllSym1 a6989586621680193346 :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (AnySym1 a6989586621680193355 :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ElemSym1 a6989586621680193550 :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680193750Sym1 a6989586621680193759 :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (NotElemSym1 a6989586621680193297 :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (NullSym0 :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680193714Sym0 :: TyFun (t a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428549Sym1 a6989586621680428554 :: TyFun (Const a b) Bool -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130700Sym1 a6989586621679130705 :: TyFun (a, b, c) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130749Sym0 :: TyFun (a, b, c, d) ((a, b, c, d) ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731363Scrutinee_6989586621679727542Sym1 x6989586621679731361 :: TyFun [a] (TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516447Scrutinee_6989586621679516255Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731185Scrutinee_6989586621679727560Sym1 key6989586621679731181 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731071Scrutinee_6989586621679727570Sym1 y6989586621679731068 :: TyFun k2 (TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731087Scrutinee_6989586621679727568Sym1 x6989586621679731084 :: TyFun k2 (TyFun [k1] (TyFun k3 Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680892729Sym1 x6989586621680892728 :: TyFun k2 (TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680193722Sym1 a_69895866216801937166989586621680193721 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731100Scrutinee_6989586621679727566Sym1 x6989586621679731097 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731262Scrutinee_6989586621679727550Sym1 n6989586621679731259 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731275Scrutinee_6989586621679727548Sym1 n6989586621679731272 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621679731412Sym0 :: TyFun (b ~> (a ~> Bool)) (TyFun k1 (TyFun k2 (TyFun a (TyFun [a] (TyFun b (m b) -> Type) -> Type) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731363Scrutinee_6989586621679727542Sym2 x6989586621679731361 xs6989586621679731362 :: TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130749Sym1 a6989586621679130754 :: TyFun (a, b, c, d) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130809Sym0 :: TyFun (a, b, c, d, e) ((a, b, c, d, e) ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731071Scrutinee_6989586621679727570Sym2 y6989586621679731068 ys6989586621679731069 :: TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731087Scrutinee_6989586621679727568Sym2 x6989586621679731084 xs6989586621679731085 :: TyFun [k1] (TyFun k3 Bool -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516356Scrutinee_6989586621679516279Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516393Scrutinee_6989586621679516269Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516447Scrutinee_6989586621679516255Sym1 x6989586621679516446 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731185Scrutinee_6989586621679727560Sym2 key6989586621679731181 x6989586621679731182 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680892729Sym2 x6989586621680892728 p6989586621680892724 :: TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680193722Sym2 a_69895866216801937166989586621680193721 arg_69895866216801931086989586621680193724 :: TyFun k3 Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731100Scrutinee_6989586621679727566Sym2 x6989586621679731097 xs6989586621679731098 :: TyFun k3 Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731262Scrutinee_6989586621679727550Sym2 n6989586621679731259 x6989586621679731260 :: TyFun k3 Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731275Scrutinee_6989586621679727548Sym2 n6989586621679731272 x6989586621679731273 :: TyFun k3 Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731071Scrutinee_6989586621679727570Sym3 y6989586621679731068 ys6989586621679731069 xs6989586621679731070 :: TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130809Sym1 a6989586621679130814 :: TyFun (a, b, c, d, e) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130880Sym0 :: TyFun (a, b, c, d, e, f) ((a, b, c, d, e, f) ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680892729Sym3 x6989586621680892728 p6989586621680892724 a_69895866216808927176989586621680892725 :: TyFun Bool ([k1] ~> [k1]) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731363Scrutinee_6989586621679727542Sym3 x6989586621679731361 xs6989586621679731362 p6989586621679731357 :: TyFun k Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516447Scrutinee_6989586621679516255Sym2 x6989586621679516446 x06989586621679516441 :: TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516356Scrutinee_6989586621679516279Sym1 x16989586621679516351 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516393Scrutinee_6989586621679516269Sym1 x16989586621679516388 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731087Scrutinee_6989586621679727568Sym3 x6989586621679731084 xs6989586621679731085 ls6989586621679731086 :: TyFun k3 Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731185Scrutinee_6989586621679727560Sym3 key6989586621679731181 x6989586621679731182 y6989586621679731183 :: TyFun k3 Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130880Sym1 a6989586621679130885 :: TyFun (a, b, c, d, e, f) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130962Sym0 :: TyFun (a, b, c, d, e, f, g) ((a, b, c, d, e, f, g) ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516356Scrutinee_6989586621679516279Sym2 x16989586621679516351 x26989586621679516352 :: TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516393Scrutinee_6989586621679516269Sym2 x16989586621679516388 x26989586621679516389 :: TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516447Scrutinee_6989586621679516255Sym3 x6989586621679516446 x06989586621679516441 y6989586621679516442 :: TyFun k3 (TyFun k4 Bool -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731071Scrutinee_6989586621679727570Sym4 y6989586621679731068 ys6989586621679731069 xs6989586621679731070 eq6989586621679731062 :: TyFun k3 Bool -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130962Sym1 a6989586621679130967 :: TyFun (a, b, c, d, e, f, g) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516356Scrutinee_6989586621679516279Sym3 x16989586621679516351 x26989586621679516352 y6989586621679516353 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516393Scrutinee_6989586621679516269Sym3 x16989586621679516388 x26989586621679516389 y6989586621679516390 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516447Scrutinee_6989586621679516255Sym4 x6989586621679516446 x06989586621679516441 y6989586621679516442 arg_69895866216795162516989586621679516437 :: TyFun k4 Bool -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516356Scrutinee_6989586621679516279Sym4 x16989586621679516351 x26989586621679516352 y6989586621679516353 arg_69895866216795162736989586621679516346 :: TyFun k4 (TyFun k5 Bool -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516393Scrutinee_6989586621679516269Sym4 x16989586621679516388 x26989586621679516389 y6989586621679516390 arg_69895866216795162636989586621679516383 :: TyFun k4 (TyFun k5 Bool -> Type) -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516356Scrutinee_6989586621679516279Sym5 x16989586621679516351 x26989586621679516352 y6989586621679516353 arg_69895866216795162736989586621679516346 arg_69895866216795162756989586621679516347 :: TyFun k5 Bool -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679516393Scrutinee_6989586621679516269Sym5 x16989586621679516388 x26989586621679516389 y6989586621679516390 arg_69895866216795162636989586621679516383 arg_69895866216795162656989586621679516384 :: TyFun k5 Bool -> Type)
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
type DemoteRep Bool
Instance details Defined in GHC.Generics type DemoteRep Bool = Bool
type Rep Bool	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep Bool = D1 ('MetaData "Bool" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "False" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "True" 'PrefixI 'False) (U1 :: Type -> Type))
data Sing (a :: Bool)
Instance details Defined in GHC.Generics data Sing (a :: Bool) where STrue :: Sing 'True SFalse :: Sing 'False
type AsRPC Bool
Instance details Defined in Morley.AsRPC type AsRPC Bool = Bool
type TypeDocFieldDescriptions Bool
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Bool = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Bool
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Bool = 'TBool
type Demote Bool
Instance details Defined in Data.Singletons.Base.Instances type Demote Bool = Bool
type Sing
Instance details Defined in Data.Singletons.Base.Instances type Sing = SBool
type MaxBound
Instance details Defined in Data.Singletons.Base.Enum type MaxBound = MaxBound_6989586621679509887Sym0
type MinBound
Instance details Defined in Data.Singletons.Base.Enum type MinBound = MinBound_6989586621679509884Sym0
newtype Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Bool = V_Bool (Vector Word8)
type UnaryArithResHs Not Bool
Instance details Defined in Lorentz.Arith type UnaryArithResHs Not Bool = Bool
type FromEnum (a :: Bool)
Instance details Defined in Data.Singletons.Base.Enum type FromEnum (a :: Bool) = Apply FromEnum_6989586621679544301Sym0 a
type Pred (arg :: Bool)
Instance details Defined in Data.Singletons.Base.Enum type Pred (arg :: Bool) = Apply (Pred_6989586621679516494Sym0 :: TyFun Bool Bool -> Type) arg
type Succ (arg :: Bool)
Instance details Defined in Data.Singletons.Base.Enum type Succ (arg :: Bool) = Apply (Succ_6989586621679516481Sym0 :: TyFun Bool Bool -> Type) arg
type ToEnum a
Instance details Defined in Data.Singletons.Base.Enum type ToEnum a = Apply ToEnum_6989586621679544288Sym0 a
type Show_ (arg :: Bool)
Instance details Defined in Text.Show.Singletons type Show_ (arg :: Bool) = Apply (Show__6989586621680047550Sym0 :: TyFun Bool Symbol -> Type) arg
newtype MVector s Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Bool = MV_Bool (MVector s Word8)
type (arg1 :: Bool) /= (arg2 :: Bool)
Instance details Defined in Data.Eq.Singletons type (arg1 :: Bool) /= (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun Bool (Bool ~> Bool) -> Type) arg1) arg2
type (a1 :: Bool) == (a2 :: Bool)
Instance details Defined in Data.Eq.Singletons type (a1 :: Bool) == (a2 :: Bool) = Apply (Apply TFHelper_6989586621679131019Sym0 a1) a2
type (arg1 :: Bool) < (arg2 :: Bool)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Bool) < (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun Bool (Bool ~> Bool) -> Type) arg1) arg2
type (arg1 :: Bool) <= (arg2 :: Bool)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Bool) <= (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun Bool (Bool ~> Bool) -> Type) arg1) arg2
type (arg1 :: Bool) > (arg2 :: Bool)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Bool) > (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun Bool (Bool ~> Bool) -> Type) arg1) arg2
type (arg1 :: Bool) >= (arg2 :: Bool)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Bool) >= (arg2 :: Bool) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun Bool (Bool ~> Bool) -> Type) arg1) arg2
type Compare (a1 :: Bool) (a2 :: Bool)
Instance details Defined in Data.Ord.Singletons type Compare (a1 :: Bool) (a2 :: Bool) = Apply (Apply Compare_6989586621679181840Sym0 a1) a2
type Max (arg1 :: Bool) (arg2 :: Bool)
Instance details Defined in Data.Ord.Singletons type Max (arg1 :: Bool) (arg2 :: Bool) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun Bool (Bool ~> Bool) -> Type) arg1) arg2
type Min (arg1 :: Bool) (arg2 :: Bool)
Instance details Defined in Data.Ord.Singletons type Min (arg1 :: Bool) (arg2 :: Bool) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun Bool (Bool ~> Bool) -> Type) arg1) arg2
type EnumFromTo (arg1 :: Bool) (arg2 :: Bool)
Instance details Defined in Data.Singletons.Base.Enum type EnumFromTo (arg1 :: Bool) (arg2 :: Bool) = Apply (Apply (EnumFromTo_6989586621679516504Sym0 :: TyFun Bool (Bool ~> [Bool]) -> Type) arg1) arg2
type ShowList (arg1 :: [Bool]) arg2
Instance details Defined in Text.Show.Singletons type ShowList (arg1 :: [Bool]) arg2 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Bool] (Symbol ~> Symbol) -> Type) arg1) arg2
type Apply GetAllSym0 (a6989586621679596382 :: All)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply GetAllSym0 (a6989586621679596382 :: All) = GetAll a6989586621679596382
type Apply GetAnySym0 (a6989586621679596398 :: Any)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply GetAnySym0 (a6989586621679596398 :: Any) = GetAny a6989586621679596398
type Apply ContainsBigMapSym (x :: T)
Instance details Defined in Morley.Michelson.Typed.Scope type Apply ContainsBigMapSym (x :: T) = ContainsBigMap x
type Apply ContainsContractSym (x :: T)
Instance details Defined in Morley.Michelson.Typed.Scope type Apply ContainsContractSym (x :: T) = ContainsContract x
type Apply ContainsNestedBigMapsSym (x :: T)
Instance details Defined in Morley.Michelson.Typed.Scope type Apply ContainsNestedBigMapsSym (x :: T) = ContainsNestedBigMaps x
type Apply ContainsOpSym (x :: T)
Instance details Defined in Morley.Michelson.Typed.Scope type Apply ContainsOpSym (x :: T) = ContainsOp x
type Apply ContainsTicketSym (x :: T)
Instance details Defined in Morley.Michelson.Typed.Scope type Apply ContainsTicketSym (x :: T) = ContainsTicket x
type Apply AllSym0 (a6989586621679596379 :: Bool)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply AllSym0 (a6989586621679596379 :: Bool) = 'All a6989586621679596379
type Apply All_Sym0 (a6989586621679713097 :: Bool)
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation type Apply All_Sym0 (a6989586621679713097 :: Bool) = All_ a6989586621679713097
type Apply AnySym0 (a6989586621679596395 :: Bool)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply AnySym0 (a6989586621679596395 :: Bool) = 'Any a6989586621679596395
type Apply Any_Sym0 (a6989586621679713091 :: Bool)
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation type Apply Any_Sym0 (a6989586621679713091 :: Bool) = Any_ a6989586621679713091
type Apply NotSym0 (a6989586621679123820 :: Bool)
Instance details Defined in Data.Bool.Singletons type Apply NotSym0 (a6989586621679123820 :: Bool) = Not a6989586621679123820
type Apply FromEnum_6989586621679544301Sym0 (a6989586621679544305 :: Bool)
Instance details Defined in Data.Singletons.Base.Enum type Apply FromEnum_6989586621679544301Sym0 (a6989586621679544305 :: Bool) = FromEnum_6989586621679544301 a6989586621679544305
type Apply ToEnum_6989586621679544288Sym0 (a6989586621679544292 :: Nat)
Instance details Defined in Data.Singletons.Base.Enum type Apply ToEnum_6989586621679544288Sym0 (a6989586621679544292 :: Nat) = ToEnum_6989586621679544288 a6989586621679544292
type EnumFromThenTo (arg1 :: Bool) (arg2 :: Bool) (arg3 :: Bool)
Instance details Defined in Data.Singletons.Base.Enum type EnumFromThenTo (arg1 :: Bool) (arg2 :: Bool) (arg3 :: Bool) = Apply (Apply (Apply (EnumFromThenTo_6989586621679516516Sym0 :: TyFun Bool (Bool ~> (Bool ~> [Bool])) -> Type) arg1) arg2) arg3
type ShowsPrec a1 (a2 :: Bool) a3
Instance details Defined in Text.Show.Singletons type ShowsPrec a1 (a2 :: Bool) a3 = Apply (Apply (Apply ShowsPrec_6989586621680071834Sym0 a1) a2) a3
type Apply (TFHelper_6989586621679606123Sym1 a6989586621679606128 :: TyFun All Bool -> Type) (a6989586621679606129 :: All)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606123Sym1 a6989586621679606128 :: TyFun All Bool -> Type) (a6989586621679606129 :: All) = TFHelper_6989586621679606123 a6989586621679606128 a6989586621679606129
type Apply (TFHelper_6989586621679606140Sym1 a6989586621679606145 :: TyFun Any Bool -> Type) (a6989586621679606146 :: Any)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606140Sym1 a6989586621679606145 :: TyFun Any Bool -> Type) (a6989586621679606146 :: Any) = TFHelper_6989586621679606140 a6989586621679606145 a6989586621679606146
type Apply (TFHelper_6989586621679130639Sym1 a6989586621679130644 :: TyFun Void Bool -> Type) (a6989586621679130645 :: Void)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130639Sym1 a6989586621679130644 :: TyFun Void Bool -> Type) (a6989586621679130645 :: Void) = TFHelper_6989586621679130639 a6989586621679130644 a6989586621679130645
type Apply (TFHelper_6989586621679131028Sym1 a6989586621679131033 :: TyFun Ordering Bool -> Type) (a6989586621679131034 :: Ordering)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679131028Sym1 a6989586621679131033 :: TyFun Ordering Bool -> Type) (a6989586621679131034 :: Ordering) = TFHelper_6989586621679131028 a6989586621679131033 a6989586621679131034
type Apply (TFHelper_6989586621679131037Sym1 a6989586621679131042 :: TyFun () Bool -> Type) (a6989586621679131043 :: ())
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679131037Sym1 a6989586621679131042 :: TyFun () Bool -> Type) (a6989586621679131043 :: ()) = TFHelper_6989586621679131037 a6989586621679131042 a6989586621679131043
type Apply (Compare_6989586621679181840Sym1 a6989586621679181845 :: TyFun Bool Ordering -> Type) (a6989586621679181846 :: Bool)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181840Sym1 a6989586621679181845 :: TyFun Bool Ordering -> Type) (a6989586621679181846 :: Bool) = Compare_6989586621679181840 a6989586621679181845 a6989586621679181846
type Apply ((&&@#@$$) a6989586621679122836 :: TyFun Bool Bool -> Type) (a6989586621679122837 :: Bool)
Instance details Defined in Data.Bool.Singletons type Apply ((&&@#@$$) a6989586621679122836 :: TyFun Bool Bool -> Type) (a6989586621679122837 :: Bool) = a6989586621679122836 && a6989586621679122837
type Apply ((\|\|@#@$$) a6989586621679123482 :: TyFun Bool Bool -> Type) (a6989586621679123483 :: Bool)
Instance details Defined in Data.Bool.Singletons type Apply ((\|\|@#@$$) a6989586621679123482 :: TyFun Bool Bool -> Type) (a6989586621679123483 :: Bool) = a6989586621679123482 \|\| a6989586621679123483
type Apply (TFHelper_6989586621679131019Sym1 a6989586621679131024 :: TyFun Bool Bool -> Type) (a6989586621679131025 :: Bool)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679131019Sym1 a6989586621679131024 :: TyFun Bool Bool -> Type) (a6989586621679131025 :: Bool) = TFHelper_6989586621679131019 a6989586621679131024 a6989586621679131025
type Apply ((<=?@#@$$) a6989586621679462422 :: TyFun Nat Bool -> Type) (a6989586621679462423 :: Nat)
Instance details Defined in GHC.TypeLits.Singletons.Internal type Apply ((<=?@#@$$) a6989586621679462422 :: TyFun Nat Bool -> Type) (a6989586621679462423 :: Nat) = a6989586621679462422 <=? a6989586621679462423
type Apply (Let6989586621680163560Scrutinee_6989586621680162757Sym0 :: TyFun k1 Bool -> Type) (n6989586621680163559 :: k1)
Instance details Defined in Data.Proxy.Singletons type Apply (Let6989586621680163560Scrutinee_6989586621680162757Sym0 :: TyFun k1 Bool -> Type) (n6989586621680163559 :: k1) = Let6989586621680163560Scrutinee_6989586621680162757 n6989586621680163559
type Apply ((/=@#@$$) a6989586621679127813 :: TyFun a Bool -> Type) (a6989586621679127814 :: a)
Instance details Defined in Data.Eq.Singletons type Apply ((/=@#@$$) a6989586621679127813 :: TyFun a Bool -> Type) (a6989586621679127814 :: a) = a6989586621679127813 /= a6989586621679127814
type Apply ((==@#@$$) a6989586621679127808 :: TyFun a Bool -> Type) (a6989586621679127809 :: a)
Instance details Defined in Data.Eq.Singletons type Apply ((==@#@$$) a6989586621679127808 :: TyFun a Bool -> Type) (a6989586621679127809 :: a) = a6989586621679127808 == a6989586621679127809
type Apply (TFHelper_6989586621679127817Sym1 a6989586621679127822 :: TyFun a Bool -> Type) (a6989586621679127823 :: a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679127817Sym1 a6989586621679127822 :: TyFun a Bool -> Type) (a6989586621679127823 :: a) = TFHelper_6989586621679127817 a6989586621679127822 a6989586621679127823
type Apply (TFHelper_6989586621679127828Sym1 a6989586621679127833 :: TyFun a Bool -> Type) (a6989586621679127834 :: a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679127828Sym1 a6989586621679127833 :: TyFun a Bool -> Type) (a6989586621679127834 :: a) = TFHelper_6989586621679127828 a6989586621679127833 a6989586621679127834
type Apply ((<=@#@$$) a6989586621679166108 :: TyFun a Bool -> Type) (a6989586621679166109 :: a)
Instance details Defined in Data.Ord.Singletons type Apply ((<=@#@$$) a6989586621679166108 :: TyFun a Bool -> Type) (a6989586621679166109 :: a) = a6989586621679166108 <= a6989586621679166109
type Apply ((<@#@$$) a6989586621679166103 :: TyFun a Bool -> Type) (a6989586621679166104 :: a)
Instance details Defined in Data.Ord.Singletons type Apply ((<@#@$$) a6989586621679166103 :: TyFun a Bool -> Type) (a6989586621679166104 :: a) = a6989586621679166103 < a6989586621679166104
type Apply ((>=@#@$$) a6989586621679166118 :: TyFun a Bool -> Type) (a6989586621679166119 :: a)
Instance details Defined in Data.Ord.Singletons type Apply ((>=@#@$$) a6989586621679166118 :: TyFun a Bool -> Type) (a6989586621679166119 :: a) = a6989586621679166118 >= a6989586621679166119
type Apply ((>@#@$$) a6989586621679166113 :: TyFun a Bool -> Type) (a6989586621679166114 :: a)
Instance details Defined in Data.Ord.Singletons type Apply ((>@#@$$) a6989586621679166113 :: TyFun a Bool -> Type) (a6989586621679166114 :: a) = a6989586621679166113 > a6989586621679166114
type Apply (TFHelper_6989586621679166153Sym1 a6989586621679166158 :: TyFun a Bool -> Type) (a6989586621679166159 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679166153Sym1 a6989586621679166158 :: TyFun a Bool -> Type) (a6989586621679166159 :: a) = TFHelper_6989586621679166153 a6989586621679166158 a6989586621679166159
type Apply (TFHelper_6989586621679166169Sym1 a6989586621679166174 :: TyFun a Bool -> Type) (a6989586621679166175 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679166169Sym1 a6989586621679166174 :: TyFun a Bool -> Type) (a6989586621679166175 :: a) = TFHelper_6989586621679166169 a6989586621679166174 a6989586621679166175
type Apply (TFHelper_6989586621679166185Sym1 a6989586621679166190 :: TyFun a Bool -> Type) (a6989586621679166191 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679166185Sym1 a6989586621679166190 :: TyFun a Bool -> Type) (a6989586621679166191 :: a) = TFHelper_6989586621679166185 a6989586621679166190 a6989586621679166191
type Apply (TFHelper_6989586621679166201Sym1 a6989586621679166206 :: TyFun a Bool -> Type) (a6989586621679166207 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679166201Sym1 a6989586621679166206 :: TyFun a Bool -> Type) (a6989586621679166207 :: a) = TFHelper_6989586621679166201 a6989586621679166206 a6989586621679166207
type Apply (DefaultEqSym1 a6989586621679130155 :: TyFun k Bool -> Type) (a6989586621679130156 :: k)
Instance details Defined in Data.Eq.Singletons type Apply (DefaultEqSym1 a6989586621679130155 :: TyFun k Bool -> Type) (a6989586621679130156 :: k) = DefaultEq a6989586621679130155 a6989586621679130156
type Apply (Let6989586621680184051Scrutinee_6989586621680184015Sym1 x6989586621680184046 :: TyFun k1 Bool -> Type) (y6989586621680184047 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184051Scrutinee_6989586621680184015Sym1 x6989586621680184046 :: TyFun k1 Bool -> Type) (y6989586621680184047 :: k1) = Let6989586621680184051Scrutinee_6989586621680184015 x6989586621680184046 y6989586621680184047
type Apply (Let6989586621680184075Scrutinee_6989586621680184017Sym1 x6989586621680184070 :: TyFun k1 Bool -> Type) (y6989586621680184071 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184075Scrutinee_6989586621680184017Sym1 x6989586621680184070 :: TyFun k1 Bool -> Type) (y6989586621680184071 :: k1) = Let6989586621680184075Scrutinee_6989586621680184017 x6989586621680184070 y6989586621680184071
type Apply (Let6989586621679166141Scrutinee_6989586621679163721Sym1 x6989586621679166139 :: TyFun k1 Bool -> Type) (y6989586621679166140 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166141Scrutinee_6989586621679163721Sym1 x6989586621679166139 :: TyFun k1 Bool -> Type) (y6989586621679166140 :: k1) = Let6989586621679166141Scrutinee_6989586621679163721 x6989586621679166139 y6989586621679166140
type Apply (Let6989586621679166145Scrutinee_6989586621679163723Sym1 x6989586621679166139 :: TyFun k1 Bool -> Type) (y6989586621679166140 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166145Scrutinee_6989586621679163723Sym1 x6989586621679166139 :: TyFun k1 Bool -> Type) (y6989586621679166140 :: k1) = Let6989586621679166145Scrutinee_6989586621679163723 x6989586621679166139 y6989586621679166140
type Apply (Let6989586621679166226Scrutinee_6989586621679163733Sym1 x6989586621679166224 :: TyFun k1 Bool -> Type) (y6989586621679166225 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166226Scrutinee_6989586621679163733Sym1 x6989586621679166224 :: TyFun k1 Bool -> Type) (y6989586621679166225 :: k1) = Let6989586621679166226Scrutinee_6989586621679163733 x6989586621679166224 y6989586621679166225
type Apply (Let6989586621679166242Scrutinee_6989586621679163735Sym1 x6989586621679166240 :: TyFun k1 Bool -> Type) (y6989586621679166241 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166242Scrutinee_6989586621679163735Sym1 x6989586621679166240 :: TyFun k1 Bool -> Type) (y6989586621679166241 :: k1) = Let6989586621679166242Scrutinee_6989586621679163735 x6989586621679166240 y6989586621679166241
type Apply (Bool_Sym2 a6989586621679120954 a6989586621679120955 :: TyFun Bool a -> Type) (a6989586621679120956 :: Bool)
Instance details Defined in Data.Bool.Singletons type Apply (Bool_Sym2 a6989586621679120954 a6989586621679120955 :: TyFun Bool a -> Type) (a6989586621679120956 :: Bool) = Bool_ a6989586621679120954 a6989586621679120955 a6989586621679120956
type Apply (Let6989586621679731119Scrutinee_6989586621679727564Sym1 n6989586621679731117 :: TyFun k Bool -> Type) (x6989586621679731118 :: k)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731119Scrutinee_6989586621679727564Sym1 n6989586621679731117 :: TyFun k Bool -> Type) (x6989586621679731118 :: k) = Let6989586621679731119Scrutinee_6989586621679727564 n6989586621679731117 x6989586621679731118
type Apply (Lambda_6989586621680193722Sym2 a_69895866216801937166989586621680193721 arg_69895866216801931086989586621680193724 :: TyFun k3 Bool -> Type) (arg_69895866216801931106989586621680193725 :: k3)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680193722Sym2 a_69895866216801937166989586621680193721 arg_69895866216801931086989586621680193724 :: TyFun k3 Bool -> Type) (arg_69895866216801931106989586621680193725 :: k3) = Lambda_6989586621680193722 a_69895866216801937166989586621680193721 arg_69895866216801931086989586621680193724 arg_69895866216801931106989586621680193725
type Apply (Let6989586621679731100Scrutinee_6989586621679727566Sym2 x6989586621679731097 xs6989586621679731098 :: TyFun k3 Bool -> Type) (n6989586621679731099 :: k3)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731100Scrutinee_6989586621679727566Sym2 x6989586621679731097 xs6989586621679731098 :: TyFun k3 Bool -> Type) (n6989586621679731099 :: k3) = Let6989586621679731100Scrutinee_6989586621679727566 x6989586621679731097 xs6989586621679731098 n6989586621679731099
type Apply (Let6989586621679731262Scrutinee_6989586621679727550Sym2 n6989586621679731259 x6989586621679731260 :: TyFun k3 Bool -> Type) (xs6989586621679731261 :: k3)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731262Scrutinee_6989586621679727550Sym2 n6989586621679731259 x6989586621679731260 :: TyFun k3 Bool -> Type) (xs6989586621679731261 :: k3) = Let6989586621679731262Scrutinee_6989586621679727550 n6989586621679731259 x6989586621679731260 xs6989586621679731261
type Apply (Let6989586621679731275Scrutinee_6989586621679727548Sym2 n6989586621679731272 x6989586621679731273 :: TyFun k3 Bool -> Type) (xs6989586621679731274 :: k3)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731275Scrutinee_6989586621679727548Sym2 n6989586621679731272 x6989586621679731273 :: TyFun k3 Bool -> Type) (xs6989586621679731274 :: k3) = Let6989586621679731275Scrutinee_6989586621679727548 n6989586621679731272 x6989586621679731273 xs6989586621679731274
type Apply (Let6989586621679731363Scrutinee_6989586621679727542Sym3 x6989586621679731361 xs6989586621679731362 p6989586621679731357 :: TyFun k Bool -> Type) (a_69895866216797313506989586621679731358 :: k)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731363Scrutinee_6989586621679727542Sym3 x6989586621679731361 xs6989586621679731362 p6989586621679731357 :: TyFun k Bool -> Type) (a_69895866216797313506989586621679731358 :: k) = Let6989586621679731363Scrutinee_6989586621679727542 x6989586621679731361 xs6989586621679731362 p6989586621679731357 a_69895866216797313506989586621679731358
type Apply (Let6989586621679731087Scrutinee_6989586621679727568Sym3 x6989586621679731084 xs6989586621679731085 ls6989586621679731086 :: TyFun k3 Bool -> Type) (l6989586621679731079 :: k3)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731087Scrutinee_6989586621679727568Sym3 x6989586621679731084 xs6989586621679731085 ls6989586621679731086 :: TyFun k3 Bool -> Type) (l6989586621679731079 :: k3) = Let6989586621679731087Scrutinee_6989586621679727568 x6989586621679731084 xs6989586621679731085 ls6989586621679731086 l6989586621679731079
type Apply (Let6989586621679731185Scrutinee_6989586621679727560Sym3 key6989586621679731181 x6989586621679731182 y6989586621679731183 :: TyFun k3 Bool -> Type) (xys6989586621679731184 :: k3)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731185Scrutinee_6989586621679727560Sym3 key6989586621679731181 x6989586621679731182 y6989586621679731183 :: TyFun k3 Bool -> Type) (xys6989586621679731184 :: k3) = Let6989586621679731185Scrutinee_6989586621679727560 key6989586621679731181 x6989586621679731182 y6989586621679731183 xys6989586621679731184
type Apply (Let6989586621679731071Scrutinee_6989586621679727570Sym4 y6989586621679731068 ys6989586621679731069 xs6989586621679731070 eq6989586621679731062 :: TyFun k3 Bool -> Type) (l6989586621679731063 :: k3)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731071Scrutinee_6989586621679727570Sym4 y6989586621679731068 ys6989586621679731069 xs6989586621679731070 eq6989586621679731062 :: TyFun k3 Bool -> Type) (l6989586621679731063 :: k3) = Let6989586621679731071Scrutinee_6989586621679727570 y6989586621679731068 ys6989586621679731069 xs6989586621679731070 eq6989586621679731062 l6989586621679731063
type Apply (Let6989586621679516447Scrutinee_6989586621679516255Sym4 x6989586621679516446 x06989586621679516441 y6989586621679516442 arg_69895866216795162516989586621679516437 :: TyFun k4 Bool -> Type) (arg_69895866216795162536989586621679516438 :: k4)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516447Scrutinee_6989586621679516255Sym4 x6989586621679516446 x06989586621679516441 y6989586621679516442 arg_69895866216795162516989586621679516437 :: TyFun k4 Bool -> Type) (arg_69895866216795162536989586621679516438 :: k4) = Let6989586621679516447Scrutinee_6989586621679516255 x6989586621679516446 x06989586621679516441 y6989586621679516442 arg_69895866216795162516989586621679516437 arg_69895866216795162536989586621679516438
type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym5 x16989586621679516351 x26989586621679516352 y6989586621679516353 arg_69895866216795162736989586621679516346 arg_69895866216795162756989586621679516347 :: TyFun k5 Bool -> Type) (arg_69895866216795162776989586621679516348 :: k5)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym5 x16989586621679516351 x26989586621679516352 y6989586621679516353 arg_69895866216795162736989586621679516346 arg_69895866216795162756989586621679516347 :: TyFun k5 Bool -> Type) (arg_69895866216795162776989586621679516348 :: k5) = Let6989586621679516356Scrutinee_6989586621679516279 x16989586621679516351 x26989586621679516352 y6989586621679516353 arg_69895866216795162736989586621679516346 arg_69895866216795162756989586621679516347 arg_69895866216795162776989586621679516348
type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym5 x16989586621679516388 x26989586621679516389 y6989586621679516390 arg_69895866216795162636989586621679516383 arg_69895866216795162656989586621679516384 :: TyFun k5 Bool -> Type) (arg_69895866216795162676989586621679516385 :: k5)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym5 x16989586621679516388 x26989586621679516389 y6989586621679516390 arg_69895866216795162636989586621679516383 arg_69895866216795162656989586621679516384 :: TyFun k5 Bool -> Type) (arg_69895866216795162676989586621679516385 :: k5) = Let6989586621679516393Scrutinee_6989586621679516269 x16989586621679516388 x26989586621679516389 y6989586621679516390 arg_69895866216795162636989586621679516383 arg_69895866216795162656989586621679516384 arg_69895866216795162676989586621679516385
type Eval (Not 'False)
Instance details Defined in Fcf.Data.Bool type Eval (Not 'False) = 'True
type Eval (Not 'True)
Instance details Defined in Fcf.Data.Bool type Eval (Not 'True) = 'False
type Apply (GuardSym0 :: TyFun Bool (f ()) -> Type) (a6989586621679286827 :: Bool)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (GuardSym0 :: TyFun Bool (f ()) -> Type) (a6989586621679286827 :: Bool) = Guard a6989586621679286827 :: f ()
type Eval (And lst :: Bool -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (And lst :: Bool -> Type) = Eval (Foldr (&&) 'True lst)
type Eval (Or lst :: Bool -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (Or lst :: Bool -> Type) = Eval (Foldr (\|\|) 'False lst)
type Eval ('False && b :: Bool -> Type)
Instance details Defined in Fcf.Data.Bool type Eval ('False && b :: Bool -> Type) = 'False
type Eval ('True && b :: Bool -> Type)
Instance details Defined in Fcf.Data.Bool type Eval ('True && b :: Bool -> Type) = b
type Eval (a && 'False :: Bool -> Type)
Instance details Defined in Fcf.Data.Bool type Eval (a && 'False :: Bool -> Type) = 'False
type Eval (a && 'True :: Bool -> Type)
Instance details Defined in Fcf.Data.Bool type Eval (a && 'True :: Bool -> Type) = a
type Eval ('False \|\| b :: Bool -> Type)
Instance details Defined in Fcf.Data.Bool type Eval ('False \|\| b :: Bool -> Type) = b
type Eval ('True \|\| b :: Bool -> Type)
Instance details Defined in Fcf.Data.Bool type Eval ('True \|\| b :: Bool -> Type) = 'True
type Eval (a \|\| 'False :: Bool -> Type)
Instance details Defined in Fcf.Data.Bool type Eval (a \|\| 'False :: Bool -> Type) = a
type Eval (a \|\| 'True :: Bool -> Type)
Instance details Defined in Fcf.Data.Bool type Eval (a \|\| 'True :: Bool -> Type) = 'True
type Eval (IsJust ('Just _a) :: Bool -> Type)
Instance details Defined in Fcf.Data.Common type Eval (IsJust ('Just _a) :: Bool -> Type) = 'True
type Eval (IsJust ('Nothing :: Maybe a) :: Bool -> Type)
Instance details Defined in Fcf.Data.Common type Eval (IsJust ('Nothing :: Maybe a) :: Bool -> Type) = 'False
type Eval (IsNothing ('Just _a) :: Bool -> Type)
Instance details Defined in Fcf.Data.Common type Eval (IsNothing ('Just _a) :: Bool -> Type) = 'False
type Eval (IsNothing ('Nothing :: Maybe a) :: Bool -> Type)
Instance details Defined in Fcf.Data.Common type Eval (IsNothing ('Nothing :: Maybe a) :: Bool -> Type) = 'True
type Eval (Null ('[] :: [a]) :: Bool -> Type)
Instance details Defined in Fcf.Data.List type Eval (Null ('[] :: [a]) :: Bool -> Type) = 'True
type Eval (Null (a2 ': as) :: Bool -> Type)
Instance details Defined in Fcf.Data.List type Eval (Null (a2 ': as) :: Bool -> Type) = 'False
type Eval (a < b :: Bool -> Type)
Instance details Defined in Fcf.Data.Nat type Eval (a < b :: Bool -> Type) = Eval (Not =<< (a >= b))
type Eval (a <= b :: Bool -> Type)
Instance details Defined in Fcf.Data.Nat type Eval (a <= b :: Bool -> Type) = a <=? b
type Eval (a > b :: Bool -> Type)
Instance details Defined in Fcf.Data.Nat type Eval (a > b :: Bool -> Type) = Eval (Not =<< (a <= b))
type Eval (a >= b :: Bool -> Type)
Instance details Defined in Fcf.Data.Nat type Eval (a >= b :: Bool -> Type) = b <=? a
type Apply TFHelper_6989586621679606123Sym0 (a6989586621679606128 :: All)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply TFHelper_6989586621679606123Sym0 (a6989586621679606128 :: All) = TFHelper_6989586621679606123Sym1 a6989586621679606128
type Apply TFHelper_6989586621679606140Sym0 (a6989586621679606145 :: Any)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply TFHelper_6989586621679606140Sym0 (a6989586621679606145 :: Any) = TFHelper_6989586621679606140Sym1 a6989586621679606145
type Apply TFHelper_6989586621679130639Sym0 (a6989586621679130644 :: Void)
Instance details Defined in Data.Eq.Singletons type Apply TFHelper_6989586621679130639Sym0 (a6989586621679130644 :: Void) = TFHelper_6989586621679130639Sym1 a6989586621679130644
type Apply TFHelper_6989586621679131028Sym0 (a6989586621679131033 :: Ordering)
Instance details Defined in Data.Eq.Singletons type Apply TFHelper_6989586621679131028Sym0 (a6989586621679131033 :: Ordering) = TFHelper_6989586621679131028Sym1 a6989586621679131033
type Apply TFHelper_6989586621679131037Sym0 (a6989586621679131042 :: ())
Instance details Defined in Data.Eq.Singletons type Apply TFHelper_6989586621679131037Sym0 (a6989586621679131042 :: ()) = TFHelper_6989586621679131037Sym1 a6989586621679131042
type Apply ShowParenSym0 (a6989586621680047463 :: Bool)
Instance details Defined in Text.Show.Singletons type Apply ShowParenSym0 (a6989586621680047463 :: Bool) = ShowParenSym1 a6989586621680047463
type Apply Compare_6989586621679181840Sym0 (a6989586621679181845 :: Bool)
Instance details Defined in Data.Ord.Singletons type Apply Compare_6989586621679181840Sym0 (a6989586621679181845 :: Bool) = Compare_6989586621679181840Sym1 a6989586621679181845
type Apply (&&@#@$) (a6989586621679122836 :: Bool)
Instance details Defined in Data.Bool.Singletons type Apply (&&@#@$) (a6989586621679122836 :: Bool) = (&&@#@$$) a6989586621679122836
type Apply (\|\|@#@$) (a6989586621679123482 :: Bool)
Instance details Defined in Data.Bool.Singletons type Apply (\|\|@#@$) (a6989586621679123482 :: Bool) = (\|\|@#@$$) a6989586621679123482
type Apply TFHelper_6989586621679131019Sym0 (a6989586621679131024 :: Bool)
Instance details Defined in Data.Eq.Singletons type Apply TFHelper_6989586621679131019Sym0 (a6989586621679131024 :: Bool) = TFHelper_6989586621679131019Sym1 a6989586621679131024
type Apply ShowsPrec_6989586621680071834Sym0 (a6989586621680071844 :: Nat)
Instance details Defined in Text.Show.Singletons type Apply ShowsPrec_6989586621680071834Sym0 (a6989586621680071844 :: Nat) = ShowsPrec_6989586621680071834Sym1 a6989586621680071844
type Apply (<=?@#@$) (a6989586621679462422 :: Nat)
Instance details Defined in GHC.TypeLits.Singletons.Internal type Apply (<=?@#@$) (a6989586621679462422 :: Nat) = (<=?@#@$$) a6989586621679462422
type Apply (ShowsPrec_6989586621680071834Sym1 a6989586621680071844 :: TyFun Bool (Symbol ~> Symbol) -> Type) (a6989586621680071845 :: Bool)
Instance details Defined in Text.Show.Singletons type Apply (ShowsPrec_6989586621680071834Sym1 a6989586621680071844 :: TyFun Bool (Symbol ~> Symbol) -> Type) (a6989586621680071845 :: Bool) = ShowsPrec_6989586621680071834Sym2 a6989586621680071844 a6989586621680071845
type Apply (UnlessSym0 :: TyFun Bool (f () ~> f ()) -> Type) (a6989586621680892589 :: Bool)
Instance details Defined in Control.Monad.Singletons type Apply (UnlessSym0 :: TyFun Bool (f () ~> f ()) -> Type) (a6989586621680892589 :: Bool) = UnlessSym1 a6989586621680892589 :: TyFun (f ()) (f ()) -> Type
type Apply (WhenSym0 :: TyFun Bool (f () ~> f ()) -> Type) (a6989586621679286971 :: Bool)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (WhenSym0 :: TyFun Bool (f () ~> f ()) -> Type) (a6989586621679286971 :: Bool) = WhenSym1 a6989586621679286971 :: TyFun (f ()) (f ()) -> Type
type Apply (IfSym0 :: TyFun Bool (k ~> (k ~> k)) -> Type) (a6989586621679124049 :: Bool)
Instance details Defined in Data.Bool.Singletons type Apply (IfSym0 :: TyFun Bool (k ~> (k ~> k)) -> Type) (a6989586621679124049 :: Bool) = IfSym1 a6989586621679124049 :: TyFun k (k ~> k) -> Type
type Apply (Elem_6989586621680392157Sym0 :: TyFun a (Identity a ~> Bool) -> Type) (a6989586621680392162 :: a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Elem_6989586621680392157Sym0 :: TyFun a (Identity a ~> Bool) -> Type) (a6989586621680392162 :: a) = Elem_6989586621680392157Sym1 a6989586621680392162
type Apply (Elem_6989586621680194236Sym0 :: TyFun a (Proxy a ~> Bool) -> Type) (a6989586621680194241 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194236Sym0 :: TyFun a (Proxy a ~> Bool) -> Type) (a6989586621680194241 :: a) = Elem_6989586621680194236Sym1 a6989586621680194241
type Apply (Elem_6989586621680194268Sym0 :: TyFun a (Dual a ~> Bool) -> Type) (a6989586621680194277 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194268Sym0 :: TyFun a (Dual a ~> Bool) -> Type) (a6989586621680194277 :: a) = Elem_6989586621680194268Sym1 a6989586621680194277
type Apply (Elem_6989586621680194618Sym0 :: TyFun a (Product a ~> Bool) -> Type) (a6989586621680194627 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194618Sym0 :: TyFun a (Product a ~> Bool) -> Type) (a6989586621680194627 :: a) = Elem_6989586621680194618Sym1 a6989586621680194627
type Apply (Elem_6989586621680194443Sym0 :: TyFun a (Sum a ~> Bool) -> Type) (a6989586621680194452 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194443Sym0 :: TyFun a (Sum a ~> Bool) -> Type) (a6989586621680194452 :: a) = Elem_6989586621680194443Sym1 a6989586621680194452
type Apply (Elem_6989586621680193860Sym0 :: TyFun a ([a] ~> Bool) -> Type) (a6989586621680193869 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680193860Sym0 :: TyFun a ([a] ~> Bool) -> Type) (a6989586621680193869 :: a) = Elem_6989586621680193860Sym1 a6989586621680193869
type Apply (ElemSym0 :: TyFun a ([a] ~> Bool) -> Type) (a6989586621679731822 :: a)
Instance details Defined in Data.List.Singletons.Internal type Apply (ElemSym0 :: TyFun a ([a] ~> Bool) -> Type) (a6989586621679731822 :: a) = ElemSym1 a6989586621679731822
type Apply (NotElemSym0 :: TyFun a ([a] ~> Bool) -> Type) (a6989586621679731814 :: a)
Instance details Defined in Data.List.Singletons.Internal type Apply (NotElemSym0 :: TyFun a ([a] ~> Bool) -> Type) (a6989586621679731814 :: a) = NotElemSym1 a6989586621679731814
type Apply (ListelemSym0 :: TyFun a ([a] ~> Bool) -> Type) (a6989586621680002068 :: a)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListelemSym0 :: TyFun a ([a] ~> Bool) -> Type) (a6989586621680002068 :: a) = ListelemSym1 a6989586621680002068
type Apply (Bool_Sym0 :: TyFun a (a ~> (Bool ~> a)) -> Type) (a6989586621679120954 :: a)
Instance details Defined in Data.Bool.Singletons type Apply (Bool_Sym0 :: TyFun a (a ~> (Bool ~> a)) -> Type) (a6989586621679120954 :: a) = Bool_Sym1 a6989586621679120954
type Apply ((/=@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679127813 :: a)
Instance details Defined in Data.Eq.Singletons type Apply ((/=@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679127813 :: a) = (/=@#@$$) a6989586621679127813
type Apply ((==@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679127808 :: a)
Instance details Defined in Data.Eq.Singletons type Apply ((==@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679127808 :: a) = (==@#@$$) a6989586621679127808
type Apply (TFHelper_6989586621679127817Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679127822 :: a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679127817Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679127822 :: a) = TFHelper_6989586621679127817Sym1 a6989586621679127822
type Apply (TFHelper_6989586621679127828Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679127833 :: a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679127828Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679127833 :: a) = TFHelper_6989586621679127828Sym1 a6989586621679127833
type Apply ((<=@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679166108 :: a)
Instance details Defined in Data.Ord.Singletons type Apply ((<=@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679166108 :: a) = (<=@#@$$) a6989586621679166108
type Apply ((<@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679166103 :: a)
Instance details Defined in Data.Ord.Singletons type Apply ((<@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679166103 :: a) = (<@#@$$) a6989586621679166103
type Apply ((>=@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679166118 :: a)
Instance details Defined in Data.Ord.Singletons type Apply ((>=@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679166118 :: a) = (>=@#@$$) a6989586621679166118
type Apply ((>@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679166113 :: a)
Instance details Defined in Data.Ord.Singletons type Apply ((>@#@$) :: TyFun a (a ~> Bool) -> Type) (a6989586621679166113 :: a) = (>@#@$$) a6989586621679166113
type Apply (TFHelper_6989586621679166153Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679166158 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679166153Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679166158 :: a) = TFHelper_6989586621679166153Sym1 a6989586621679166158
type Apply (TFHelper_6989586621679166169Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679166174 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679166169Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679166174 :: a) = TFHelper_6989586621679166169Sym1 a6989586621679166174
type Apply (TFHelper_6989586621679166185Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679166190 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679166185Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679166190 :: a) = TFHelper_6989586621679166185Sym1 a6989586621679166190
type Apply (TFHelper_6989586621679166201Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679166206 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679166201Sym0 :: TyFun a (a ~> Bool) -> Type) (a6989586621679166206 :: a) = TFHelper_6989586621679166201Sym1 a6989586621679166206
type Apply (DefaultEqSym0 :: TyFun k (k ~> Bool) -> Type) (a6989586621679130155 :: k)
Instance details Defined in Data.Eq.Singletons type Apply (DefaultEqSym0 :: TyFun k (k ~> Bool) -> Type) (a6989586621679130155 :: k) = DefaultEqSym1 a6989586621679130155
type Apply (Let6989586621680184051Scrutinee_6989586621680184015Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621680184046 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184051Scrutinee_6989586621680184015Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621680184046 :: k1) = Let6989586621680184051Scrutinee_6989586621680184015Sym1 x6989586621680184046
type Apply (Let6989586621680184075Scrutinee_6989586621680184017Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621680184070 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184075Scrutinee_6989586621680184017Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621680184070 :: k1) = Let6989586621680184075Scrutinee_6989586621680184017Sym1 x6989586621680184070
type Apply (Let6989586621679166141Scrutinee_6989586621679163721Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621679166139 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166141Scrutinee_6989586621679163721Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621679166139 :: k1) = Let6989586621679166141Scrutinee_6989586621679163721Sym1 x6989586621679166139
type Apply (Let6989586621679166145Scrutinee_6989586621679163723Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621679166139 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166145Scrutinee_6989586621679163723Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621679166139 :: k1) = Let6989586621679166145Scrutinee_6989586621679163723Sym1 x6989586621679166139
type Apply (Let6989586621679166226Scrutinee_6989586621679163733Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621679166224 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166226Scrutinee_6989586621679163733Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621679166224 :: k1) = Let6989586621679166226Scrutinee_6989586621679163733Sym1 x6989586621679166224
type Apply (Let6989586621679166242Scrutinee_6989586621679163735Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621679166240 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166242Scrutinee_6989586621679163735Sym0 :: TyFun k1 (TyFun k1 Bool -> Type) -> Type) (x6989586621679166240 :: k1) = Let6989586621679166242Scrutinee_6989586621679163735Sym1 x6989586621679166240
type Apply (Bool_Sym1 a6989586621679120954 :: TyFun a (Bool ~> a) -> Type) (a6989586621679120955 :: a)
Instance details Defined in Data.Bool.Singletons type Apply (Bool_Sym1 a6989586621679120954 :: TyFun a (Bool ~> a) -> Type) (a6989586621679120955 :: a) = Bool_Sym2 a6989586621679120954 a6989586621679120955
type Apply (Elem_bySym1 a6989586621679731050 :: TyFun a ([a] ~> Bool) -> Type) (a6989586621679731051 :: a)
Instance details Defined in Data.List.Singletons.Internal type Apply (Elem_bySym1 a6989586621679731050 :: TyFun a ([a] ~> Bool) -> Type) (a6989586621679731051 :: a) = Elem_bySym2 a6989586621679731050 a6989586621679731051
type Apply (ElemSym0 :: TyFun a (t a ~> Bool) -> Type) (a6989586621680193550 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (ElemSym0 :: TyFun a (t a ~> Bool) -> Type) (a6989586621680193550 :: a) = ElemSym1 a6989586621680193550 :: TyFun (t a) Bool -> Type
type Apply (Elem_6989586621680193750Sym0 :: TyFun a (t a ~> Bool) -> Type) (a6989586621680193759 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680193750Sym0 :: TyFun a (t a ~> Bool) -> Type) (a6989586621680193759 :: a) = Elem_6989586621680193750Sym1 a6989586621680193759 :: TyFun (t a) Bool -> Type
type Apply (NotElemSym0 :: TyFun a (t a ~> Bool) -> Type) (a6989586621680193297 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (NotElemSym0 :: TyFun a (t a ~> Bool) -> Type) (a6989586621680193297 :: a) = NotElemSym1 a6989586621680193297 :: TyFun (t a) Bool -> Type
type Apply (Let6989586621679731119Scrutinee_6989586621679727564Sym0 :: TyFun k1 (TyFun k Bool -> Type) -> Type) (n6989586621679731117 :: k1)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731119Scrutinee_6989586621679727564Sym0 :: TyFun k1 (TyFun k Bool -> Type) -> Type) (n6989586621679731117 :: k1) = Let6989586621679731119Scrutinee_6989586621679727564Sym1 n6989586621679731117 :: TyFun k Bool -> Type
type Apply (Let6989586621679731363Scrutinee_6989586621679727542Sym0 :: TyFun k1 (TyFun [a] (TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type) -> Type) -> Type) (x6989586621679731361 :: k1)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731363Scrutinee_6989586621679727542Sym0 :: TyFun k1 (TyFun [a] (TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type) -> Type) -> Type) (x6989586621679731361 :: k1) = Let6989586621679731363Scrutinee_6989586621679727542Sym1 x6989586621679731361 :: TyFun [a] (TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type) -> Type
type Apply (Let6989586621679731185Scrutinee_6989586621679727560Sym0 :: TyFun k1 (TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type) (key6989586621679731181 :: k1)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731185Scrutinee_6989586621679727560Sym0 :: TyFun k1 (TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type) (key6989586621679731181 :: k1) = Let6989586621679731185Scrutinee_6989586621679727560Sym1 key6989586621679731181 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type
type Apply (Let6989586621679731071Scrutinee_6989586621679727570Sym0 :: TyFun k1 (TyFun k2 (TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type) -> Type) (y6989586621679731068 :: k1)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731071Scrutinee_6989586621679727570Sym0 :: TyFun k1 (TyFun k2 (TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type) -> Type) (y6989586621679731068 :: k1) = Let6989586621679731071Scrutinee_6989586621679727570Sym1 y6989586621679731068 :: TyFun k2 (TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type
type Apply (Let6989586621679731087Scrutinee_6989586621679727568Sym0 :: TyFun k1 (TyFun k2 (TyFun [k1] (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type) (x6989586621679731084 :: k1)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731087Scrutinee_6989586621679727568Sym0 :: TyFun k1 (TyFun k2 (TyFun [k1] (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type) (x6989586621679731084 :: k1) = Let6989586621679731087Scrutinee_6989586621679727568Sym1 x6989586621679731084 :: TyFun k2 (TyFun [k1] (TyFun k3 Bool -> Type) -> Type) -> Type
type Apply (Lambda_6989586621680892729Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type) -> Type) -> Type) (x6989586621680892728 :: k1)
Instance details Defined in Control.Monad.Singletons type Apply (Lambda_6989586621680892729Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type) -> Type) -> Type) (x6989586621680892728 :: k1) = Lambda_6989586621680892729Sym1 x6989586621680892728 :: TyFun k2 (TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type) -> Type
type Apply (Lambda_6989586621680193722Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) (a_69895866216801937166989586621680193721 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680193722Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) (a_69895866216801937166989586621680193721 :: k1) = Lambda_6989586621680193722Sym1 a_69895866216801937166989586621680193721 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type
type Apply (Let6989586621679731100Scrutinee_6989586621679727566Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) (x6989586621679731097 :: k1)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731100Scrutinee_6989586621679727566Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) (x6989586621679731097 :: k1) = Let6989586621679731100Scrutinee_6989586621679727566Sym1 x6989586621679731097 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type
type Apply (Let6989586621679731262Scrutinee_6989586621679727550Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) (n6989586621679731259 :: k1)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731262Scrutinee_6989586621679727550Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) (n6989586621679731259 :: k1) = Let6989586621679731262Scrutinee_6989586621679727550Sym1 n6989586621679731259 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type
type Apply (Let6989586621679731275Scrutinee_6989586621679727548Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) (n6989586621679731272 :: k1)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731275Scrutinee_6989586621679727548Sym0 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) (n6989586621679731272 :: k1) = Let6989586621679731275Scrutinee_6989586621679727548Sym1 n6989586621679731272 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type
type Apply (Let6989586621679516447Scrutinee_6989586621679516255Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type) -> Type) -> Type) (x6989586621679516446 :: k1)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516447Scrutinee_6989586621679516255Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type) -> Type) -> Type) (x6989586621679516446 :: k1) = Let6989586621679516447Scrutinee_6989586621679516255Sym1 x6989586621679516446 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type) -> Type
type Apply (Let6989586621679731185Scrutinee_6989586621679727560Sym1 key6989586621679731181 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) (x6989586621679731182 :: k1)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731185Scrutinee_6989586621679727560Sym1 key6989586621679731181 :: TyFun k1 (TyFun k2 (TyFun k3 Bool -> Type) -> Type) -> Type) (x6989586621679731182 :: k1) = Let6989586621679731185Scrutinee_6989586621679727560Sym2 key6989586621679731181 x6989586621679731182 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type
type Apply (Let6989586621679731071Scrutinee_6989586621679727570Sym1 y6989586621679731068 :: TyFun k2 (TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type) (ys6989586621679731069 :: k2)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731071Scrutinee_6989586621679727570Sym1 y6989586621679731068 :: TyFun k2 (TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type) -> Type) (ys6989586621679731069 :: k2) = Let6989586621679731071Scrutinee_6989586621679727570Sym2 y6989586621679731068 ys6989586621679731069 :: TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type
type Apply (Let6989586621679731087Scrutinee_6989586621679727568Sym1 x6989586621679731084 :: TyFun k2 (TyFun [k1] (TyFun k3 Bool -> Type) -> Type) -> Type) (xs6989586621679731085 :: k2)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731087Scrutinee_6989586621679727568Sym1 x6989586621679731084 :: TyFun k2 (TyFun [k1] (TyFun k3 Bool -> Type) -> Type) -> Type) (xs6989586621679731085 :: k2) = Let6989586621679731087Scrutinee_6989586621679727568Sym2 x6989586621679731084 xs6989586621679731085 :: TyFun [k1] (TyFun k3 Bool -> Type) -> Type
type Apply (Lambda_6989586621680892729Sym1 x6989586621680892728 :: TyFun k2 (TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type) -> Type) (p6989586621680892724 :: k2)
Instance details Defined in Control.Monad.Singletons type Apply (Lambda_6989586621680892729Sym1 x6989586621680892728 :: TyFun k2 (TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type) -> Type) (p6989586621680892724 :: k2) = Lambda_6989586621680892729Sym2 x6989586621680892728 p6989586621680892724 :: TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type
type Apply (Lambda_6989586621680193722Sym1 a_69895866216801937166989586621680193721 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type) (arg_69895866216801931086989586621680193724 :: k2)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680193722Sym1 a_69895866216801937166989586621680193721 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type) (arg_69895866216801931086989586621680193724 :: k2) = Lambda_6989586621680193722Sym2 a_69895866216801937166989586621680193721 arg_69895866216801931086989586621680193724 :: TyFun k3 Bool -> Type
type Apply (Let6989586621679731100Scrutinee_6989586621679727566Sym1 x6989586621679731097 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type) (xs6989586621679731098 :: k2)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731100Scrutinee_6989586621679727566Sym1 x6989586621679731097 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type) (xs6989586621679731098 :: k2) = Let6989586621679731100Scrutinee_6989586621679727566Sym2 x6989586621679731097 xs6989586621679731098 :: TyFun k3 Bool -> Type
type Apply (Let6989586621679731262Scrutinee_6989586621679727550Sym1 n6989586621679731259 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type) (x6989586621679731260 :: k2)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731262Scrutinee_6989586621679727550Sym1 n6989586621679731259 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type) (x6989586621679731260 :: k2) = Let6989586621679731262Scrutinee_6989586621679727550Sym2 n6989586621679731259 x6989586621679731260 :: TyFun k3 Bool -> Type
type Apply (Let6989586621679731275Scrutinee_6989586621679727548Sym1 n6989586621679731272 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type) (x6989586621679731273 :: k2)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731275Scrutinee_6989586621679727548Sym1 n6989586621679731272 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type) (x6989586621679731273 :: k2) = Let6989586621679731275Scrutinee_6989586621679727548Sym2 n6989586621679731272 x6989586621679731273 :: TyFun k3 Bool -> Type
type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type) -> Type) (x16989586621679516351 :: k1)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type) -> Type) (x16989586621679516351 :: k1) = Let6989586621679516356Scrutinee_6989586621679516279Sym1 x16989586621679516351 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type
type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type) -> Type) (x16989586621679516388 :: k1)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym0 :: TyFun k1 (TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type) -> Type) (x16989586621679516388 :: k1) = Let6989586621679516393Scrutinee_6989586621679516269Sym1 x16989586621679516388 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type
type Apply (Let6989586621679516447Scrutinee_6989586621679516255Sym1 x6989586621679516446 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type) -> Type) (x06989586621679516441 :: k2)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516447Scrutinee_6989586621679516255Sym1 x6989586621679516446 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type) -> Type) (x06989586621679516441 :: k2) = Let6989586621679516447Scrutinee_6989586621679516255Sym2 x6989586621679516446 x06989586621679516441 :: TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type
type Apply (Let6989586621679731185Scrutinee_6989586621679727560Sym2 key6989586621679731181 x6989586621679731182 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type) (y6989586621679731183 :: k2)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731185Scrutinee_6989586621679727560Sym2 key6989586621679731181 x6989586621679731182 :: TyFun k2 (TyFun k3 Bool -> Type) -> Type) (y6989586621679731183 :: k2) = Let6989586621679731185Scrutinee_6989586621679727560Sym3 key6989586621679731181 x6989586621679731182 y6989586621679731183 :: TyFun k3 Bool -> Type
type Apply (Lambda_6989586621680892729Sym2 x6989586621680892728 p6989586621680892724 :: TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type) (a_69895866216808927176989586621680892725 :: k3)
Instance details Defined in Control.Monad.Singletons type Apply (Lambda_6989586621680892729Sym2 x6989586621680892728 p6989586621680892724 :: TyFun k3 (TyFun Bool ([k1] ~> [k1]) -> Type) -> Type) (a_69895866216808927176989586621680892725 :: k3) = Lambda_6989586621680892729Sym3 x6989586621680892728 p6989586621680892724 a_69895866216808927176989586621680892725
type Apply (Lambda_6989586621680892729Sym3 x6989586621680892728 p6989586621680892724 a_69895866216808927176989586621680892725 :: TyFun Bool ([k1] ~> [k1]) -> Type) (flg6989586621680892731 :: Bool)
Instance details Defined in Control.Monad.Singletons type Apply (Lambda_6989586621680892729Sym3 x6989586621680892728 p6989586621680892724 a_69895866216808927176989586621680892725 :: TyFun Bool ([k1] ~> [k1]) -> Type) (flg6989586621680892731 :: Bool) = Lambda_6989586621680892729 x6989586621680892728 p6989586621680892724 a_69895866216808927176989586621680892725 flg6989586621680892731
type Apply (Let6989586621679516447Scrutinee_6989586621679516255Sym2 x6989586621679516446 x06989586621679516441 :: TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type) (y6989586621679516442 :: k1)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516447Scrutinee_6989586621679516255Sym2 x6989586621679516446 x06989586621679516441 :: TyFun k1 (TyFun k3 (TyFun k4 Bool -> Type) -> Type) -> Type) (y6989586621679516442 :: k1) = Let6989586621679516447Scrutinee_6989586621679516255Sym3 x6989586621679516446 x06989586621679516441 y6989586621679516442 :: TyFun k3 (TyFun k4 Bool -> Type) -> Type
type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym1 x16989586621679516351 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type) (x26989586621679516352 :: k2)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym1 x16989586621679516351 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type) (x26989586621679516352 :: k2) = Let6989586621679516356Scrutinee_6989586621679516279Sym2 x16989586621679516351 x26989586621679516352 :: TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type
type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym1 x16989586621679516388 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type) (x26989586621679516389 :: k2)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym1 x16989586621679516388 :: TyFun k2 (TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) -> Type) (x26989586621679516389 :: k2) = Let6989586621679516393Scrutinee_6989586621679516269Sym2 x16989586621679516388 x26989586621679516389 :: TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type
type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym2 x16989586621679516351 x26989586621679516352 :: TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) (y6989586621679516353 :: k1)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym2 x16989586621679516351 x26989586621679516352 :: TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) (y6989586621679516353 :: k1) = Let6989586621679516356Scrutinee_6989586621679516279Sym3 x16989586621679516351 x26989586621679516352 y6989586621679516353 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type
type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym2 x16989586621679516388 x26989586621679516389 :: TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) (y6989586621679516390 :: k1)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym2 x16989586621679516388 x26989586621679516389 :: TyFun k1 (TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) -> Type) (y6989586621679516390 :: k1) = Let6989586621679516393Scrutinee_6989586621679516269Sym3 x16989586621679516388 x26989586621679516389 y6989586621679516390 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type
type Apply (Let6989586621679516447Scrutinee_6989586621679516255Sym3 x6989586621679516446 x06989586621679516441 y6989586621679516442 :: TyFun k3 (TyFun k4 Bool -> Type) -> Type) (arg_69895866216795162516989586621679516437 :: k3)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516447Scrutinee_6989586621679516255Sym3 x6989586621679516446 x06989586621679516441 y6989586621679516442 :: TyFun k3 (TyFun k4 Bool -> Type) -> Type) (arg_69895866216795162516989586621679516437 :: k3) = Let6989586621679516447Scrutinee_6989586621679516255Sym4 x6989586621679516446 x06989586621679516441 y6989586621679516442 arg_69895866216795162516989586621679516437 :: TyFun k4 Bool -> Type
type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym3 x16989586621679516351 x26989586621679516352 y6989586621679516353 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) (arg_69895866216795162736989586621679516346 :: k3)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym3 x16989586621679516351 x26989586621679516352 y6989586621679516353 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) (arg_69895866216795162736989586621679516346 :: k3) = Let6989586621679516356Scrutinee_6989586621679516279Sym4 x16989586621679516351 x26989586621679516352 y6989586621679516353 arg_69895866216795162736989586621679516346 :: TyFun k4 (TyFun k5 Bool -> Type) -> Type
type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym3 x16989586621679516388 x26989586621679516389 y6989586621679516390 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) (arg_69895866216795162636989586621679516383 :: k3)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym3 x16989586621679516388 x26989586621679516389 y6989586621679516390 :: TyFun k3 (TyFun k4 (TyFun k5 Bool -> Type) -> Type) -> Type) (arg_69895866216795162636989586621679516383 :: k3) = Let6989586621679516393Scrutinee_6989586621679516269Sym4 x16989586621679516388 x26989586621679516389 y6989586621679516390 arg_69895866216795162636989586621679516383 :: TyFun k4 (TyFun k5 Bool -> Type) -> Type
type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym4 x16989586621679516351 x26989586621679516352 y6989586621679516353 arg_69895866216795162736989586621679516346 :: TyFun k4 (TyFun k5 Bool -> Type) -> Type) (arg_69895866216795162756989586621679516347 :: k4)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516356Scrutinee_6989586621679516279Sym4 x16989586621679516351 x26989586621679516352 y6989586621679516353 arg_69895866216795162736989586621679516346 :: TyFun k4 (TyFun k5 Bool -> Type) -> Type) (arg_69895866216795162756989586621679516347 :: k4) = Let6989586621679516356Scrutinee_6989586621679516279Sym5 x16989586621679516351 x26989586621679516352 y6989586621679516353 arg_69895866216795162736989586621679516346 arg_69895866216795162756989586621679516347 :: TyFun k5 Bool -> Type
type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym4 x16989586621679516388 x26989586621679516389 y6989586621679516390 arg_69895866216795162636989586621679516383 :: TyFun k4 (TyFun k5 Bool -> Type) -> Type) (arg_69895866216795162656989586621679516384 :: k4)
Instance details Defined in Data.Singletons.Base.Enum type Apply (Let6989586621679516393Scrutinee_6989586621679516269Sym4 x16989586621679516388 x26989586621679516389 y6989586621679516390 arg_69895866216795162636989586621679516383 :: TyFun k4 (TyFun k5 Bool -> Type) -> Type) (arg_69895866216795162656989586621679516384 :: k4) = Let6989586621679516393Scrutinee_6989586621679516269Sym5 x16989586621679516388 x26989586621679516389 y6989586621679516390 arg_69895866216795162636989586621679516383 arg_69895866216795162656989586621679516384 :: TyFun k5 Bool -> Type
type Eval (IsLeft ('Left _a :: Either a b) :: Bool -> Type)
Instance details Defined in Fcf.Data.Common type Eval (IsLeft ('Left _a :: Either a b) :: Bool -> Type) = 'True
type Eval (IsLeft ('Right _a :: Either a b) :: Bool -> Type)
Instance details Defined in Fcf.Data.Common type Eval (IsLeft ('Right _a :: Either a b) :: Bool -> Type) = 'False
type Eval (IsRight ('Left _a :: Either a b) :: Bool -> Type)
Instance details Defined in Fcf.Data.Common type Eval (IsRight ('Left _a :: Either a b) :: Bool -> Type) = 'False
type Eval (IsRight ('Right _a :: Either a b) :: Bool -> Type)
Instance details Defined in Fcf.Data.Common type Eval (IsRight ('Right _a :: Either a b) :: Bool -> Type) = 'True
type Eval (Elem a2 as :: Bool -> Type)
Instance details Defined in Fcf.Data.List type Eval (Elem a2 as :: Bool -> Type) = Eval ((IsJust :: Maybe Nat -> Bool -> Type) =<< FindIndex (TyEq a2 :: a1 -> Bool -> Type) as)
type Eval (IsInfixOf xs ys :: Bool -> Type)
Instance details Defined in Fcf.Data.List type Eval (IsInfixOf xs ys :: Bool -> Type) = Eval ((Any (IsPrefixOf xs) :: [[a]] -> Bool -> Type) =<< Tails ys)
type Eval (IsPrefixOf xs ys :: Bool -> Type)
Instance details Defined in Fcf.Data.List type Eval (IsPrefixOf xs ys :: Bool -> Type) = IsPrefixOf_ xs ys
type Eval (IsSuffixOf xs ys :: Bool -> Type)
Instance details Defined in Fcf.Data.List type Eval (IsSuffixOf xs ys :: Bool -> Type) = Eval (IsPrefixOf ((Reverse :: [a] -> [a] -> Type) @@ xs) ((Reverse :: [a] -> [a] -> Type) @@ ys))
type Eval (All p lst :: Bool -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (All p lst :: Bool -> Type) = Eval (Foldr (Bicomap p (Pure :: Bool -> Bool -> Type) (&&)) 'True lst)
type Eval (Any p lst :: Bool -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (Any p lst :: Bool -> Type) = Eval (Foldr (Bicomap p (Pure :: Bool -> Bool -> Type) (\|\|)) 'False lst)
type Eval (TyEq a b :: Bool -> Type)
Instance details Defined in Fcf.Utils type Eval (TyEq a b :: Bool -> Type) = TyEqImpl a b
type Eval (TyEqSing a b :: Bool -> Type)
Instance details Defined in Morley.Util.Fcf type Eval (TyEqSing a b :: Bool -> Type) = DefaultEq a b
type Apply AndSym0 (a6989586621679732059 :: [Bool])
Instance details Defined in Data.List.Singletons.Internal type Apply AndSym0 (a6989586621679732059 :: [Bool]) = And a6989586621679732059
type Apply OrSym0 (a6989586621679732054 :: [Bool])
Instance details Defined in Data.List.Singletons.Internal type Apply OrSym0 (a6989586621679732054 :: [Bool]) = Or a6989586621679732054
type Apply (Null_6989586621680392273Sym0 :: TyFun (Identity a) Bool -> Type) (a6989586621680392277 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Null_6989586621680392273Sym0 :: TyFun (Identity a) Bool -> Type) (a6989586621680392277 :: Identity a) = Null_6989586621680392273 a6989586621680392277
type Apply (Null_6989586621680194400Sym0 :: TyFun (Dual a) Bool -> Type) (a6989586621680194404 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680194400Sym0 :: TyFun (Dual a) Bool -> Type) (a6989586621680194404 :: Dual a) = Null_6989586621680194400 a6989586621680194404
type Apply (Null_6989586621680194750Sym0 :: TyFun (Product a) Bool -> Type) (a6989586621680194754 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680194750Sym0 :: TyFun (Product a) Bool -> Type) (a6989586621680194754 :: Product a) = Null_6989586621680194750 a6989586621680194754
type Apply (Null_6989586621680194575Sym0 :: TyFun (Sum a) Bool -> Type) (a6989586621680194579 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680194575Sym0 :: TyFun (Sum a) Bool -> Type) (a6989586621680194579 :: Sum a) = Null_6989586621680194575 a6989586621680194579
type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679486210 :: Maybe a)
Instance details Defined in Data.Maybe.Singletons type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679486210 :: Maybe a) = IsJust a6989586621679486210
type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679486207 :: Maybe a)
Instance details Defined in Data.Maybe.Singletons type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679486207 :: Maybe a) = IsNothing a6989586621679486207
type Apply (Null_6989586621680193994Sym0 :: TyFun [a] Bool -> Type) (a6989586621680194000 :: [a])
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680193994Sym0 :: TyFun [a] Bool -> Type) (a6989586621680194000 :: [a]) = Null_6989586621680193994 a6989586621680194000
type Apply (NullSym0 :: TyFun [a] Bool -> Type) (a6989586621679732232 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (NullSym0 :: TyFun [a] Bool -> Type) (a6989586621679732232 :: [a]) = Null a6989586621679732232
type Apply (ListnullSym0 :: TyFun [a] Bool -> Type) (a6989586621680001977 :: [a])
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListnullSym0 :: TyFun [a] Bool -> Type) (a6989586621680001977 :: [a]) = Listnull a6989586621680001977
type Apply (AndSym0 :: TyFun (t Bool) Bool -> Type) (a6989586621680193369 :: t Bool)
Instance details Defined in Data.Foldable.Singletons type Apply (AndSym0 :: TyFun (t Bool) Bool -> Type) (a6989586621680193369 :: t Bool) = And a6989586621680193369
type Apply (OrSym0 :: TyFun (t Bool) Bool -> Type) (a6989586621680193363 :: t Bool)
Instance details Defined in Data.Foldable.Singletons type Apply (OrSym0 :: TyFun (t Bool) Bool -> Type) (a6989586621680193363 :: t Bool) = Or a6989586621680193363
type Apply (TFHelper_6989586621679131006Sym1 a6989586621679131011 :: TyFun (Identity a) Bool -> Type) (a6989586621679131012 :: Identity a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679131006Sym1 a6989586621679131011 :: TyFun (Identity a) Bool -> Type) (a6989586621679131012 :: Identity a) = TFHelper_6989586621679131006 a6989586621679131011 a6989586621679131012
type Apply (Elem_6989586621680392157Sym1 a6989586621680392162 :: TyFun (Identity a) Bool -> Type) (a6989586621680392163 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Elem_6989586621680392157Sym1 a6989586621680392162 :: TyFun (Identity a) Bool -> Type) (a6989586621680392163 :: Identity a) = Elem_6989586621680392157 a6989586621680392162 a6989586621680392163
type Apply (TFHelper_6989586621680109664Sym1 a6989586621680109669 :: TyFun (First a) Bool -> Type) (a6989586621680109670 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680109664Sym1 a6989586621680109669 :: TyFun (First a) Bool -> Type) (a6989586621680109670 :: First a) = TFHelper_6989586621680109664 a6989586621680109669 a6989586621680109670
type Apply (TFHelper_6989586621680109684Sym1 a6989586621680109689 :: TyFun (Last a) Bool -> Type) (a6989586621680109690 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680109684Sym1 a6989586621680109689 :: TyFun (Last a) Bool -> Type) (a6989586621680109690 :: Last a) = TFHelper_6989586621680109684 a6989586621680109689 a6989586621680109690
type Apply (TFHelper_6989586621679179231Sym1 a6989586621679179236 :: TyFun (Down a) Bool -> Type) (a6989586621679179237 :: Down a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679179231Sym1 a6989586621679179236 :: TyFun (Down a) Bool -> Type) (a6989586621679179237 :: Down a) = TFHelper_6989586621679179231 a6989586621679179236 a6989586621679179237
type Apply (TFHelper_6989586621679606240Sym1 a6989586621679606245 :: TyFun (First a) Bool -> Type) (a6989586621679606246 :: First a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606240Sym1 a6989586621679606245 :: TyFun (First a) Bool -> Type) (a6989586621679606246 :: First a) = TFHelper_6989586621679606240 a6989586621679606245 a6989586621679606246
type Apply (TFHelper_6989586621679606260Sym1 a6989586621679606265 :: TyFun (Last a) Bool -> Type) (a6989586621679606266 :: Last a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606260Sym1 a6989586621679606265 :: TyFun (Last a) Bool -> Type) (a6989586621679606266 :: Last a) = TFHelper_6989586621679606260 a6989586621679606265 a6989586621679606266
type Apply (TFHelper_6989586621679606220Sym1 a6989586621679606225 :: TyFun (Max a) Bool -> Type) (a6989586621679606226 :: Max a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606220Sym1 a6989586621679606225 :: TyFun (Max a) Bool -> Type) (a6989586621679606226 :: Max a) = TFHelper_6989586621679606220 a6989586621679606225 a6989586621679606226
type Apply (TFHelper_6989586621679606200Sym1 a6989586621679606205 :: TyFun (Min a) Bool -> Type) (a6989586621679606206 :: Min a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606200Sym1 a6989586621679606205 :: TyFun (Min a) Bool -> Type) (a6989586621679606206 :: Min a) = TFHelper_6989586621679606200 a6989586621679606205 a6989586621679606206
type Apply (TFHelper_6989586621679606280Sym1 a6989586621679606285 :: TyFun (WrappedMonoid m) Bool -> Type) (a6989586621679606286 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606280Sym1 a6989586621679606285 :: TyFun (WrappedMonoid m) Bool -> Type) (a6989586621679606286 :: WrappedMonoid m) = TFHelper_6989586621679606280 a6989586621679606285 a6989586621679606286
type Apply (Elem_6989586621680194268Sym1 a6989586621680194277 :: TyFun (Dual a) Bool -> Type) (a6989586621680194278 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194268Sym1 a6989586621680194277 :: TyFun (Dual a) Bool -> Type) (a6989586621680194278 :: Dual a) = Elem_6989586621680194268 a6989586621680194277 a6989586621680194278
type Apply (TFHelper_6989586621679606106Sym1 a6989586621679606111 :: TyFun (Dual a) Bool -> Type) (a6989586621679606112 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606106Sym1 a6989586621679606111 :: TyFun (Dual a) Bool -> Type) (a6989586621679606112 :: Dual a) = TFHelper_6989586621679606106 a6989586621679606111 a6989586621679606112
type Apply (Elem_6989586621680194618Sym1 a6989586621680194627 :: TyFun (Product a) Bool -> Type) (a6989586621680194628 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194618Sym1 a6989586621680194627 :: TyFun (Product a) Bool -> Type) (a6989586621680194628 :: Product a) = Elem_6989586621680194618 a6989586621680194627 a6989586621680194628
type Apply (TFHelper_6989586621679606180Sym1 a6989586621679606185 :: TyFun (Product a) Bool -> Type) (a6989586621679606186 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606180Sym1 a6989586621679606185 :: TyFun (Product a) Bool -> Type) (a6989586621679606186 :: Product a) = TFHelper_6989586621679606180 a6989586621679606185 a6989586621679606186
type Apply (Elem_6989586621680194443Sym1 a6989586621680194452 :: TyFun (Sum a) Bool -> Type) (a6989586621680194453 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194443Sym1 a6989586621680194452 :: TyFun (Sum a) Bool -> Type) (a6989586621680194453 :: Sum a) = Elem_6989586621680194443 a6989586621680194452 a6989586621680194453
type Apply (TFHelper_6989586621679606160Sym1 a6989586621679606165 :: TyFun (Sum a) Bool -> Type) (a6989586621679606166 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606160Sym1 a6989586621679606165 :: TyFun (Sum a) Bool -> Type) (a6989586621679606166 :: Sum a) = TFHelper_6989586621679606160 a6989586621679606165 a6989586621679606166
type Apply (TFHelper_6989586621679130622Sym1 a6989586621679130627 :: TyFun (NonEmpty a) Bool -> Type) (a6989586621679130628 :: NonEmpty a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130622Sym1 a6989586621679130627 :: TyFun (NonEmpty a) Bool -> Type) (a6989586621679130628 :: NonEmpty a) = TFHelper_6989586621679130622 a6989586621679130627 a6989586621679130628
type Apply (TFHelper_6989586621679130516Sym1 a6989586621679130521 :: TyFun (Maybe a) Bool -> Type) (a6989586621679130522 :: Maybe a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130516Sym1 a6989586621679130521 :: TyFun (Maybe a) Bool -> Type) (a6989586621679130522 :: Maybe a) = TFHelper_6989586621679130516 a6989586621679130521 a6989586621679130522
type Apply (TFHelper_6989586621679130547Sym1 a6989586621679130552 :: TyFun [a] Bool -> Type) (a6989586621679130553 :: [a])
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130547Sym1 a6989586621679130552 :: TyFun [a] Bool -> Type) (a6989586621679130553 :: [a]) = TFHelper_6989586621679130547 a6989586621679130552 a6989586621679130553
type Apply (Elem_6989586621680193860Sym1 a6989586621680193869 :: TyFun [a] Bool -> Type) (a6989586621680193870 :: [a])
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680193860Sym1 a6989586621680193869 :: TyFun [a] Bool -> Type) (a6989586621680193870 :: [a]) = Elem_6989586621680193860 a6989586621680193869 a6989586621680193870
type Apply (AllSym1 a6989586621679732047 :: TyFun [a] Bool -> Type) (a6989586621679732048 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (AllSym1 a6989586621679732047 :: TyFun [a] Bool -> Type) (a6989586621679732048 :: [a]) = All a6989586621679732047 a6989586621679732048
type Apply (AnySym1 a6989586621679732039 :: TyFun [a] Bool -> Type) (a6989586621679732040 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (AnySym1 a6989586621679732039 :: TyFun [a] Bool -> Type) (a6989586621679732040 :: [a]) = Any a6989586621679732039 a6989586621679732040
type Apply (ElemSym1 a6989586621679731822 :: TyFun [a] Bool -> Type) (a6989586621679731823 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (ElemSym1 a6989586621679731822 :: TyFun [a] Bool -> Type) (a6989586621679731823 :: [a]) = Elem a6989586621679731822 a6989586621679731823
type Apply (IsInfixOfSym1 a6989586621679731830 :: TyFun [a] Bool -> Type) (a6989586621679731831 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (IsInfixOfSym1 a6989586621679731830 :: TyFun [a] Bool -> Type) (a6989586621679731831 :: [a]) = IsInfixOf a6989586621679731830 a6989586621679731831
type Apply (IsPrefixOfSym1 a6989586621679731844 :: TyFun [a] Bool -> Type) (a6989586621679731845 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (IsPrefixOfSym1 a6989586621679731844 :: TyFun [a] Bool -> Type) (a6989586621679731845 :: [a]) = IsPrefixOf a6989586621679731844 a6989586621679731845
type Apply (IsSuffixOfSym1 a6989586621679731837 :: TyFun [a] Bool -> Type) (a6989586621679731838 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (IsSuffixOfSym1 a6989586621679731837 :: TyFun [a] Bool -> Type) (a6989586621679731838 :: [a]) = IsSuffixOf a6989586621679731837 a6989586621679731838
type Apply (NotElemSym1 a6989586621679731814 :: TyFun [a] Bool -> Type) (a6989586621679731815 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (NotElemSym1 a6989586621679731814 :: TyFun [a] Bool -> Type) (a6989586621679731815 :: [a]) = NotElem a6989586621679731814 a6989586621679731815
type Apply (ListelemSym1 a6989586621680002068 :: TyFun [a] Bool -> Type) (a6989586621680002069 :: [a])
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListelemSym1 a6989586621680002068 :: TyFun [a] Bool -> Type) (a6989586621680002069 :: [a]) = Listelem a6989586621680002068 a6989586621680002069
type Apply (ListisPrefixOfSym1 a6989586621680002140 :: TyFun [a] Bool -> Type) (a6989586621680002141 :: [a])
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListisPrefixOfSym1 a6989586621680002140 :: TyFun [a] Bool -> Type) (a6989586621680002141 :: [a]) = ListisPrefixOf a6989586621680002140 a6989586621680002141
type Apply (Elem_bySym2 a6989586621679731050 a6989586621679731051 :: TyFun [a] Bool -> Type) (a6989586621679731052 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (Elem_bySym2 a6989586621679731050 a6989586621679731051 :: TyFun [a] Bool -> Type) (a6989586621679731052 :: [a]) = Elem_by a6989586621679731050 a6989586621679731051 a6989586621679731052
type Apply (AllSym1 a6989586621680193346 :: TyFun (t a) Bool -> Type) (a6989586621680193347 :: t a)
Instance details Defined in Data.Foldable.Singletons type Apply (AllSym1 a6989586621680193346 :: TyFun (t a) Bool -> Type) (a6989586621680193347 :: t a) = All a6989586621680193346 a6989586621680193347
type Apply (AnySym1 a6989586621680193355 :: TyFun (t a) Bool -> Type) (a6989586621680193356 :: t a)
Instance details Defined in Data.Foldable.Singletons type Apply (AnySym1 a6989586621680193355 :: TyFun (t a) Bool -> Type) (a6989586621680193356 :: t a) = Any a6989586621680193355 a6989586621680193356
type Apply (ElemSym1 a6989586621680193550 :: TyFun (t a) Bool -> Type) (a6989586621680193551 :: t a)
Instance details Defined in Data.Foldable.Singletons type Apply (ElemSym1 a6989586621680193550 :: TyFun (t a) Bool -> Type) (a6989586621680193551 :: t a) = Elem a6989586621680193550 a6989586621680193551
type Apply (Elem_6989586621680193750Sym1 a6989586621680193759 :: TyFun (t a) Bool -> Type) (a6989586621680193760 :: t a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680193750Sym1 a6989586621680193759 :: TyFun (t a) Bool -> Type) (a6989586621680193760 :: t a) = Elem_6989586621680193750 a6989586621680193759 a6989586621680193760
type Apply (NotElemSym1 a6989586621680193297 :: TyFun (t a) Bool -> Type) (a6989586621680193298 :: t a)
Instance details Defined in Data.Foldable.Singletons type Apply (NotElemSym1 a6989586621680193297 :: TyFun (t a) Bool -> Type) (a6989586621680193298 :: t a) = NotElem a6989586621680193297 a6989586621680193298
type Apply (NullSym0 :: TyFun (t a) Bool -> Type) (a6989586621680193543 :: t a)
Instance details Defined in Data.Foldable.Singletons type Apply (NullSym0 :: TyFun (t a) Bool -> Type) (a6989586621680193543 :: t a) = Null a6989586621680193543
type Apply (Null_6989586621680193714Sym0 :: TyFun (t a) Bool -> Type) (a6989586621680193720 :: t a)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680193714Sym0 :: TyFun (t a) Bool -> Type) (a6989586621680193720 :: t a) = Null_6989586621680193714 a6989586621680193720
type Apply (TFHelper_6989586621679131006Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type) (a6989586621679131011 :: Identity a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679131006Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type) (a6989586621679131011 :: Identity a) = TFHelper_6989586621679131006Sym1 a6989586621679131011
type Apply (TFHelper_6989586621680109664Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) (a6989586621680109669 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680109664Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) (a6989586621680109669 :: First a) = TFHelper_6989586621680109664Sym1 a6989586621680109669
type Apply (TFHelper_6989586621680109684Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) (a6989586621680109689 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680109684Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) (a6989586621680109689 :: Last a) = TFHelper_6989586621680109684Sym1 a6989586621680109689
type Apply (TFHelper_6989586621679179231Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type) (a6989586621679179236 :: Down a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679179231Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type) (a6989586621679179236 :: Down a) = TFHelper_6989586621679179231Sym1 a6989586621679179236
type Apply (TFHelper_6989586621679606240Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) (a6989586621679606245 :: First a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606240Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) (a6989586621679606245 :: First a) = TFHelper_6989586621679606240Sym1 a6989586621679606245
type Apply (TFHelper_6989586621679606260Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) (a6989586621679606265 :: Last a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606260Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) (a6989586621679606265 :: Last a) = TFHelper_6989586621679606260Sym1 a6989586621679606265
type Apply (TFHelper_6989586621679606220Sym0 :: TyFun (Max a) (Max a ~> Bool) -> Type) (a6989586621679606225 :: Max a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606220Sym0 :: TyFun (Max a) (Max a ~> Bool) -> Type) (a6989586621679606225 :: Max a) = TFHelper_6989586621679606220Sym1 a6989586621679606225
type Apply (TFHelper_6989586621679606200Sym0 :: TyFun (Min a) (Min a ~> Bool) -> Type) (a6989586621679606205 :: Min a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606200Sym0 :: TyFun (Min a) (Min a ~> Bool) -> Type) (a6989586621679606205 :: Min a) = TFHelper_6989586621679606200Sym1 a6989586621679606205
type Apply (TFHelper_6989586621679606280Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type) (a6989586621679606285 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606280Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type) (a6989586621679606285 :: WrappedMonoid m) = TFHelper_6989586621679606280Sym1 a6989586621679606285
type Apply (TFHelper_6989586621679606106Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type) (a6989586621679606111 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606106Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type) (a6989586621679606111 :: Dual a) = TFHelper_6989586621679606106Sym1 a6989586621679606111
type Apply (TFHelper_6989586621679606180Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type) (a6989586621679606185 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606180Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type) (a6989586621679606185 :: Product a) = TFHelper_6989586621679606180Sym1 a6989586621679606185
type Apply (TFHelper_6989586621679606160Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type) (a6989586621679606165 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606160Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type) (a6989586621679606165 :: Sum a) = TFHelper_6989586621679606160Sym1 a6989586621679606165
type Apply (TFHelper_6989586621679130622Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type) (a6989586621679130627 :: NonEmpty a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130622Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type) (a6989586621679130627 :: NonEmpty a) = TFHelper_6989586621679130622Sym1 a6989586621679130627
type Apply (TFHelper_6989586621679130516Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type) (a6989586621679130521 :: Maybe a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130516Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type) (a6989586621679130521 :: Maybe a) = TFHelper_6989586621679130516Sym1 a6989586621679130521
type Apply (TFHelper_6989586621679130547Sym0 :: TyFun [a] ([a] ~> Bool) -> Type) (a6989586621679130552 :: [a])
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130547Sym0 :: TyFun [a] ([a] ~> Bool) -> Type) (a6989586621679130552 :: [a]) = TFHelper_6989586621679130547Sym1 a6989586621679130552
type Apply (IsInfixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type) (a6989586621679731830 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (IsInfixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type) (a6989586621679731830 :: [a]) = IsInfixOfSym1 a6989586621679731830
type Apply (IsPrefixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type) (a6989586621679731844 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (IsPrefixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type) (a6989586621679731844 :: [a]) = IsPrefixOfSym1 a6989586621679731844
type Apply (IsSuffixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type) (a6989586621679731837 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (IsSuffixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type) (a6989586621679731837 :: [a]) = IsSuffixOfSym1 a6989586621679731837
type Apply (ListisPrefixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type) (a6989586621680002140 :: [a])
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListisPrefixOfSym0 :: TyFun [a] ([a] ~> Bool) -> Type) (a6989586621680002140 :: [a]) = ListisPrefixOfSym1 a6989586621680002140
type Apply (Let6989586621679731363Scrutinee_6989586621679727542Sym1 x6989586621679731361 :: TyFun [a] (TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type) -> Type) (xs6989586621679731362 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731363Scrutinee_6989586621679727542Sym1 x6989586621679731361 :: TyFun [a] (TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type) -> Type) (xs6989586621679731362 :: [a]) = Let6989586621679731363Scrutinee_6989586621679727542Sym2 x6989586621679731361 xs6989586621679731362 :: TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type
type Apply (Let6989586621679731071Scrutinee_6989586621679727570Sym2 y6989586621679731068 ys6989586621679731069 :: TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type) (xs6989586621679731070 :: [k1])
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731071Scrutinee_6989586621679727570Sym2 y6989586621679731068 ys6989586621679731069 :: TyFun [k1] (TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) -> Type) (xs6989586621679731070 :: [k1]) = Let6989586621679731071Scrutinee_6989586621679727570Sym3 y6989586621679731068 ys6989586621679731069 xs6989586621679731070 :: TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type
type Apply (Let6989586621679731087Scrutinee_6989586621679727568Sym2 x6989586621679731084 xs6989586621679731085 :: TyFun [k1] (TyFun k3 Bool -> Type) -> Type) (ls6989586621679731086 :: [k1])
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731087Scrutinee_6989586621679727568Sym2 x6989586621679731084 xs6989586621679731085 :: TyFun [k1] (TyFun k3 Bool -> Type) -> Type) (ls6989586621679731086 :: [k1]) = Let6989586621679731087Scrutinee_6989586621679727568Sym3 x6989586621679731084 xs6989586621679731085 ls6989586621679731086 :: TyFun k3 Bool -> Type
type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621679277095 :: Either a b)
Instance details Defined in Data.Either.Singletons type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621679277095 :: Either a b) = IsLeft a6989586621679277095
type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621679277092 :: Either a b)
Instance details Defined in Data.Either.Singletons type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621679277092 :: Either a b) = IsRight a6989586621679277092
type Apply (Null_6989586621680194155Sym0 :: TyFun (Either a1 a2) Bool -> Type) (a6989586621680194161 :: Either a1 a2)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680194155Sym0 :: TyFun (Either a1 a2) Bool -> Type) (a6989586621680194161 :: Either a1 a2) = Null_6989586621680194155 a6989586621680194161
type Apply (Elem_6989586621680194236Sym1 a6989586621680194241 :: TyFun (Proxy a) Bool -> Type) (a6989586621680194242 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194236Sym1 a6989586621680194241 :: TyFun (Proxy a) Bool -> Type) (a6989586621680194242 :: Proxy a) = Elem_6989586621680194236 a6989586621680194241 a6989586621680194242
type Apply (Null_6989586621680194229Sym0 :: TyFun (Proxy a) Bool -> Type) (a6989586621680194233 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680194229Sym0 :: TyFun (Proxy a) Bool -> Type) (a6989586621680194233 :: Proxy a) = Null_6989586621680194229 a6989586621680194233
type Apply (TFHelper_6989586621679130594Sym1 a6989586621679130599 :: TyFun (Either a b) Bool -> Type) (a6989586621679130600 :: Either a b)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130594Sym1 a6989586621679130599 :: TyFun (Either a b) Bool -> Type) (a6989586621679130600 :: Either a b) = TFHelper_6989586621679130594 a6989586621679130599 a6989586621679130600
type Apply (TFHelper_6989586621680163384Sym1 a6989586621680163389 :: TyFun (Proxy s) Bool -> Type) (a6989586621680163390 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680163384Sym1 a6989586621680163389 :: TyFun (Proxy s) Bool -> Type) (a6989586621680163390 :: Proxy s) = TFHelper_6989586621680163384 a6989586621680163389 a6989586621680163390
type Apply (TFHelper_6989586621680605296Sym1 a6989586621680605301 :: TyFun (Arg a b) Bool -> Type) (a6989586621680605302 :: Arg a b)
Instance details Defined in Data.Semigroup.Singletons type Apply (TFHelper_6989586621680605296Sym1 a6989586621680605301 :: TyFun (Arg a b) Bool -> Type) (a6989586621680605302 :: Arg a b) = TFHelper_6989586621680605296 a6989586621680605301 a6989586621680605302
type Apply (TFHelper_6989586621679130662Sym1 a6989586621679130667 :: TyFun (a, b) Bool -> Type) (a6989586621679130668 :: (a, b))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130662Sym1 a6989586621679130667 :: TyFun (a, b) Bool -> Type) (a6989586621679130668 :: (a, b)) = TFHelper_6989586621679130662 a6989586621679130667 a6989586621679130668
type Apply (DeleteFirstsBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type) (a6989586621679731576 :: a ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (DeleteFirstsBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type) (a6989586621679731576 :: a ~> (a ~> Bool)) = DeleteFirstsBySym1 a6989586621679731576
type Apply (IntersectBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type) (a6989586621679731401 :: a ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (IntersectBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type) (a6989586621679731401 :: a ~> (a ~> Bool)) = IntersectBySym1 a6989586621679731401
type Apply (UnionBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type) (a6989586621679731040 :: a ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (UnionBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> ([a] ~> [a])) -> Type) (a6989586621679731040 :: a ~> (a ~> Bool)) = UnionBySym1 a6989586621679731040
type Apply (GroupBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [[a]]) -> Type) (a6989586621679731193 :: a ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (GroupBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [[a]]) -> Type) (a6989586621679731193 :: a ~> (a ~> Bool)) = GroupBySym1 a6989586621679731193
type Apply (NubBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [a]) -> Type) (a6989586621679731060 :: a ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (NubBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [a]) -> Type) (a6989586621679731060 :: a ~> (a ~> Bool)) = NubBySym1 a6989586621679731060
type Apply (ListnubBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [a]) -> Type) (a6989586621680002102 :: a ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListnubBySym0 :: TyFun (a ~> (a ~> Bool)) ([a] ~> [a]) -> Type) (a6989586621680002102 :: a ~> (a ~> Bool)) = ListnubBySym1 a6989586621680002102
type Apply (Elem_bySym0 :: TyFun (a ~> (a ~> Bool)) (a ~> ([a] ~> Bool)) -> Type) (a6989586621679731050 :: a ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (Elem_bySym0 :: TyFun (a ~> (a ~> Bool)) (a ~> ([a] ~> Bool)) -> Type) (a6989586621679731050 :: a ~> (a ~> Bool)) = Elem_bySym1 a6989586621679731050
type Apply (DeleteBySym0 :: TyFun (a ~> (a ~> Bool)) (a ~> ([a] ~> [a])) -> Type) (a6989586621679731586 :: a ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (DeleteBySym0 :: TyFun (a ~> (a ~> Bool)) (a ~> ([a] ~> [a])) -> Type) (a6989586621679731586 :: a ~> (a ~> Bool)) = DeleteBySym1 a6989586621679731586
type Apply (UntilSym0 :: TyFun (a ~> Bool) ((a ~> a) ~> (a ~> a)) -> Type) (a6989586621679248366 :: a ~> Bool)
Instance details Defined in GHC.Base.Singletons type Apply (UntilSym0 :: TyFun (a ~> Bool) ((a ~> a) ~> (a ~> a)) -> Type) (a6989586621679248366 :: a ~> Bool) = UntilSym1 a6989586621679248366
type Apply (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type) (a6989586621679731453 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type) (a6989586621679731453 :: a ~> Bool) = FindIndexSym1 a6989586621679731453
type Apply (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type) (a6989586621679731480 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type) (a6989586621679731480 :: a ~> Bool) = FindSym1 a6989586621679731480
type Apply (BreakSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type) (a6989586621679731283 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (BreakSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type) (a6989586621679731283 :: a ~> Bool) = BreakSym1 a6989586621679731283
type Apply (PartitionSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type) (a6989586621679731171 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (PartitionSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type) (a6989586621679731171 :: a ~> Bool) = PartitionSym1 a6989586621679731171
type Apply (SpanSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type) (a6989586621679731318 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (SpanSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type) (a6989586621679731318 :: a ~> Bool) = SpanSym1 a6989586621679731318
type Apply (ListpartitionSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type) (a6989586621680002162 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListpartitionSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type) (a6989586621680002162 :: a ~> Bool) = ListpartitionSym1 a6989586621680002162
type Apply (ListspanSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type) (a6989586621680002184 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListspanSym0 :: TyFun (a ~> Bool) ([a] ~> ([a], [a])) -> Type) (a6989586621680002184 :: a ~> Bool) = ListspanSym1 a6989586621680002184
type Apply (AllSym0 :: TyFun (a ~> Bool) ([a] ~> Bool) -> Type) (a6989586621679732047 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (AllSym0 :: TyFun (a ~> Bool) ([a] ~> Bool) -> Type) (a6989586621679732047 :: a ~> Bool) = AllSym1 a6989586621679732047
type Apply (AnySym0 :: TyFun (a ~> Bool) ([a] ~> Bool) -> Type) (a6989586621679732039 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (AnySym0 :: TyFun (a ~> Bool) ([a] ~> Bool) -> Type) (a6989586621679732039 :: a ~> Bool) = AnySym1 a6989586621679732039
type Apply (FindIndicesSym0 :: TyFun (a ~> Bool) ([a] ~> [Nat]) -> Type) (a6989586621679731430 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (FindIndicesSym0 :: TyFun (a ~> Bool) ([a] ~> [Nat]) -> Type) (a6989586621679731430 :: a ~> Bool) = FindIndicesSym1 a6989586621679731430
type Apply (DropWhileEndSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621679731355 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (DropWhileEndSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621679731355 :: a ~> Bool) = DropWhileEndSym1 a6989586621679731355
type Apply (DropWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621679731372 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (DropWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621679731372 :: a ~> Bool) = DropWhileSym1 a6989586621679731372
type Apply (FilterSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621679731487 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (FilterSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621679731487 :: a ~> Bool) = FilterSym1 a6989586621679731487
type Apply (TakeWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621679731387 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (TakeWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621679731387 :: a ~> Bool) = TakeWhileSym1 a6989586621679731387
type Apply (ListdropWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621680002195 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListdropWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621680002195 :: a ~> Bool) = ListdropWhileSym1 a6989586621680002195
type Apply (ListfilterSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621680002173 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListfilterSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621680002173 :: a ~> Bool) = ListfilterSym1 a6989586621680002173
type Apply (ListtakeWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621680002206 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListtakeWhileSym0 :: TyFun (a ~> Bool) ([a] ~> [a]) -> Type) (a6989586621680002206 :: a ~> Bool) = ListtakeWhileSym1 a6989586621680002206
type Apply (SelectSym0 :: TyFun (a ~> Bool) (a ~> (([a], [a]) ~> ([a], [a]))) -> Type) (a6989586621679731156 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (SelectSym0 :: TyFun (a ~> Bool) (a ~> (([a], [a]) ~> ([a], [a]))) -> Type) (a6989586621679731156 :: a ~> Bool) = SelectSym1 a6989586621679731156
type Apply (Let6989586621679731296X_6989586621679731297Sym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] ([k], [k]) -> Type) -> Type) -> Type) (p6989586621679731287 :: k ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731296X_6989586621679731297Sym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] ([k], [k]) -> Type) -> Type) -> Type) (p6989586621679731287 :: k ~> Bool) = Let6989586621679731296X_6989586621679731297Sym1 p6989586621679731287
type Apply (Let6989586621679731331X_6989586621679731332Sym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] ([k], [k]) -> Type) -> Type) -> Type) (p6989586621679731322 :: k ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731331X_6989586621679731332Sym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] ([k], [k]) -> Type) -> Type) -> Type) (p6989586621679731322 :: k ~> Bool) = Let6989586621679731331X_6989586621679731332Sym1 p6989586621679731322
type Apply (Let6989586621679731296YsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type) (p6989586621679731287 :: k ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731296YsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type) (p6989586621679731287 :: k ~> Bool) = Let6989586621679731296YsSym1 p6989586621679731287
type Apply (Let6989586621679731296ZsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type) (p6989586621679731287 :: k ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731296ZsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type) (p6989586621679731287 :: k ~> Bool) = Let6989586621679731296ZsSym1 p6989586621679731287
type Apply (Let6989586621679731331YsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type) (p6989586621679731322 :: k ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731331YsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type) (p6989586621679731322 :: k ~> Bool) = Let6989586621679731331YsSym1 p6989586621679731322
type Apply (Let6989586621679731331ZsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type) (p6989586621679731322 :: k ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731331ZsSym0 :: TyFun (k ~> Bool) (TyFun k (TyFun [k] [k] -> Type) -> Type) -> Type) (p6989586621679731322 :: k ~> Bool) = Let6989586621679731331ZsSym1 p6989586621679731322
type Apply (TFHelper_6989586621679130594Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type) (a6989586621679130599 :: Either a b)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130594Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type) (a6989586621679130599 :: Either a b) = TFHelper_6989586621679130594Sym1 a6989586621679130599
type Apply (TFHelper_6989586621680163384Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) (a6989586621680163389 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680163384Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) (a6989586621680163389 :: Proxy s) = TFHelper_6989586621680163384Sym1 a6989586621680163389
type Apply (TFHelper_6989586621680605296Sym0 :: TyFun (Arg a b) (Arg a b ~> Bool) -> Type) (a6989586621680605301 :: Arg a b)
Instance details Defined in Data.Semigroup.Singletons type Apply (TFHelper_6989586621680605296Sym0 :: TyFun (Arg a b) (Arg a b ~> Bool) -> Type) (a6989586621680605301 :: Arg a b) = TFHelper_6989586621680605296Sym1 a6989586621680605301
type Apply (MfilterSym0 :: TyFun (a ~> Bool) (m a ~> m a) -> Type) (a6989586621680892560 :: a ~> Bool)
Instance details Defined in Control.Monad.Singletons type Apply (MfilterSym0 :: TyFun (a ~> Bool) (m a ~> m a) -> Type) (a6989586621680892560 :: a ~> Bool) = MfilterSym1 a6989586621680892560 :: TyFun (m a) (m a) -> Type
type Apply (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type) (a6989586621680193279 :: a ~> Bool)
Instance details Defined in Data.Foldable.Singletons type Apply (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type) (a6989586621680193279 :: a ~> Bool) = FindSym1 a6989586621680193279 :: TyFun (t a) (Maybe a) -> Type
type Apply (AllSym0 :: TyFun (a ~> Bool) (t a ~> Bool) -> Type) (a6989586621680193346 :: a ~> Bool)
Instance details Defined in Data.Foldable.Singletons type Apply (AllSym0 :: TyFun (a ~> Bool) (t a ~> Bool) -> Type) (a6989586621680193346 :: a ~> Bool) = AllSym1 a6989586621680193346 :: TyFun (t a) Bool -> Type
type Apply (AnySym0 :: TyFun (a ~> Bool) (t a ~> Bool) -> Type) (a6989586621680193355 :: a ~> Bool)
Instance details Defined in Data.Foldable.Singletons type Apply (AnySym0 :: TyFun (a ~> Bool) (t a ~> Bool) -> Type) (a6989586621680193355 :: a ~> Bool) = AnySym1 a6989586621680193355 :: TyFun (t a) Bool -> Type
type Apply (Lambda_6989586621680193283Sym0 :: TyFun (a ~> Bool) (TyFun k (TyFun a (First a) -> Type) -> Type) -> Type) (p6989586621680193281 :: a ~> Bool)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680193283Sym0 :: TyFun (a ~> Bool) (TyFun k (TyFun a (First a) -> Type) -> Type) -> Type) (p6989586621680193281 :: a ~> Bool) = Lambda_6989586621680193283Sym1 p6989586621680193281 :: TyFun k (TyFun a (First a) -> Type) -> Type
type Apply (Lambda_6989586621679731359Sym0 :: TyFun (a ~> Bool) (TyFun k (TyFun a (TyFun [a] [a] -> Type) -> Type) -> Type) -> Type) (p6989586621679731357 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (Lambda_6989586621679731359Sym0 :: TyFun (a ~> Bool) (TyFun k (TyFun a (TyFun [a] [a] -> Type) -> Type) -> Type) -> Type) (p6989586621679731357 :: a ~> Bool) = Lambda_6989586621679731359Sym1 p6989586621679731357 :: TyFun k (TyFun a (TyFun [a] [a] -> Type) -> Type) -> Type
type Apply (FilterMSym0 :: TyFun (a ~> m Bool) ([a] ~> m [a]) -> Type) (a6989586621680892722 :: a ~> m Bool)
Instance details Defined in Control.Monad.Singletons type Apply (FilterMSym0 :: TyFun (a ~> m Bool) ([a] ~> m [a]) -> Type) (a6989586621680892722 :: a ~> m Bool) = FilterMSym1 a6989586621680892722
type Apply (Let6989586621679731198X_6989586621679731199Sym0 :: TyFun (k1 ~> (a ~> Bool)) (TyFun k1 (TyFun [a] ([a], [a]) -> Type) -> Type) -> Type) (eq6989586621679731195 :: k1 ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731198X_6989586621679731199Sym0 :: TyFun (k1 ~> (a ~> Bool)) (TyFun k1 (TyFun [a] ([a], [a]) -> Type) -> Type) -> Type) (eq6989586621679731195 :: k1 ~> (a ~> Bool)) = Let6989586621679731198X_6989586621679731199Sym1 eq6989586621679731195
type Apply (Let6989586621679731198YsSym0 :: TyFun (k1 ~> (a ~> Bool)) (TyFun k1 (TyFun [a] [a] -> Type) -> Type) -> Type) (eq6989586621679731195 :: k1 ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731198YsSym0 :: TyFun (k1 ~> (a ~> Bool)) (TyFun k1 (TyFun [a] [a] -> Type) -> Type) -> Type) (eq6989586621679731195 :: k1 ~> (a ~> Bool)) = Let6989586621679731198YsSym1 eq6989586621679731195
type Apply (Let6989586621679731198ZsSym0 :: TyFun (k1 ~> (a ~> Bool)) (TyFun k1 (TyFun [a] [a] -> Type) -> Type) -> Type) (eq6989586621679731195 :: k1 ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731198ZsSym0 :: TyFun (k1 ~> (a ~> Bool)) (TyFun k1 (TyFun [a] [a] -> Type) -> Type) -> Type) (eq6989586621679731195 :: k1 ~> (a ~> Bool)) = Let6989586621679731198ZsSym1 eq6989586621679731195
type Apply (Let6989586621679731064NubBy'Sym0 :: TyFun (k1 ~> (k1 ~> Bool)) (TyFun k (TyFun [k1] ([k1] ~> [k1]) -> Type) -> Type) -> Type) (eq6989586621679731062 :: k1 ~> (k1 ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731064NubBy'Sym0 :: TyFun (k1 ~> (k1 ~> Bool)) (TyFun k (TyFun [k1] ([k1] ~> [k1]) -> Type) -> Type) -> Type) (eq6989586621679731062 :: k1 ~> (k1 ~> Bool)) = Let6989586621679731064NubBy'Sym1 eq6989586621679731062 :: TyFun k (TyFun [k1] ([k1] ~> [k1]) -> Type) -> Type
type Apply (Let6989586621679248372GoSym0 :: TyFun (k1 ~> Bool) (TyFun (k1 ~> k1) (TyFun k2 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) (p6989586621679248369 :: k1 ~> Bool)
Instance details Defined in GHC.Base.Singletons type Apply (Let6989586621679248372GoSym0 :: TyFun (k1 ~> Bool) (TyFun (k1 ~> k1) (TyFun k2 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) (p6989586621679248369 :: k1 ~> Bool) = Let6989586621679248372GoSym1 p6989586621679248369 :: TyFun (k1 ~> k1) (TyFun k2 (TyFun k1 k1 -> Type) -> Type) -> Type
type Apply (TFHelper_6989586621679130662Sym0 :: TyFun (a, b) ((a, b) ~> Bool) -> Type) (a6989586621679130667 :: (a, b))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130662Sym0 :: TyFun (a, b) ((a, b) ~> Bool) -> Type) (a6989586621679130667 :: (a, b)) = TFHelper_6989586621679130662Sym1 a6989586621679130667
type Apply (Lambda_6989586621680892564Sym0 :: TyFun (k1 ~> Bool) (TyFun k (TyFun k1 (m k1) -> Type) -> Type) -> Type) (p6989586621680892562 :: k1 ~> Bool)
Instance details Defined in Control.Monad.Singletons type Apply (Lambda_6989586621680892564Sym0 :: TyFun (k1 ~> Bool) (TyFun k (TyFun k1 (m k1) -> Type) -> Type) -> Type) (p6989586621680892562 :: k1 ~> Bool) = Lambda_6989586621680892564Sym1 p6989586621680892562 :: TyFun k (TyFun k1 (m k1) -> Type) -> Type
type Apply (Lambda_6989586621680892726Sym0 :: TyFun (k2 ~> f Bool) (TyFun k3 (TyFun k2 (f [k2] ~> f [k2]) -> Type) -> Type) -> Type) (p6989586621680892724 :: k2 ~> f Bool)
Instance details Defined in Control.Monad.Singletons type Apply (Lambda_6989586621680892726Sym0 :: TyFun (k2 ~> f Bool) (TyFun k3 (TyFun k2 (f [k2] ~> f [k2]) -> Type) -> Type) -> Type) (p6989586621680892724 :: k2 ~> f Bool) = Lambda_6989586621680892726Sym1 p6989586621680892724 :: TyFun k3 (TyFun k2 (f [k2] ~> f [k2]) -> Type) -> Type
type Apply (Lambda_6989586621679731412Sym0 :: TyFun (b ~> (a ~> Bool)) (TyFun k1 (TyFun k2 (TyFun a (TyFun [a] (TyFun b (m b) -> Type) -> Type) -> Type) -> Type) -> Type) -> Type) (eq6989586621679731404 :: b ~> (a ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (Lambda_6989586621679731412Sym0 :: TyFun (b ~> (a ~> Bool)) (TyFun k1 (TyFun k2 (TyFun a (TyFun [a] (TyFun b (m b) -> Type) -> Type) -> Type) -> Type) -> Type) -> Type) (eq6989586621679731404 :: b ~> (a ~> Bool)) = Lambda_6989586621679731412Sym1 eq6989586621679731404 :: TyFun k1 (TyFun k2 (TyFun a (TyFun [a] (TyFun b (m b) -> Type) -> Type) -> Type) -> Type) -> Type
type Apply (Let6989586621679731363Scrutinee_6989586621679727542Sym2 x6989586621679731361 xs6989586621679731362 :: TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type) (p6989586621679731357 :: k1 ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731363Scrutinee_6989586621679727542Sym2 x6989586621679731361 xs6989586621679731362 :: TyFun (k1 ~> Bool) (TyFun k Bool -> Type) -> Type) (p6989586621679731357 :: k1 ~> Bool) = Let6989586621679731363Scrutinee_6989586621679727542Sym3 x6989586621679731361 xs6989586621679731362 p6989586621679731357 :: TyFun k Bool -> Type
type Apply (Let6989586621679731071Scrutinee_6989586621679727570Sym3 y6989586621679731068 ys6989586621679731069 xs6989586621679731070 :: TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) (eq6989586621679731062 :: k1 ~> (k1 ~> Bool))
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731071Scrutinee_6989586621679727570Sym3 y6989586621679731068 ys6989586621679731069 xs6989586621679731070 :: TyFun (k1 ~> (k1 ~> Bool)) (TyFun k3 Bool -> Type) -> Type) (eq6989586621679731062 :: k1 ~> (k1 ~> Bool)) = Let6989586621679731071Scrutinee_6989586621679727570Sym4 y6989586621679731068 ys6989586621679731069 xs6989586621679731070 eq6989586621679731062 :: TyFun k3 Bool -> Type
type Apply (TFHelper_6989586621680428549Sym1 a6989586621680428554 :: TyFun (Const a b) Bool -> Type) (a6989586621680428555 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428549Sym1 a6989586621680428554 :: TyFun (Const a b) Bool -> Type) (a6989586621680428555 :: Const a b) = TFHelper_6989586621680428549 a6989586621680428554 a6989586621680428555
type Apply (TFHelper_6989586621679130700Sym1 a6989586621679130705 :: TyFun (a, b, c) Bool -> Type) (a6989586621679130706 :: (a, b, c))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130700Sym1 a6989586621679130705 :: TyFun (a, b, c) Bool -> Type) (a6989586621679130706 :: (a, b, c)) = TFHelper_6989586621679130700 a6989586621679130705 a6989586621679130706
type Apply (TFHelper_6989586621680428549Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type) (a6989586621680428554 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428549Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type) (a6989586621680428554 :: Const a b) = TFHelper_6989586621680428549Sym1 a6989586621680428554
type Apply (TFHelper_6989586621679130700Sym0 :: TyFun (a, b, c) ((a, b, c) ~> Bool) -> Type) (a6989586621679130705 :: (a, b, c))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130700Sym0 :: TyFun (a, b, c) ((a, b, c) ~> Bool) -> Type) (a6989586621679130705 :: (a, b, c)) = TFHelper_6989586621679130700Sym1 a6989586621679130705
type Apply (TFHelper_6989586621679130749Sym1 a6989586621679130754 :: TyFun (a, b, c, d) Bool -> Type) (a6989586621679130755 :: (a, b, c, d))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130749Sym1 a6989586621679130754 :: TyFun (a, b, c, d) Bool -> Type) (a6989586621679130755 :: (a, b, c, d)) = TFHelper_6989586621679130749 a6989586621679130754 a6989586621679130755
type Apply (TFHelper_6989586621679130749Sym0 :: TyFun (a, b, c, d) ((a, b, c, d) ~> Bool) -> Type) (a6989586621679130754 :: (a, b, c, d))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130749Sym0 :: TyFun (a, b, c, d) ((a, b, c, d) ~> Bool) -> Type) (a6989586621679130754 :: (a, b, c, d)) = TFHelper_6989586621679130749Sym1 a6989586621679130754
type Apply (TFHelper_6989586621679130809Sym1 a6989586621679130814 :: TyFun (a, b, c, d, e) Bool -> Type) (a6989586621679130815 :: (a, b, c, d, e))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130809Sym1 a6989586621679130814 :: TyFun (a, b, c, d, e) Bool -> Type) (a6989586621679130815 :: (a, b, c, d, e)) = TFHelper_6989586621679130809 a6989586621679130814 a6989586621679130815
type Apply (TFHelper_6989586621679130809Sym0 :: TyFun (a, b, c, d, e) ((a, b, c, d, e) ~> Bool) -> Type) (a6989586621679130814 :: (a, b, c, d, e))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130809Sym0 :: TyFun (a, b, c, d, e) ((a, b, c, d, e) ~> Bool) -> Type) (a6989586621679130814 :: (a, b, c, d, e)) = TFHelper_6989586621679130809Sym1 a6989586621679130814
type Apply (TFHelper_6989586621679130880Sym1 a6989586621679130885 :: TyFun (a, b, c, d, e, f) Bool -> Type) (a6989586621679130886 :: (a, b, c, d, e, f))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130880Sym1 a6989586621679130885 :: TyFun (a, b, c, d, e, f) Bool -> Type) (a6989586621679130886 :: (a, b, c, d, e, f)) = TFHelper_6989586621679130880 a6989586621679130885 a6989586621679130886
type Apply (TFHelper_6989586621679130880Sym0 :: TyFun (a, b, c, d, e, f) ((a, b, c, d, e, f) ~> Bool) -> Type) (a6989586621679130885 :: (a, b, c, d, e, f))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130880Sym0 :: TyFun (a, b, c, d, e, f) ((a, b, c, d, e, f) ~> Bool) -> Type) (a6989586621679130885 :: (a, b, c, d, e, f)) = TFHelper_6989586621679130880Sym1 a6989586621679130885
type Apply (TFHelper_6989586621679130962Sym1 a6989586621679130967 :: TyFun (a, b, c, d, e, f, g) Bool -> Type) (a6989586621679130968 :: (a, b, c, d, e, f, g))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130962Sym1 a6989586621679130967 :: TyFun (a, b, c, d, e, f, g) Bool -> Type) (a6989586621679130968 :: (a, b, c, d, e, f, g)) = TFHelper_6989586621679130962 a6989586621679130967 a6989586621679130968
type Apply (TFHelper_6989586621679130962Sym0 :: TyFun (a, b, c, d, e, f, g) ((a, b, c, d, e, f, g) ~> Bool) -> Type) (a6989586621679130967 :: (a, b, c, d, e, f, g))
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130962Sym0 :: TyFun (a, b, c, d, e, f, g) ((a, b, c, d, e, f, g) ~> Bool) -> Type) (a6989586621679130967 :: (a, b, c, d, e, f, g)) = TFHelper_6989586621679130962Sym1 a6989586621679130967

type String = [Char] #

A String is a list of characters. String constants in Haskell are values of type String.

See Data.List for operations on lists.

data Char #

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) code points (i.e. characters, see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char.

To convert a Char to or from the corresponding Int value defined by Unicode, use toEnum and fromEnum from the Enum class respectively (or equivalently ord and chr).

Instances

Instances details

Structured Char
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Char -> Structure # structureHash' :: Tagged Char MD5
Storable Char	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Char -> Int # alignment :: Char -> Int # peekElemOff :: Ptr Char -> Int -> IO Char # pokeElemOff :: Ptr Char -> Int -> Char -> IO () # peekByteOff :: Ptr b -> Int -> IO Char # pokeByteOff :: Ptr b -> Int -> Char -> IO () # peek :: Ptr Char -> IO Char # poke :: Ptr Char -> Char -> IO () #
Bounded Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char # maxBound :: Char #
Enum Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Char -> Char # pred :: Char -> Char # toEnum :: Int -> Char # fromEnum :: Char -> Int # enumFrom :: Char -> [Char] # enumFromThen :: Char -> Char -> [Char] # enumFromTo :: Char -> Char -> [Char] # enumFromThenTo :: Char -> Char -> Char -> [Char] #
Read Char	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Char # readList :: ReadS [Char] # readPrec :: ReadPrec Char # readListPrec :: ReadPrec [Char] #
Show Char	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Subtractive Char
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Char # Methods (-) :: Char -> Char -> Difference Char #
PrimMemoryComparable Char
Instance details Defined in Basement.PrimType
PrimType Char
Instance details Defined in Basement.PrimType Associated Types type PrimSize Char :: Nat # Methods primSizeInBytes :: Proxy Char -> CountOf Word8 # primShiftToBytes :: Proxy Char -> Int # primBaUIndex :: ByteArray# -> Offset Char -> Char # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> prim Char # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> Char -> prim () # primAddrIndex :: Addr# -> Offset Char -> Char # primAddrRead :: PrimMonad prim => Addr# -> Offset Char -> prim Char # primAddrWrite :: PrimMonad prim => Addr# -> Offset Char -> Char -> prim () #
NFData Char
Instance details Defined in Control.DeepSeq Methods rnf :: Char -> () #
Buildable Char
Instance details Defined in Formatting.Buildable Methods build :: Char -> Builder #
Eq Char
Instance details Defined in GHC.Classes Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Ord Char
Instance details Defined in GHC.Classes Methods compare :: Char -> Char -> Ordering # (<) :: Char -> Char -> Bool # (<=) :: Char -> Char -> Bool # (>) :: Char -> Char -> Bool # (>=) :: Char -> Char -> Bool # max :: Char -> Char -> Char # min :: Char -> Char -> Char #
Hashable Char
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Char -> Int # hash :: Char -> Int #
TraversableStream String
Instance details Defined in Text.Megaparsec.Stream Methods reachOffset :: Int -> PosState String -> (Maybe String, PosState String) # reachOffsetNoLine :: Int -> PosState String -> PosState String #
VisualStream String
Instance details Defined in Text.Megaparsec.Stream Methods showTokens :: Proxy String -> NonEmpty (Token String) -> String # tokensLength :: Proxy String -> NonEmpty (Token String) -> Int #
Uniform Char
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Char #
UniformRange Char
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Char, Char) -> g -> m Char #
ErrorList Char
Instance details Defined in Control.Monad.Trans.Error Methods listMsg :: String -> [Char] #
ToLText String
Instance details Defined in Universum.String.Conversion Methods toLText :: String -> Text #
ToString String
Instance details Defined in Universum.String.Conversion Methods toString :: String -> String #
ToText String
Instance details Defined in Universum.String.Conversion Methods toText :: String -> Text #
Unbox Char
Instance details Defined in Data.Vector.Unboxed.Base
Lift Char
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Char -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Char -> Code m Char #
ConvertUtf8 String ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: String -> ByteString # decodeUtf8 :: ByteString -> String # decodeUtf8Strict :: ByteString -> Either UnicodeException String #
ConvertUtf8 String ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: String -> ByteString # decodeUtf8 :: ByteString -> String # decodeUtf8Strict :: ByteString -> Either UnicodeException String #
Vector Vector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char) # basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char) # basicLength :: Vector Char -> Int # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char # basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m () # elemseq :: Vector Char -> Char -> b -> b #
MVector MVector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Char -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char # basicOverlaps :: MVector s Char -> MVector s Char -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char) # basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Char -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char) #
KnownSymbol n => Reifies (n :: Symbol) String
Instance details Defined in Data.Reflection Methods reflect :: proxy n -> String #
() :=> (Bounded Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Char #
() :=> (Enum Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Char #
() :=> (Read Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Char #
() :=> (Show Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Char #
() :=> (Ord Char)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Char #
Generic1 (URec Char :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Char) :: k -> Type # Methods from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a # to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a #
Foldable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b # foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] # null :: UChar a -> Bool # length :: UChar a -> Int # elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # sum :: Num a => UChar a -> a # product :: Num a => UChar a -> a #
Traversable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b) # sequenceA :: Applicative f => UChar (f a) -> f (UChar a) # mapM :: Monad m => (a -> m b) -> UChar a -> m (UChar b) # sequence :: Monad m => UChar (m a) -> m (UChar a) #
Buildable [Char]
Instance details Defined in Formatting.Buildable Methods build :: [Char] -> Builder #
Print [Char]
Instance details Defined in Universum.Print.Internal Methods hPutStr :: Handle -> [Char] -> IO () # hPutStrLn :: Handle -> [Char] -> IO () #
Functor (URec Char :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
SuppressUnusedWarnings (Fail_6989586621679456264Sym0 :: TyFun [Char] (Maybe a) -> Type)
Instance details Defined in Control.Monad.Fail.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fail_6989586621679456270Sym0 :: TyFun [Char] [a] -> Type)
Instance details Defined in Control.Monad.Fail.Singletons Methods suppressUnusedWarnings :: () #
SMonadFail m => SingI (FailSym0 :: TyFun [Char] (m a) -> Type)
Instance details Defined in Control.Monad.Fail.Singletons Methods sing :: Sing FailSym0 #
SuppressUnusedWarnings (FailSym0 :: TyFun [Char] (m a) -> Type)
Instance details Defined in Control.Monad.Fail.Singletons Methods suppressUnusedWarnings :: () #
Generic (URec Char p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
Show (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Eq (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Ord (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Char p -> URec Char p -> Ordering # (<) :: URec Char p -> URec Char p -> Bool # (<=) :: URec Char p -> URec Char p -> Bool # (>) :: URec Char p -> URec Char p -> Bool # (>=) :: URec Char p -> URec Char p -> Bool # max :: URec Char p -> URec Char p -> URec Char p # min :: URec Char p -> URec Char p -> URec Char p #
type NatNumMaxBound Char
Instance details Defined in Basement.Nat type NatNumMaxBound Char = 1114111
type Difference Char
Instance details Defined in Basement.Numerical.Subtractive type Difference Char = Int
type PrimSize Char
Instance details Defined in Basement.PrimType type PrimSize Char = 4
type PrettyShow Char
Instance details Defined in Morley.Prelude.Show type PrettyShow Char = TypeError ('Text "Show instance for String and Char is not pretty" :$$: 'Text "Consider relying on the Buildable instance") :: Constraint
newtype Vector Char
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Char = V_Char (Vector Char)
data URec Char (p :: k)	Used for marking occurrences of `Char#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Char (p :: k) = UChar { uChar# :: Char# }
newtype MVector s Char
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Char = MV_Char (MVector s Char)
type Rep1 (URec Char :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Char :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: k -> Type)))
type Apply (Fail_6989586621679456264Sym0 :: TyFun [Char] (Maybe a) -> Type) (a6989586621679456268 :: [Char])
Instance details Defined in Control.Monad.Fail.Singletons type Apply (Fail_6989586621679456264Sym0 :: TyFun [Char] (Maybe a) -> Type) (a6989586621679456268 :: [Char]) = Fail_6989586621679456264 a6989586621679456268 :: Maybe a
type Apply (Fail_6989586621679456270Sym0 :: TyFun [Char] [a] -> Type) (a6989586621679456274 :: [Char])
Instance details Defined in Control.Monad.Fail.Singletons type Apply (Fail_6989586621679456270Sym0 :: TyFun [Char] [a] -> Type) (a6989586621679456274 :: [Char]) = Fail_6989586621679456270 a6989586621679456274 :: [a]
type Apply (FailSym0 :: TyFun [Char] (m a) -> Type) (a6989586621679456262 :: [Char])
Instance details Defined in Control.Monad.Fail.Singletons type Apply (FailSym0 :: TyFun [Char] (m a) -> Type) (a6989586621679456262 :: [Char]) = Fail a6989586621679456262 :: m a
type Rep (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Char p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: Type -> Type)))

data Double #

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Constructors

D# Double#

Instances

Instances details

Structured Double
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Double -> Structure # structureHash' :: Tagged Double MD5
Storable Double	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Double -> Int # alignment :: Double -> Int # peekElemOff :: Ptr Double -> Int -> IO Double # pokeElemOff :: Ptr Double -> Int -> Double -> IO () # peekByteOff :: Ptr b -> Int -> IO Double # pokeByteOff :: Ptr b -> Int -> Double -> IO () # peek :: Ptr Double -> IO Double # poke :: Ptr Double -> Double -> IO () #
Floating Double	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Double # exp :: Double -> Double # log :: Double -> Double # sqrt :: Double -> Double # (**) :: Double -> Double -> Double # logBase :: Double -> Double -> Double # sin :: Double -> Double # cos :: Double -> Double # tan :: Double -> Double # asin :: Double -> Double # acos :: Double -> Double # atan :: Double -> Double # sinh :: Double -> Double # cosh :: Double -> Double # tanh :: Double -> Double # asinh :: Double -> Double # acosh :: Double -> Double # atanh :: Double -> Double # log1p :: Double -> Double # expm1 :: Double -> Double # log1pexp :: Double -> Double # log1mexp :: Double -> Double #
RealFloat Double	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # exponent :: Double -> Int # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isNaN :: Double -> Bool # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # isIEEE :: Double -> Bool # atan2 :: Double -> Double -> Double #
Read Double	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
Subtractive Double
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Double # Methods (-) :: Double -> Double -> Difference Double #
PrimType Double
Instance details Defined in Basement.PrimType Associated Types type PrimSize Double :: Nat # Methods primSizeInBytes :: Proxy Double -> CountOf Word8 # primShiftToBytes :: Proxy Double -> Int # primBaUIndex :: ByteArray# -> Offset Double -> Double # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> prim Double # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> Double -> prim () # primAddrIndex :: Addr# -> Offset Double -> Double # primAddrRead :: PrimMonad prim => Addr# -> Offset Double -> prim Double # primAddrWrite :: PrimMonad prim => Addr# -> Offset Double -> Double -> prim () #
Default Double
Instance details Defined in Data.Default.Class Methods def :: Double #
NFData Double
Instance details Defined in Control.DeepSeq Methods rnf :: Double -> () #
Buildable Double
Instance details Defined in Formatting.Buildable Methods build :: Double -> Builder #
Eq Double	Note that due to the presence of `NaN`, `Double`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Double)`False Also note that `Double`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Double)`True `>>>` `recip 0 == recip (-0 :: Double)`False
Instance details Defined in GHC.Classes Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Ord Double	Note that due to the presence of `NaN`, `Double`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Double)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Double`'s instance: `>>>` `(0/0 :: Double) > 1`False `>>>` `compare (0/0 :: Double) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Double -> Double -> Ordering # (<) :: Double -> Double -> Bool # (<=) :: Double -> Double -> Bool # (>) :: Double -> Double -> Bool # (>=) :: Double -> Double -> Bool # max :: Double -> Double -> Double # min :: Double -> Double -> Double #
Hashable Double	Note: prior to `hashable-1.3.0.0`, `hash 0.0 /= hash (-0.0)` The `hash` of NaN is not well defined. Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Double -> Int # hash :: Double -> Int #
UniformRange Double	See Floating point number caveats.
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Double, Double) -> g -> m Double #
Ring Double
Instance details Defined in Data.Semiring Methods negate :: Double -> Double #
Semiring Double
Instance details Defined in Data.Semiring Methods plus :: Double -> Double -> Double # zero :: Double # times :: Double -> Double -> Double # one :: Double # fromNatural :: Natural -> Double #
Unbox Double
Instance details Defined in Data.Vector.Unboxed.Base
Lift Double
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Double -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Double -> Code m Double #
Vector Vector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double) # basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double) # basicLength :: Vector Double -> Int # basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double # basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m () # elemseq :: Vector Double -> Double -> b -> b #
MVector MVector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Double -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double # basicOverlaps :: MVector s Double -> MVector s Double -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double) # basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Double -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double) #
() :=> (Enum Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Double #
() :=> (Floating Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Floating Double #
() :=> (RealFloat Double)
Instance details Defined in Data.Constraint Methods ins :: () :- RealFloat Double #
() :=> (Num Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Double #
() :=> (Fractional Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Fractional Double #
() :=> (Real Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Double #
() :=> (RealFrac Double)
Instance details Defined in Data.Constraint Methods ins :: () :- RealFrac Double #
() :=> (Eq Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Double #
() :=> (Ord Double)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Double #
Generic1 (URec Double :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Double) :: k -> Type # Methods from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a # to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a #
Foldable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m # foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m # foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b # foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b # foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] # null :: UDouble a -> Bool # length :: UDouble a -> Int # elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # sum :: Num a => UDouble a -> a # product :: Num a => UDouble a -> a #
Traversable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) # sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) # mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b) # sequence :: Monad m => UDouble (m a) -> m (UDouble a) #
Functor (URec Double :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Generic (URec Double p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
Show (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Eq (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Ord (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # max :: URec Double p -> URec Double p -> URec Double p # min :: URec Double p -> URec Double p -> URec Double p #
type Difference Double
Instance details Defined in Basement.Numerical.Subtractive type Difference Double = Double
type PrimSize Double
Instance details Defined in Basement.PrimType type PrimSize Double = 8
type ForeignFloating Double
Instance details Defined in Data.Double.Conversion.Internal.FFI type ForeignFloating Double = CDouble
type PrettyShow Double
Instance details Defined in Morley.Prelude.Show type PrettyShow Double = ()
newtype Vector Double
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Double = V_Double (Vector Double)
data URec Double (p :: k)	Used for marking occurrences of `Double#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Double (p :: k) = UDouble { uDouble# :: Double# }
newtype MVector s Double
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Double = MV_Double (MVector s Double)
type Rep1 (URec Double :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Double :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: k -> Type)))
type Rep (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Double p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: Type -> Type)))

data Float #

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Constructors

F# Float#

Instances

Instances details

Structured Float
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Float -> Structure # structureHash' :: Tagged Float MD5
Storable Float	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Float -> Int # alignment :: Float -> Int # peekElemOff :: Ptr Float -> Int -> IO Float # pokeElemOff :: Ptr Float -> Int -> Float -> IO () # peekByteOff :: Ptr b -> Int -> IO Float # pokeByteOff :: Ptr b -> Int -> Float -> IO () # peek :: Ptr Float -> IO Float # poke :: Ptr Float -> Float -> IO () #
Floating Float	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Float # exp :: Float -> Float # log :: Float -> Float # sqrt :: Float -> Float # (**) :: Float -> Float -> Float # logBase :: Float -> Float -> Float # sin :: Float -> Float # cos :: Float -> Float # tan :: Float -> Float # asin :: Float -> Float # acos :: Float -> Float # atan :: Float -> Float # sinh :: Float -> Float # cosh :: Float -> Float # tanh :: Float -> Float # asinh :: Float -> Float # acosh :: Float -> Float # atanh :: Float -> Float # log1p :: Float -> Float # expm1 :: Float -> Float # log1pexp :: Float -> Float # log1mexp :: Float -> Float #
RealFloat Float	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # exponent :: Float -> Int # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isNaN :: Float -> Bool # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # isIEEE :: Float -> Bool # atan2 :: Float -> Float -> Float #
Read Float	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
Subtractive Float
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Float # Methods (-) :: Float -> Float -> Difference Float #
PrimType Float
Instance details Defined in Basement.PrimType Associated Types type PrimSize Float :: Nat # Methods primSizeInBytes :: Proxy Float -> CountOf Word8 # primShiftToBytes :: Proxy Float -> Int # primBaUIndex :: ByteArray# -> Offset Float -> Float # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> prim Float # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> Float -> prim () # primAddrIndex :: Addr# -> Offset Float -> Float # primAddrRead :: PrimMonad prim => Addr# -> Offset Float -> prim Float # primAddrWrite :: PrimMonad prim => Addr# -> Offset Float -> Float -> prim () #
Default Float
Instance details Defined in Data.Default.Class Methods def :: Float #
NFData Float
Instance details Defined in Control.DeepSeq Methods rnf :: Float -> () #
Buildable Float
Instance details Defined in Formatting.Buildable Methods build :: Float -> Builder #
Eq Float	Note that due to the presence of `NaN`, `Float`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Float)`False Also note that `Float`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Float)`True `>>>` `recip 0 == recip (-0 :: Float)`False
Instance details Defined in GHC.Classes Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Ord Float	Note that due to the presence of `NaN`, `Float`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Float)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Float`'s instance: `>>>` `(0/0 :: Float) > 1`False `>>>` `compare (0/0 :: Float) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Float -> Float -> Ordering # (<) :: Float -> Float -> Bool # (<=) :: Float -> Float -> Bool # (>) :: Float -> Float -> Bool # (>=) :: Float -> Float -> Bool # max :: Float -> Float -> Float # min :: Float -> Float -> Float #
Hashable Float	Note: prior to `hashable-1.3.0.0`, `hash 0.0 /= hash (-0.0)` The `hash` of NaN is not well defined. Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Float -> Int # hash :: Float -> Int #
UniformRange Float	See Floating point number caveats.
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Float, Float) -> g -> m Float #
Ring Float
Instance details Defined in Data.Semiring Methods negate :: Float -> Float #
Semiring Float
Instance details Defined in Data.Semiring Methods plus :: Float -> Float -> Float # zero :: Float # times :: Float -> Float -> Float # one :: Float # fromNatural :: Natural -> Float #
Unbox Float
Instance details Defined in Data.Vector.Unboxed.Base
Lift Float
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Float -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Float -> Code m Float #
Vector Vector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float) # basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float) # basicLength :: Vector Float -> Int # basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float # basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m () # elemseq :: Vector Float -> Float -> b -> b #
MVector MVector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Float -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float # basicOverlaps :: MVector s Float -> MVector s Float -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float) # basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Float -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float) #
() :=> (Enum Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Float #
() :=> (Floating Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Floating Float #
() :=> (RealFloat Float)
Instance details Defined in Data.Constraint Methods ins :: () :- RealFloat Float #
() :=> (Num Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Float #
() :=> (Fractional Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Fractional Float #
() :=> (Real Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Float #
() :=> (RealFrac Float)
Instance details Defined in Data.Constraint Methods ins :: () :- RealFrac Float #
() :=> (Eq Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Float #
() :=> (Ord Float)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Float #
Generic1 (URec Float :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Float) :: k -> Type # Methods from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a # to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a #
Foldable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m # foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m # foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b # foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b # foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] # null :: UFloat a -> Bool # length :: UFloat a -> Int # elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # sum :: Num a => UFloat a -> a # product :: Num a => UFloat a -> a #
Traversable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) # sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) # mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b) # sequence :: Monad m => UFloat (m a) -> m (UFloat a) #
Functor (URec Float :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Generic (URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
Show (URec Float p)
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Eq (URec Float p)
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Ord (URec Float p)
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering # (<) :: URec Float p -> URec Float p -> Bool # (<=) :: URec Float p -> URec Float p -> Bool # (>) :: URec Float p -> URec Float p -> Bool # (>=) :: URec Float p -> URec Float p -> Bool # max :: URec Float p -> URec Float p -> URec Float p # min :: URec Float p -> URec Float p -> URec Float p #
type Difference Float
Instance details Defined in Basement.Numerical.Subtractive type Difference Float = Float
type PrimSize Float
Instance details Defined in Basement.PrimType type PrimSize Float = 4
type ForeignFloating Float
Instance details Defined in Data.Double.Conversion.Internal.FFI type ForeignFloating Float = CFloat
type PrettyShow Float
Instance details Defined in Morley.Prelude.Show type PrettyShow Float = ()
newtype Vector Float
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Float = V_Float (Vector Float)
data URec Float (p :: k)	Used for marking occurrences of `Float#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Float (p :: k) = UFloat { uFloat# :: Float# }
newtype MVector s Float
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Float = MV_Float (MVector s Float)
type Rep1 (URec Float :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: k -> Type)))
type Rep (URec Float p)
Instance details Defined in GHC.Generics type Rep (URec Float p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: Type -> Type)))

data Int #

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using minBound and maxBound from the Bounded class.

Instances

Instances details

Structured Int
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Int -> Structure # structureHash' :: Tagged Int MD5
Bits Int	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Int -> Int -> Int # (.\|.) :: Int -> Int -> Int # xor :: Int -> Int -> Int # complement :: Int -> Int # shift :: Int -> Int -> Int # rotate :: Int -> Int -> Int # zeroBits :: Int # bit :: Int -> Int # setBit :: Int -> Int -> Int # clearBit :: Int -> Int -> Int # complementBit :: Int -> Int -> Int # testBit :: Int -> Int -> Bool # bitSizeMaybe :: Int -> Maybe Int # bitSize :: Int -> Int # isSigned :: Int -> Bool # shiftL :: Int -> Int -> Int # unsafeShiftL :: Int -> Int -> Int # shiftR :: Int -> Int -> Int # unsafeShiftR :: Int -> Int -> Int # rotateL :: Int -> Int -> Int # rotateR :: Int -> Int -> Int # popCount :: Int -> Int #
FiniteBits Int	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Int -> Int # countLeadingZeros :: Int -> Int # countTrailingZeros :: Int -> Int #
Storable Int	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int -> Int # alignment :: Int -> Int # peekElemOff :: Ptr Int -> Int -> IO Int # pokeElemOff :: Ptr Int -> Int -> Int -> IO () # peekByteOff :: Ptr b -> Int -> IO Int # pokeByteOff :: Ptr b -> Int -> Int -> IO () # peek :: Ptr Int -> IO Int # poke :: Ptr Int -> Int -> IO () #
Bounded Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int # maxBound :: Int #
Enum Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Int -> Int # pred :: Int -> Int # toEnum :: Int -> Int # fromEnum :: Int -> Int # enumFrom :: Int -> [Int] # enumFromThen :: Int -> Int -> [Int] # enumFromTo :: Int -> Int -> [Int] # enumFromThenTo :: Int -> Int -> Int -> [Int] #
Num Int	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Int -> Int -> Int # (-) :: Int -> Int -> Int # (*) :: Int -> Int -> Int # negate :: Int -> Int # abs :: Int -> Int # signum :: Int -> Int # fromInteger :: Integer -> Int #
Read Int	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Int # readList :: ReadS [Int] # readPrec :: ReadPrec Int # readListPrec :: ReadPrec [Int] #
Integral Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Int -> Int -> Int # rem :: Int -> Int -> Int # div :: Int -> Int -> Int # mod :: Int -> Int -> Int # quotRem :: Int -> Int -> (Int, Int) # divMod :: Int -> Int -> (Int, Int) # toInteger :: Int -> Integer #
Real Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Int -> Rational #
Show Int	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Subtractive Int
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Int # Methods (-) :: Int -> Int -> Difference Int #
PrimMemoryComparable Int
Instance details Defined in Basement.PrimType
PrimType Int
Instance details Defined in Basement.PrimType Associated Types type PrimSize Int :: Nat # Methods primSizeInBytes :: Proxy Int -> CountOf Word8 # primShiftToBytes :: Proxy Int -> Int # primBaUIndex :: ByteArray# -> Offset Int -> Int # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> prim Int # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> Int -> prim () # primAddrIndex :: Addr# -> Offset Int -> Int # primAddrRead :: PrimMonad prim => Addr# -> Offset Int -> prim Int # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int -> Int -> prim () #
Default Int
Instance details Defined in Data.Default.Class Methods def :: Int #
NFData Int
Instance details Defined in Control.DeepSeq Methods rnf :: Int -> () #
Buildable Int
Instance details Defined in Formatting.Buildable Methods build :: Int -> Builder #
Eq Int
Instance details Defined in GHC.Classes Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Ord Int
Instance details Defined in GHC.Classes Methods compare :: Int -> Int -> Ordering # (<) :: Int -> Int -> Bool # (<=) :: Int -> Int -> Bool # (>) :: Int -> Int -> Bool # (>=) :: Int -> Int -> Bool # max :: Int -> Int -> Int # min :: Int -> Int -> Int #
Hashable Int
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int -> Int # hash :: Int -> Int #
Uniform Int
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int #
UniformRange Int
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int, Int) -> g -> m Int #
Ring Int
Instance details Defined in Data.Semiring Methods negate :: Int -> Int #
Semiring Int
Instance details Defined in Data.Semiring Methods plus :: Int -> Int -> Int # zero :: Int # times :: Int -> Int -> Int # one :: Int # fromNatural :: Natural -> Int #
ByteSource Int
Instance details Defined in Data.UUID.Types.Internal.Builder Methods (/-/) :: ByteSink Int g -> Int -> g
Unbox Int
Instance details Defined in Data.Vector.Unboxed.Base
Lift Int
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int -> Code m Int #
Vector Vector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int) # basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int) # basicLength :: Vector Int -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int # basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m () # elemseq :: Vector Int -> Int -> b -> b #
MVector MVector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int # basicOverlaps :: MVector s Int -> MVector s Int -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int) #
() :=> (Bits Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Bits Int #
() :=> (Bounded Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Int #
() :=> (Enum Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Int #
() :=> (Num Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Int #
() :=> (Read Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Int #
() :=> (Integral Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Integral Int #
() :=> (Real Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Int #
() :=> (Show Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Int #
() :=> (Eq Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Int #
() :=> (Ord Int)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Int #
Generic1 (URec Int :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Int) :: k -> Type # Methods from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a # to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a #
Foldable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m # foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m # foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b # foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b # foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] # null :: UInt a -> Bool # length :: UInt a -> Int # elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # minimum :: Ord a => UInt a -> a # sum :: Num a => UInt a -> a # product :: Num a => UInt a -> a #
Traversable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) # sequenceA :: Applicative f => UInt (f a) -> f (UInt a) # mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b) # sequence :: Monad m => UInt (m a) -> m (UInt a) #
Reifies Z Int
Instance details Defined in Data.Reflection Methods reflect :: proxy Z -> Int #
Reifies n Int => Reifies (D n :: Type) Int
Instance details Defined in Data.Reflection Methods reflect :: proxy (D n) -> Int #
Reifies n Int => Reifies (PD n :: Type) Int
Instance details Defined in Data.Reflection Methods reflect :: proxy (PD n) -> Int #
Reifies n Int => Reifies (SD n :: Type) Int
Instance details Defined in Data.Reflection Methods reflect :: proxy (SD n) -> Int #
Functor (URec Int :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Generic (URec Int p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
Show (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Eq (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Ord (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Int p -> URec Int p -> Ordering # (<) :: URec Int p -> URec Int p -> Bool # (<=) :: URec Int p -> URec Int p -> Bool # (>) :: URec Int p -> URec Int p -> Bool # (>=) :: URec Int p -> URec Int p -> Bool # max :: URec Int p -> URec Int p -> URec Int p # min :: URec Int p -> URec Int p -> URec Int p #
type NatNumMaxBound Int
Instance details Defined in Basement.Nat type NatNumMaxBound Int = NatNumMaxBound Int64
type Difference Int
Instance details Defined in Basement.Numerical.Subtractive type Difference Int = Int
type PrimSize Int
Instance details Defined in Basement.PrimType type PrimSize Int = 8
type IntBaseType Int
Instance details Defined in Data.IntCast type IntBaseType Int = 'FixedIntTag 64
type PrettyShow Int
Instance details Defined in Morley.Prelude.Show type PrettyShow Int = ()
newtype Vector Int
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int = V_Int (Vector Int)
data URec Int (p :: k)	Used for marking occurrences of `Int#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Int (p :: k) = UInt { uInt# :: Int# }
type ByteSink Int g
Instance details Defined in Data.UUID.Types.Internal.Builder type ByteSink Int g = Takes4Bytes g
newtype MVector s Int
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int = MV_Int (MVector s Int)
type Rep1 (URec Int :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Int :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: k -> Type)))
type Rep (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Int p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: Type -> Type)))

data Int8 #

8-bit signed integer type

Instances

Instances details

Structured Int8
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Int8 -> Structure # structureHash' :: Tagged Int8 MD5
Bits Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int8 -> Int8 -> Int8 # (.\|.) :: Int8 -> Int8 -> Int8 # xor :: Int8 -> Int8 -> Int8 # complement :: Int8 -> Int8 # shift :: Int8 -> Int -> Int8 # rotate :: Int8 -> Int -> Int8 # zeroBits :: Int8 # bit :: Int -> Int8 # setBit :: Int8 -> Int -> Int8 # clearBit :: Int8 -> Int -> Int8 # complementBit :: Int8 -> Int -> Int8 # testBit :: Int8 -> Int -> Bool # bitSizeMaybe :: Int8 -> Maybe Int # bitSize :: Int8 -> Int # isSigned :: Int8 -> Bool # shiftL :: Int8 -> Int -> Int8 # unsafeShiftL :: Int8 -> Int -> Int8 # shiftR :: Int8 -> Int -> Int8 # unsafeShiftR :: Int8 -> Int -> Int8 # rotateL :: Int8 -> Int -> Int8 # rotateR :: Int8 -> Int -> Int8 # popCount :: Int8 -> Int #
FiniteBits Int8	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int8 -> Int # countLeadingZeros :: Int8 -> Int # countTrailingZeros :: Int8 -> Int #
Storable Int8	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int8 -> Int # alignment :: Int8 -> Int # peekElemOff :: Ptr Int8 -> Int -> IO Int8 # pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int8 # pokeByteOff :: Ptr b -> Int -> Int8 -> IO () # peek :: Ptr Int8 -> IO Int8 # poke :: Ptr Int8 -> Int8 -> IO () #
Bounded Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int8 # maxBound :: Int8 #
Enum Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int8 -> Int8 # pred :: Int8 -> Int8 # toEnum :: Int -> Int8 # fromEnum :: Int8 -> Int # enumFrom :: Int8 -> [Int8] # enumFromThen :: Int8 -> Int8 -> [Int8] # enumFromTo :: Int8 -> Int8 -> [Int8] # enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8] #
Ix Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int8, Int8) -> [Int8] # index :: (Int8, Int8) -> Int8 -> Int # unsafeIndex :: (Int8, Int8) -> Int8 -> Int # inRange :: (Int8, Int8) -> Int8 -> Bool # rangeSize :: (Int8, Int8) -> Int # unsafeRangeSize :: (Int8, Int8) -> Int #
Num Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int8 -> Int8 -> Int8 # (-) :: Int8 -> Int8 -> Int8 # (*) :: Int8 -> Int8 -> Int8 # negate :: Int8 -> Int8 # abs :: Int8 -> Int8 # signum :: Int8 -> Int8 # fromInteger :: Integer -> Int8 #
Read Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int8 # readList :: ReadS [Int8] # readPrec :: ReadPrec Int8 # readListPrec :: ReadPrec [Int8] #
Integral Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int8 -> Int8 -> Int8 # rem :: Int8 -> Int8 -> Int8 # div :: Int8 -> Int8 -> Int8 # mod :: Int8 -> Int8 -> Int8 # quotRem :: Int8 -> Int8 -> (Int8, Int8) # divMod :: Int8 -> Int8 -> (Int8, Int8) # toInteger :: Int8 -> Integer #
Real Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int8 -> Rational #
Show Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
BitOps Int8
Instance details Defined in Basement.Bits Methods (.&.) :: Int8 -> Int8 -> Int8 # (.\|.) :: Int8 -> Int8 -> Int8 # (.^.) :: Int8 -> Int8 -> Int8 # (.<<.) :: Int8 -> CountOf Bool -> Int8 # (.>>.) :: Int8 -> CountOf Bool -> Int8 # bit :: Offset Bool -> Int8 # isBitSet :: Int8 -> Offset Bool -> Bool # setBit :: Int8 -> Offset Bool -> Int8 # clearBit :: Int8 -> Offset Bool -> Int8 #
FiniteBitsOps Int8
Instance details Defined in Basement.Bits Methods numberOfBits :: Int8 -> CountOf Bool # rotateL :: Int8 -> CountOf Bool -> Int8 # rotateR :: Int8 -> CountOf Bool -> Int8 # popCount :: Int8 -> CountOf Bool # bitFlip :: Int8 -> Int8 # countLeadingZeros :: Int8 -> CountOf Bool # countTrailingZeros :: Int8 -> CountOf Bool #
Subtractive Int8
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Int8 # Methods (-) :: Int8 -> Int8 -> Difference Int8 #
PrimMemoryComparable Int8
Instance details Defined in Basement.PrimType
PrimType Int8
Instance details Defined in Basement.PrimType Associated Types type PrimSize Int8 :: Nat # Methods primSizeInBytes :: Proxy Int8 -> CountOf Word8 # primShiftToBytes :: Proxy Int8 -> Int # primBaUIndex :: ByteArray# -> Offset Int8 -> Int8 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> prim Int8 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int8 -> Int8 -> prim () # primAddrIndex :: Addr# -> Offset Int8 -> Int8 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int8 -> prim Int8 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int8 -> Int8 -> prim () #
Default Int8
Instance details Defined in Data.Default.Class Methods def :: Int8 #
NFData Int8
Instance details Defined in Control.DeepSeq Methods rnf :: Int8 -> () #
Buildable Int8
Instance details Defined in Formatting.Buildable Methods build :: Int8 -> Builder #
Eq Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Ord Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int8 -> Int8 -> Ordering # (<) :: Int8 -> Int8 -> Bool # (<=) :: Int8 -> Int8 -> Bool # (>) :: Int8 -> Int8 -> Bool # (>=) :: Int8 -> Int8 -> Bool # max :: Int8 -> Int8 -> Int8 # min :: Int8 -> Int8 -> Int8 #
Hashable Int8
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int8 -> Int # hash :: Int8 -> Int #
Uniform Int8
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int8 #
UniformRange Int8
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int8, Int8) -> g -> m Int8 #
Ring Int8
Instance details Defined in Data.Semiring Methods negate :: Int8 -> Int8 #
Semiring Int8
Instance details Defined in Data.Semiring Methods plus :: Int8 -> Int8 -> Int8 # zero :: Int8 # times :: Int8 -> Int8 -> Int8 # one :: Int8 # fromNatural :: Natural -> Int8 #
Unbox Int8
Instance details Defined in Data.Vector.Unboxed.Base
Lift Int8
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int8 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int8 -> Code m Int8 #
Vector Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> m (Vector Int8) # basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m (Mutable Vector (PrimState m) Int8) # basicLength :: Vector Int8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8 # basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> Vector Int8 -> m () # elemseq :: Vector Int8 -> Int8 -> b -> b #
MVector MVector Int8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int8 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int8 -> MVector s Int8 # basicOverlaps :: MVector s Int8 -> MVector s Int8 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int8) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int8 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int8 -> m (MVector (PrimState m) Int8) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m Int8 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> Int8 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int8 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int8 -> Int8 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m (MVector (PrimState m) Int8) #
type NatNumMaxBound Int8
Instance details Defined in Basement.Nat type NatNumMaxBound Int8 = 127
type Difference Int8
Instance details Defined in Basement.Numerical.Subtractive type Difference Int8 = Int8
type PrimSize Int8
Instance details Defined in Basement.PrimType type PrimSize Int8 = 1
type IntBaseType Int8
Instance details Defined in Data.IntCast type IntBaseType Int8 = 'FixedIntTag 8
type PrettyShow Int8
Instance details Defined in Morley.Prelude.Show type PrettyShow Int8 = ()
newtype Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int8 = V_Int8 (Vector Int8)
newtype MVector s Int8
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int8 = MV_Int8 (MVector s Int8)

data Int16 #

16-bit signed integer type

Instances

Instances details

Structured Int16
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Int16 -> Structure # structureHash' :: Tagged Int16 MD5
Bits Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int16 -> Int16 -> Int16 # (.\|.) :: Int16 -> Int16 -> Int16 # xor :: Int16 -> Int16 -> Int16 # complement :: Int16 -> Int16 # shift :: Int16 -> Int -> Int16 # rotate :: Int16 -> Int -> Int16 # zeroBits :: Int16 # bit :: Int -> Int16 # setBit :: Int16 -> Int -> Int16 # clearBit :: Int16 -> Int -> Int16 # complementBit :: Int16 -> Int -> Int16 # testBit :: Int16 -> Int -> Bool # bitSizeMaybe :: Int16 -> Maybe Int # bitSize :: Int16 -> Int # isSigned :: Int16 -> Bool # shiftL :: Int16 -> Int -> Int16 # unsafeShiftL :: Int16 -> Int -> Int16 # shiftR :: Int16 -> Int -> Int16 # unsafeShiftR :: Int16 -> Int -> Int16 # rotateL :: Int16 -> Int -> Int16 # rotateR :: Int16 -> Int -> Int16 # popCount :: Int16 -> Int #
FiniteBits Int16	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int16 -> Int # countLeadingZeros :: Int16 -> Int # countTrailingZeros :: Int16 -> Int #
Storable Int16	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int16 -> Int # alignment :: Int16 -> Int # peekElemOff :: Ptr Int16 -> Int -> IO Int16 # pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int16 # pokeByteOff :: Ptr b -> Int -> Int16 -> IO () # peek :: Ptr Int16 -> IO Int16 # poke :: Ptr Int16 -> Int16 -> IO () #
Bounded Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int16 # maxBound :: Int16 #
Enum Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int16 -> Int16 # pred :: Int16 -> Int16 # toEnum :: Int -> Int16 # fromEnum :: Int16 -> Int # enumFrom :: Int16 -> [Int16] # enumFromThen :: Int16 -> Int16 -> [Int16] # enumFromTo :: Int16 -> Int16 -> [Int16] # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] #
Ix Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int16, Int16) -> [Int16] # index :: (Int16, Int16) -> Int16 -> Int # unsafeIndex :: (Int16, Int16) -> Int16 -> Int # inRange :: (Int16, Int16) -> Int16 -> Bool # rangeSize :: (Int16, Int16) -> Int # unsafeRangeSize :: (Int16, Int16) -> Int #
Num Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int16 -> Int16 -> Int16 # (-) :: Int16 -> Int16 -> Int16 # (*) :: Int16 -> Int16 -> Int16 # negate :: Int16 -> Int16 # abs :: Int16 -> Int16 # signum :: Int16 -> Int16 # fromInteger :: Integer -> Int16 #
Read Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int16 # readList :: ReadS [Int16] # readPrec :: ReadPrec Int16 # readListPrec :: ReadPrec [Int16] #
Integral Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int16 -> Int16 -> Int16 # rem :: Int16 -> Int16 -> Int16 # div :: Int16 -> Int16 -> Int16 # mod :: Int16 -> Int16 -> Int16 # quotRem :: Int16 -> Int16 -> (Int16, Int16) # divMod :: Int16 -> Int16 -> (Int16, Int16) # toInteger :: Int16 -> Integer #
Real Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int16 -> Rational #
Show Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
BitOps Int16
Instance details Defined in Basement.Bits Methods (.&.) :: Int16 -> Int16 -> Int16 # (.\|.) :: Int16 -> Int16 -> Int16 # (.^.) :: Int16 -> Int16 -> Int16 # (.<<.) :: Int16 -> CountOf Bool -> Int16 # (.>>.) :: Int16 -> CountOf Bool -> Int16 # bit :: Offset Bool -> Int16 # isBitSet :: Int16 -> Offset Bool -> Bool # setBit :: Int16 -> Offset Bool -> Int16 # clearBit :: Int16 -> Offset Bool -> Int16 #
FiniteBitsOps Int16
Instance details Defined in Basement.Bits Methods numberOfBits :: Int16 -> CountOf Bool # rotateL :: Int16 -> CountOf Bool -> Int16 # rotateR :: Int16 -> CountOf Bool -> Int16 # popCount :: Int16 -> CountOf Bool # bitFlip :: Int16 -> Int16 # countLeadingZeros :: Int16 -> CountOf Bool # countTrailingZeros :: Int16 -> CountOf Bool #
Subtractive Int16
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Int16 # Methods (-) :: Int16 -> Int16 -> Difference Int16 #
PrimMemoryComparable Int16
Instance details Defined in Basement.PrimType
PrimType Int16
Instance details Defined in Basement.PrimType Associated Types type PrimSize Int16 :: Nat # Methods primSizeInBytes :: Proxy Int16 -> CountOf Word8 # primShiftToBytes :: Proxy Int16 -> Int # primBaUIndex :: ByteArray# -> Offset Int16 -> Int16 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> prim Int16 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int16 -> Int16 -> prim () # primAddrIndex :: Addr# -> Offset Int16 -> Int16 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int16 -> prim Int16 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int16 -> Int16 -> prim () #
Default Int16
Instance details Defined in Data.Default.Class Methods def :: Int16 #
NFData Int16
Instance details Defined in Control.DeepSeq Methods rnf :: Int16 -> () #
Buildable Int16
Instance details Defined in Formatting.Buildable Methods build :: Int16 -> Builder #
Eq Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Ord Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int16 -> Int16 -> Ordering # (<) :: Int16 -> Int16 -> Bool # (<=) :: Int16 -> Int16 -> Bool # (>) :: Int16 -> Int16 -> Bool # (>=) :: Int16 -> Int16 -> Bool # max :: Int16 -> Int16 -> Int16 # min :: Int16 -> Int16 -> Int16 #
Hashable Int16
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int16 -> Int # hash :: Int16 -> Int #
Uniform Int16
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int16 #
UniformRange Int16
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int16, Int16) -> g -> m Int16 #
Ring Int16
Instance details Defined in Data.Semiring Methods negate :: Int16 -> Int16 #
Semiring Int16
Instance details Defined in Data.Semiring Methods plus :: Int16 -> Int16 -> Int16 # zero :: Int16 # times :: Int16 -> Int16 -> Int16 # one :: Int16 # fromNatural :: Natural -> Int16 #
Unbox Int16
Instance details Defined in Data.Vector.Unboxed.Base
Lift Int16
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int16 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int16 -> Code m Int16 #
Vector Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> m (Vector Int16) # basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m (Mutable Vector (PrimState m) Int16) # basicLength :: Vector Int16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16 # basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> Vector Int16 -> m () # elemseq :: Vector Int16 -> Int16 -> b -> b #
MVector MVector Int16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int16 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int16 -> MVector s Int16 # basicOverlaps :: MVector s Int16 -> MVector s Int16 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int16) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int16 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int16 -> m (MVector (PrimState m) Int16) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m Int16 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> Int16 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int16 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int16 -> Int16 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m (MVector (PrimState m) Int16) #
type NatNumMaxBound Int16
Instance details Defined in Basement.Nat type NatNumMaxBound Int16 = 32767
type Difference Int16
Instance details Defined in Basement.Numerical.Subtractive type Difference Int16 = Int16
type PrimSize Int16
Instance details Defined in Basement.PrimType type PrimSize Int16 = 2
type IntBaseType Int16
Instance details Defined in Data.IntCast type IntBaseType Int16 = 'FixedIntTag 16
type PrettyShow Int16
Instance details Defined in Morley.Prelude.Show type PrettyShow Int16 = ()
newtype Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int16 = V_Int16 (Vector Int16)
newtype MVector s Int16
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int16 = MV_Int16 (MVector s Int16)

data Int32 #

32-bit signed integer type

Instances

Instances details

Structured Int32
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Int32 -> Structure # structureHash' :: Tagged Int32 MD5
Bits Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int32 -> Int32 -> Int32 # (.\|.) :: Int32 -> Int32 -> Int32 # xor :: Int32 -> Int32 -> Int32 # complement :: Int32 -> Int32 # shift :: Int32 -> Int -> Int32 # rotate :: Int32 -> Int -> Int32 # zeroBits :: Int32 # bit :: Int -> Int32 # setBit :: Int32 -> Int -> Int32 # clearBit :: Int32 -> Int -> Int32 # complementBit :: Int32 -> Int -> Int32 # testBit :: Int32 -> Int -> Bool # bitSizeMaybe :: Int32 -> Maybe Int # bitSize :: Int32 -> Int # isSigned :: Int32 -> Bool # shiftL :: Int32 -> Int -> Int32 # unsafeShiftL :: Int32 -> Int -> Int32 # shiftR :: Int32 -> Int -> Int32 # unsafeShiftR :: Int32 -> Int -> Int32 # rotateL :: Int32 -> Int -> Int32 # rotateR :: Int32 -> Int -> Int32 # popCount :: Int32 -> Int #
FiniteBits Int32	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int32 -> Int # countLeadingZeros :: Int32 -> Int # countTrailingZeros :: Int32 -> Int #
Storable Int32	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int32 -> Int # alignment :: Int32 -> Int # peekElemOff :: Ptr Int32 -> Int -> IO Int32 # pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int32 # pokeByteOff :: Ptr b -> Int -> Int32 -> IO () # peek :: Ptr Int32 -> IO Int32 # poke :: Ptr Int32 -> Int32 -> IO () #
Bounded Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int32 # maxBound :: Int32 #
Enum Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Ix Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int32, Int32) -> [Int32] # index :: (Int32, Int32) -> Int32 -> Int # unsafeIndex :: (Int32, Int32) -> Int32 -> Int # inRange :: (Int32, Int32) -> Int32 -> Bool # rangeSize :: (Int32, Int32) -> Int # unsafeRangeSize :: (Int32, Int32) -> Int #
Num Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int32 -> Int32 -> Int32 # (-) :: Int32 -> Int32 -> Int32 # (*) :: Int32 -> Int32 -> Int32 # negate :: Int32 -> Int32 # abs :: Int32 -> Int32 # signum :: Int32 -> Int32 # fromInteger :: Integer -> Int32 #
Read Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] # readPrec :: ReadPrec Int32 # readListPrec :: ReadPrec [Int32] #
Integral Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int32 -> Int32 -> Int32 # rem :: Int32 -> Int32 -> Int32 # div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # quotRem :: Int32 -> Int32 -> (Int32, Int32) # divMod :: Int32 -> Int32 -> (Int32, Int32) # toInteger :: Int32 -> Integer #
Real Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int32 -> Rational #
Show Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
BitOps Int32
Instance details Defined in Basement.Bits Methods (.&.) :: Int32 -> Int32 -> Int32 # (.\|.) :: Int32 -> Int32 -> Int32 # (.^.) :: Int32 -> Int32 -> Int32 # (.<<.) :: Int32 -> CountOf Bool -> Int32 # (.>>.) :: Int32 -> CountOf Bool -> Int32 # bit :: Offset Bool -> Int32 # isBitSet :: Int32 -> Offset Bool -> Bool # setBit :: Int32 -> Offset Bool -> Int32 # clearBit :: Int32 -> Offset Bool -> Int32 #
FiniteBitsOps Int32
Instance details Defined in Basement.Bits Methods numberOfBits :: Int32 -> CountOf Bool # rotateL :: Int32 -> CountOf Bool -> Int32 # rotateR :: Int32 -> CountOf Bool -> Int32 # popCount :: Int32 -> CountOf Bool # bitFlip :: Int32 -> Int32 # countLeadingZeros :: Int32 -> CountOf Bool # countTrailingZeros :: Int32 -> CountOf Bool #
Subtractive Int32
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Int32 # Methods (-) :: Int32 -> Int32 -> Difference Int32 #
PrimMemoryComparable Int32
Instance details Defined in Basement.PrimType
PrimType Int32
Instance details Defined in Basement.PrimType Associated Types type PrimSize Int32 :: Nat # Methods primSizeInBytes :: Proxy Int32 -> CountOf Word8 # primShiftToBytes :: Proxy Int32 -> Int # primBaUIndex :: ByteArray# -> Offset Int32 -> Int32 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> prim Int32 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int32 -> Int32 -> prim () # primAddrIndex :: Addr# -> Offset Int32 -> Int32 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int32 -> prim Int32 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int32 -> Int32 -> prim () #
Default Int32
Instance details Defined in Data.Default.Class Methods def :: Int32 #
NFData Int32
Instance details Defined in Control.DeepSeq Methods rnf :: Int32 -> () #
Buildable Int32
Instance details Defined in Formatting.Buildable Methods build :: Int32 -> Builder #
Eq Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Ord Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int32 -> Int32 -> Ordering # (<) :: Int32 -> Int32 -> Bool # (<=) :: Int32 -> Int32 -> Bool # (>) :: Int32 -> Int32 -> Bool # (>=) :: Int32 -> Int32 -> Bool # max :: Int32 -> Int32 -> Int32 # min :: Int32 -> Int32 -> Int32 #
Hashable Int32
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int32 -> Int # hash :: Int32 -> Int #
Uniform Int32
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int32 #
UniformRange Int32
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int32, Int32) -> g -> m Int32 #
Ring Int32
Instance details Defined in Data.Semiring Methods negate :: Int32 -> Int32 #
Semiring Int32
Instance details Defined in Data.Semiring Methods plus :: Int32 -> Int32 -> Int32 # zero :: Int32 # times :: Int32 -> Int32 -> Int32 # one :: Int32 # fromNatural :: Natural -> Int32 #
Unbox Int32
Instance details Defined in Data.Vector.Unboxed.Base
Lift Int32
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int32 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int32 -> Code m Int32 #
Vector Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> m (Vector Int32) # basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m (Mutable Vector (PrimState m) Int32) # basicLength :: Vector Int32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32 # basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> Vector Int32 -> m () # elemseq :: Vector Int32 -> Int32 -> b -> b #
MVector MVector Int32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int32 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32 # basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int32) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int32 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m (MVector (PrimState m) Int32) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m Int32 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> Int32 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int32 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int32 -> Int32 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m (MVector (PrimState m) Int32) #
type NatNumMaxBound Int32
Instance details Defined in Basement.Nat type NatNumMaxBound Int32 = 2147483647
type Difference Int32
Instance details Defined in Basement.Numerical.Subtractive type Difference Int32 = Int32
type PrimSize Int32
Instance details Defined in Basement.PrimType type PrimSize Int32 = 4
type IntBaseType Int32
Instance details Defined in Data.IntCast type IntBaseType Int32 = 'FixedIntTag 32
type PrettyShow Int32
Instance details Defined in Morley.Prelude.Show type PrettyShow Int32 = ()
newtype Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int32 = V_Int32 (Vector Int32)
newtype MVector s Int32
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int32 = MV_Int32 (MVector s Int32)

data Int64 #

64-bit signed integer type

Instances

Instances details

Structured Int64
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Int64 -> Structure # structureHash' :: Tagged Int64 MD5
FromJSON TezosInt64
Instance details Defined in Morley.Micheline.Json Methods parseJSON :: Value -> Parser TezosInt64 # parseJSONList :: Value -> Parser [TezosInt64] #
ToJSON TezosInt64
Instance details Defined in Morley.Micheline.Json Methods toJSON :: TezosInt64 -> Value # toEncoding :: TezosInt64 -> Encoding # toJSONList :: [TezosInt64] -> Value # toEncodingList :: [TezosInt64] -> Encoding #
Bits Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (.&.) :: Int64 -> Int64 -> Int64 # (.\|.) :: Int64 -> Int64 -> Int64 # xor :: Int64 -> Int64 -> Int64 # complement :: Int64 -> Int64 # shift :: Int64 -> Int -> Int64 # rotate :: Int64 -> Int -> Int64 # zeroBits :: Int64 # bit :: Int -> Int64 # setBit :: Int64 -> Int -> Int64 # clearBit :: Int64 -> Int -> Int64 # complementBit :: Int64 -> Int -> Int64 # testBit :: Int64 -> Int -> Bool # bitSizeMaybe :: Int64 -> Maybe Int # bitSize :: Int64 -> Int # isSigned :: Int64 -> Bool # shiftL :: Int64 -> Int -> Int64 # unsafeShiftL :: Int64 -> Int -> Int64 # shiftR :: Int64 -> Int -> Int64 # unsafeShiftR :: Int64 -> Int -> Int64 # rotateL :: Int64 -> Int -> Int64 # rotateR :: Int64 -> Int -> Int64 # popCount :: Int64 -> Int #
FiniteBits Int64	Since: base-4.6.0.0
Instance details Defined in GHC.Int Methods finiteBitSize :: Int64 -> Int # countLeadingZeros :: Int64 -> Int # countTrailingZeros :: Int64 -> Int #
Storable Int64	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Int64 -> Int # alignment :: Int64 -> Int # peekElemOff :: Ptr Int64 -> Int -> IO Int64 # pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int64 # pokeByteOff :: Ptr b -> Int -> Int64 -> IO () # peek :: Ptr Int64 -> IO Int64 # poke :: Ptr Int64 -> Int64 -> IO () #
Bounded Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int64 # maxBound :: Int64 #
Enum Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Ix Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods range :: (Int64, Int64) -> [Int64] # index :: (Int64, Int64) -> Int64 -> Int # unsafeIndex :: (Int64, Int64) -> Int64 -> Int # inRange :: (Int64, Int64) -> Int64 -> Bool # rangeSize :: (Int64, Int64) -> Int # unsafeRangeSize :: (Int64, Int64) -> Int #
Num Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (+) :: Int64 -> Int64 -> Int64 # (-) :: Int64 -> Int64 -> Int64 # (*) :: Int64 -> Int64 -> Int64 # negate :: Int64 -> Int64 # abs :: Int64 -> Int64 # signum :: Int64 -> Int64 # fromInteger :: Integer -> Int64 #
Read Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] # readPrec :: ReadPrec Int64 # readListPrec :: ReadPrec [Int64] #
Integral Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods quot :: Int64 -> Int64 -> Int64 # rem :: Int64 -> Int64 -> Int64 # div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # quotRem :: Int64 -> Int64 -> (Int64, Int64) # divMod :: Int64 -> Int64 -> (Int64, Int64) # toInteger :: Int64 -> Integer #
Real Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods toRational :: Int64 -> Rational #
Show Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
BitOps Int64
Instance details Defined in Basement.Bits Methods (.&.) :: Int64 -> Int64 -> Int64 # (.\|.) :: Int64 -> Int64 -> Int64 # (.^.) :: Int64 -> Int64 -> Int64 # (.<<.) :: Int64 -> CountOf Bool -> Int64 # (.>>.) :: Int64 -> CountOf Bool -> Int64 # bit :: Offset Bool -> Int64 # isBitSet :: Int64 -> Offset Bool -> Bool # setBit :: Int64 -> Offset Bool -> Int64 # clearBit :: Int64 -> Offset Bool -> Int64 #
FiniteBitsOps Int64
Instance details Defined in Basement.Bits Methods numberOfBits :: Int64 -> CountOf Bool # rotateL :: Int64 -> CountOf Bool -> Int64 # rotateR :: Int64 -> CountOf Bool -> Int64 # popCount :: Int64 -> CountOf Bool # bitFlip :: Int64 -> Int64 # countLeadingZeros :: Int64 -> CountOf Bool # countTrailingZeros :: Int64 -> CountOf Bool #
Subtractive Int64
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Int64 # Methods (-) :: Int64 -> Int64 -> Difference Int64 #
PrimMemoryComparable Int64
Instance details Defined in Basement.PrimType
PrimType Int64
Instance details Defined in Basement.PrimType Associated Types type PrimSize Int64 :: Nat # Methods primSizeInBytes :: Proxy Int64 -> CountOf Word8 # primShiftToBytes :: Proxy Int64 -> Int # primBaUIndex :: ByteArray# -> Offset Int64 -> Int64 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> prim Int64 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int64 -> Int64 -> prim () # primAddrIndex :: Addr# -> Offset Int64 -> Int64 # primAddrRead :: PrimMonad prim => Addr# -> Offset Int64 -> prim Int64 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Int64 -> Int64 -> prim () #
Default Int64
Instance details Defined in Data.Default.Class Methods def :: Int64 #
NFData Int64
Instance details Defined in Control.DeepSeq Methods rnf :: Int64 -> () #
Buildable Int64
Instance details Defined in Formatting.Buildable Methods build :: Int64 -> Builder #
Buildable TezosInt64
Instance details Defined in Morley.Micheline.Json Methods build :: TezosInt64 -> Builder #
Eq Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Ord Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods compare :: Int64 -> Int64 -> Ordering # (<) :: Int64 -> Int64 -> Bool # (<=) :: Int64 -> Int64 -> Bool # (>) :: Int64 -> Int64 -> Bool # (>=) :: Int64 -> Int64 -> Bool # max :: Int64 -> Int64 -> Int64 # min :: Int64 -> Int64 -> Int64 #
Hashable Int64
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int64 -> Int # hash :: Int64 -> Int #
Uniform Int64
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int64 #
UniformRange Int64
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int64, Int64) -> g -> m Int64 #
Ring Int64
Instance details Defined in Data.Semiring Methods negate :: Int64 -> Int64 #
Semiring Int64
Instance details Defined in Data.Semiring Methods plus :: Int64 -> Int64 -> Int64 # zero :: Int64 # times :: Int64 -> Int64 -> Int64 # one :: Int64 # fromNatural :: Natural -> Int64 #
Unbox Int64
Instance details Defined in Data.Vector.Unboxed.Base
Lift Int64
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int64 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int64 -> Code m Int64 #
Vector Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64) # basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64) # basicLength :: Vector Int64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64 # basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m () # elemseq :: Vector Int64 -> Int64 -> b -> b #
MVector MVector Int64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int64 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64 # basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int64) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int64 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m (MVector (PrimState m) Int64) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m Int64 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> Int64 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int64 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int64 -> Int64 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m (MVector (PrimState m) Int64) #
type NatNumMaxBound Int64
Instance details Defined in Basement.Nat type NatNumMaxBound Int64 = 9223372036854775807
type Difference Int64
Instance details Defined in Basement.Numerical.Subtractive type Difference Int64 = Int64
type PrimSize Int64
Instance details Defined in Basement.PrimType type PrimSize Int64 = 8
type IntBaseType Int64
Instance details Defined in Data.IntCast type IntBaseType Int64 = 'FixedIntTag 64
type PrettyShow Int64
Instance details Defined in Morley.Prelude.Show type PrettyShow Int64 = ()
newtype Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int64 = V_Int64 (Vector Int64)
newtype MVector s Int64
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int64 = MV_Int64 (MVector s Int64)

data Integer #

Arbitrary precision integers. In contrast with fixed-size integral types such as Int, the Integer type represents the entire infinite range of integers.

Integers are stored in a kind of sign-magnitude form, hence do not expect two's complement form when using bit operations.

If the value is small (fit into an Int), IS constructor is used. Otherwise IP and IN constructors are used to store a BigNat representing respectively the positive or the negative value magnitude.

Invariant: IP and IN are used iff value doesn't fit in IS

Instances

Instances details

Structured Integer
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Integer -> Structure # structureHash' :: Tagged Integer MD5
FiniteBitsBase Integer
Instance details Defined in Data.Word.Odd Methods subWordClz :: Int -> Integer -> Int # subWordCtz :: Int -> Integer -> Int #
FromJSON TezosBigNum
Instance details Defined in Morley.Micheline.Json Methods parseJSON :: Value -> Parser TezosBigNum # parseJSONList :: Value -> Parser [TezosBigNum] #
ToJSON TezosBigNum
Instance details Defined in Morley.Micheline.Json Methods toJSON :: TezosBigNum -> Value # toEncoding :: TezosBigNum -> Encoding # toJSONList :: [TezosBigNum] -> Value # toEncodingList :: [TezosBigNum] -> Encoding #
Bits Integer	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Integer -> Integer -> Integer # (.\|.) :: Integer -> Integer -> Integer # xor :: Integer -> Integer -> Integer # complement :: Integer -> Integer # shift :: Integer -> Int -> Integer # rotate :: Integer -> Int -> Integer # zeroBits :: Integer # bit :: Int -> Integer # setBit :: Integer -> Int -> Integer # clearBit :: Integer -> Int -> Integer # complementBit :: Integer -> Int -> Integer # testBit :: Integer -> Int -> Bool # bitSizeMaybe :: Integer -> Maybe Int # bitSize :: Integer -> Int # isSigned :: Integer -> Bool # shiftL :: Integer -> Int -> Integer # unsafeShiftL :: Integer -> Int -> Integer # shiftR :: Integer -> Int -> Integer # unsafeShiftR :: Integer -> Int -> Integer # rotateL :: Integer -> Int -> Integer # rotateR :: Integer -> Int -> Integer # popCount :: Integer -> Int #
Enum Integer	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Num Integer	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Integer -> Integer -> Integer # (-) :: Integer -> Integer -> Integer # (*) :: Integer -> Integer -> Integer # negate :: Integer -> Integer # abs :: Integer -> Integer # signum :: Integer -> Integer # fromInteger :: Integer -> Integer #
Read Integer	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Integer # readList :: ReadS [Integer] # readPrec :: ReadPrec Integer # readListPrec :: ReadPrec [Integer] #
Integral Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Integer -> Integer -> Integer # rem :: Integer -> Integer -> Integer # div :: Integer -> Integer -> Integer # mod :: Integer -> Integer -> Integer # quotRem :: Integer -> Integer -> (Integer, Integer) # divMod :: Integer -> Integer -> (Integer, Integer) # toInteger :: Integer -> Integer #
Real Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Integer -> Rational #
Show Integer	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Subtractive Integer
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Integer # Methods (-) :: Integer -> Integer -> Difference Integer #
Default Integer
Instance details Defined in Data.Default.Class Methods def :: Integer #
NFData Integer
Instance details Defined in Control.DeepSeq Methods rnf :: Integer -> () #
Buildable Integer
Instance details Defined in Formatting.Buildable Methods build :: Integer -> Builder #
Eq Integer
Instance details Defined in GHC.Num.Integer Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Ord Integer
Instance details Defined in GHC.Num.Integer Methods compare :: Integer -> Integer -> Ordering # (<) :: Integer -> Integer -> Bool # (<=) :: Integer -> Integer -> Bool # (>) :: Integer -> Integer -> Bool # (>=) :: Integer -> Integer -> Bool # max :: Integer -> Integer -> Integer # min :: Integer -> Integer -> Integer #
Hashable Integer
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Integer -> Int # hash :: Integer -> Int #
HasAnnotation Integer
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Integer) # annOptions :: Maybe AnnOptions #
ToBytesArithOpHs Integer
Instance details Defined in Lorentz.Arith Methods evalToBytesOpHs :: forall bs (s :: [Type]). BytesLike bs => (Integer ': s) :-> (bs ': s) #
NonZero Integer
Instance details Defined in Lorentz.Macro Methods nonZero :: forall (s :: [Type]). (Integer ': s) :-> (Maybe Integer ': s) #
HasRPCRepr Integer
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Integer #
TypeHasDoc Integer
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Integer :: FieldDescriptions # Methods typeDocName :: Proxy Integer -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Integer -> WithinParens -> Markdown # typeDocDependencies :: Proxy Integer -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Integer # typeDocMichelsonRep :: TypeDocMichelsonRep Integer #
IsoValue Integer
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Integer :: T # Methods toVal :: Integer -> Value (ToT Integer) # fromVal :: Value (ToT Integer) -> Integer #
UniformRange Integer
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Integer, Integer) -> g -> m Integer #
Ring Integer
Instance details Defined in Data.Semiring Methods negate :: Integer -> Integer #
Semiring Integer
Instance details Defined in Data.Semiring Methods plus :: Integer -> Integer -> Integer # zero :: Integer # times :: Integer -> Integer -> Integer # one :: Integer # fromNatural :: Natural -> Integer #
UnaryArithOpHs Abs Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Abs Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Abs Integer ': s) #
UnaryArithOpHs Eq' Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Eq' Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Eq' Integer ': s) #
UnaryArithOpHs Ge Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Ge Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Ge Integer ': s) #
UnaryArithOpHs Gt Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Gt Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Gt Integer ': s) #
UnaryArithOpHs Le Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Le Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Le Integer ': s) #
UnaryArithOpHs Lt Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Lt Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Lt Integer ': s) #
UnaryArithOpHs Neg Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neg Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Neg Integer ': s) #
UnaryArithOpHs Neq Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neq Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Neq Integer ': s) #
UnaryArithOpHs Not Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Not Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Not Integer ': s) #
MultiplyPoint Integer Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods multiply :: Integer -> Bls12381G1 -> Bls12381G1 #
MultiplyPoint Integer Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods multiply :: Integer -> Bls12381G2 -> Bls12381G2 #
Lift Integer
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Integer -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Integer -> Code m Integer #
KnownNat n => Reifies (n :: Nat) Integer
Instance details Defined in Data.Reflection Methods reflect :: proxy n -> Integer #
r ~ Timestamp => ArithOpHs Add Timestamp Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Timestamp ': (Integer ': s)) :-> (r ': s) #
r ~ Timestamp => ArithOpHs Add Integer Timestamp r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Timestamp ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Add Integer Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Integer ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Add Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Add Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs And Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Maybe (Integer, Natural) => ArithOpHs EDiv Integer Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Integer ': s)) :-> (r ': s) #
r ~ Maybe (Integer, Natural) => ArithOpHs EDiv Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Maybe (Integer, Natural) => ArithOpHs EDiv Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Bls12381Fr Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Integer ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Integer Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Mul Integer Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Integer ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Mul Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Mul Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Timestamp => ArithOpHs Sub Timestamp Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Timestamp ': (Integer ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Integer Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Integer ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
() :=> (Bits Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Bits Integer #
() :=> (Enum Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Integer #
() :=> (Num Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Integer #
() :=> (Integral Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Integral Integer #
() :=> (Real Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Integer #
() :=> (Eq Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Integer #
() :=> (Ord Integer)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Integer #
type Difference Integer
Instance details Defined in Basement.Numerical.Subtractive type Difference Integer = Integer
type IntBaseType Integer
Instance details Defined in Data.IntCast type IntBaseType Integer = 'BigIntTag
type AsRPC Integer
Instance details Defined in Morley.AsRPC type AsRPC Integer = Integer
type TypeDocFieldDescriptions Integer
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Integer = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Integer
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Integer = 'TInt
type PrettyShow Integer
Instance details Defined in Morley.Prelude.Show type PrettyShow Integer = ()
type UnaryArithResHs Abs Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Abs Integer = Natural
type UnaryArithResHs Eq' Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Eq' Integer = Bool
type UnaryArithResHs Ge Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Ge Integer = Bool
type UnaryArithResHs Gt Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Gt Integer = Bool
type UnaryArithResHs Le Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Le Integer = Bool
type UnaryArithResHs Lt Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Lt Integer = Bool
type UnaryArithResHs Neg Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neg Integer = Integer
type UnaryArithResHs Neq Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neq Integer = Bool
type UnaryArithResHs Not Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Not Integer = Integer

data Natural #

Natural number

Invariant: numbers <= 0xffffffffffffffff use the NS constructor

Instances

Instances details

FromJSON TezosNat
Instance details Defined in Morley.Micheline.Json Methods parseJSON :: Value -> Parser TezosNat # parseJSONList :: Value -> Parser [TezosNat] #
ToJSON TezosNat
Instance details Defined in Morley.Micheline.Json Methods toJSON :: TezosNat -> Value # toEncoding :: TezosNat -> Encoding # toJSONList :: [TezosNat] -> Value # toEncodingList :: [TezosNat] -> Encoding #
Bits Natural	Since: base-4.8.0
Instance details Defined in Data.Bits Methods (.&.) :: Natural -> Natural -> Natural # (.\|.) :: Natural -> Natural -> Natural # xor :: Natural -> Natural -> Natural # complement :: Natural -> Natural # shift :: Natural -> Int -> Natural # rotate :: Natural -> Int -> Natural # zeroBits :: Natural # bit :: Int -> Natural # setBit :: Natural -> Int -> Natural # clearBit :: Natural -> Int -> Natural # complementBit :: Natural -> Int -> Natural # testBit :: Natural -> Int -> Bool # bitSizeMaybe :: Natural -> Maybe Int # bitSize :: Natural -> Int # isSigned :: Natural -> Bool # shiftL :: Natural -> Int -> Natural # unsafeShiftL :: Natural -> Int -> Natural # shiftR :: Natural -> Int -> Natural # unsafeShiftR :: Natural -> Int -> Natural # rotateL :: Natural -> Int -> Natural # rotateR :: Natural -> Int -> Natural # popCount :: Natural -> Int #
Enum Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Enum Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Num Natural	Note that `Natural`'s `Num` instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though. Since: base-4.8.0.0
Instance details Defined in GHC.Num Methods (+) :: Natural -> Natural -> Natural # (-) :: Natural -> Natural -> Natural # (*) :: Natural -> Natural -> Natural # negate :: Natural -> Natural # abs :: Natural -> Natural # signum :: Natural -> Natural # fromInteger :: Integer -> Natural #
Read Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Natural # readList :: ReadS [Natural] # readPrec :: ReadPrec Natural # readListPrec :: ReadPrec [Natural] #
Integral Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods quot :: Natural -> Natural -> Natural # rem :: Natural -> Natural -> Natural # div :: Natural -> Natural -> Natural # mod :: Natural -> Natural -> Natural # quotRem :: Natural -> Natural -> (Natural, Natural) # divMod :: Natural -> Natural -> (Natural, Natural) # toInteger :: Natural -> Integer #
Real Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods toRational :: Natural -> Rational #
Show Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Subtractive Natural
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Natural # Methods (-) :: Natural -> Natural -> Difference Natural #
NFData Natural	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Natural -> () #
Buildable TezosNat
Instance details Defined in Morley.Micheline.Json Methods build :: TezosNat -> Builder #
Eq Natural
Instance details Defined in GHC.Num.Natural Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Ord Natural
Instance details Defined in GHC.Num.Natural Methods compare :: Natural -> Natural -> Ordering # (<) :: Natural -> Natural -> Bool # (<=) :: Natural -> Natural -> Bool # (>) :: Natural -> Natural -> Bool # (>=) :: Natural -> Natural -> Bool # max :: Natural -> Natural -> Natural # min :: Natural -> Natural -> Natural #
Hashable Natural
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Natural -> Int # hash :: Natural -> Int #
HasAnnotation Natural
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Natural) # annOptions :: Maybe AnnOptions #
ToBytesArithOpHs Natural
Instance details Defined in Lorentz.Arith Methods evalToBytesOpHs :: forall bs (s :: [Type]). BytesLike bs => (Natural ': s) :-> (bs ': s) #
ToIntegerArithOpHs Natural
Instance details Defined in Lorentz.Arith Methods evalToIntOpHs :: forall (s :: [Type]). (Natural ': s) :-> (Integer ': s) #
NonZero Natural
Instance details Defined in Lorentz.Macro Methods nonZero :: forall (s :: [Type]). (Natural ': s) :-> (Maybe Natural ': s) #
HasRPCRepr Natural
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Natural #
TypeHasDoc Natural
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Natural :: FieldDescriptions # Methods typeDocName :: Proxy Natural -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Natural -> WithinParens -> Markdown # typeDocDependencies :: Proxy Natural -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Natural # typeDocMichelsonRep :: TypeDocMichelsonRep Natural #
IsoValue Natural
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Natural :: T # Methods toVal :: Natural -> Value (ToT Natural) # fromVal :: Value (ToT Natural) -> Natural #
UniformRange Natural
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Natural, Natural) -> g -> m Natural #
Semiring Natural
Instance details Defined in Data.Semiring Methods plus :: Natural -> Natural -> Natural # zero :: Natural # times :: Natural -> Natural -> Natural # one :: Natural # fromNatural :: Natural -> Natural #
UnaryArithOpHs Eq' Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Eq' Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Eq' Natural ': s) #
UnaryArithOpHs Ge Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Ge Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Ge Natural ': s) #
UnaryArithOpHs Gt Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Gt Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Gt Natural ': s) #
UnaryArithOpHs Le Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Le Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Le Natural ': s) #
UnaryArithOpHs Lt Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Lt Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Lt Natural ': s) #
UnaryArithOpHs Neg Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neg Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Neg Natural ': s) #
UnaryArithOpHs Neq Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neq Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Neq Natural ': s) #
UnaryArithOpHs Not Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Not Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Not Natural ': s) #
Lift Natural
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Natural -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Natural -> Code m Natural #
r ~ Integer => ArithOpHs Add Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Add Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Add Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs And Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs And Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ Maybe (Mutez, Mutez) => ArithOpHs EDiv Mutez Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Mutez ': (Natural ': s)) :-> (r ': s) #
r ~ Maybe (Integer, Natural) => ArithOpHs EDiv Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Maybe (Integer, Natural) => ArithOpHs EDiv Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Maybe (Natural, Natural) => ArithOpHs EDiv Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs Lsl ByteString Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (Natural ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Lsl Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs Lsr ByteString Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (Natural ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Lsr Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ Mutez => ArithOpHs Mul Mutez Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Mutez ': (Natural ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Bls12381Fr Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Natural ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Mul Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Mutez => ArithOpHs Mul Natural Mutez r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Mutez ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Natural Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Mul Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Mul Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Or Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Xor Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
() :=> (Bits Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Bits Natural #
() :=> (Enum Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Natural #
() :=> (Num Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Natural #
() :=> (Read Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Natural #
() :=> (Integral Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Integral Natural #
() :=> (Real Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Natural #
() :=> (Show Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Natural #
() :=> (Eq Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Natural #
() :=> (Ord Natural)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Natural #
type Difference Natural
Instance details Defined in Basement.Numerical.Subtractive type Difference Natural = Maybe Natural
type IntBaseType Natural
Instance details Defined in Data.IntCast type IntBaseType Natural = 'BigWordTag
type AsRPC Natural
Instance details Defined in Morley.AsRPC type AsRPC Natural = Natural
type TypeDocFieldDescriptions Natural
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Natural = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Natural
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Natural = 'TNat
type PrettyShow Natural
Instance details Defined in Morley.Prelude.Show type PrettyShow Natural = ()
type UnaryArithResHs Eq' Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Eq' Natural = Bool
type UnaryArithResHs Ge Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Ge Natural = Bool
type UnaryArithResHs Gt Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Gt Natural = Bool
type UnaryArithResHs Le Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Le Natural = Bool
type UnaryArithResHs Lt Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Lt Natural = Bool
type UnaryArithResHs Neg Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neg Natural = Integer
type UnaryArithResHs Neq Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neq Natural = Bool
type UnaryArithResHs Not Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Not Natural = Integer

data Maybe a #

The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error.

The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

Constructors

Nothing
Just a

Instances

Instances details

MonadFail Maybe	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> Maybe a #
Foldable Maybe	Since: base-2.1
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # toList :: Maybe a -> [a] # null :: Maybe a -> Bool # length :: Maybe a -> Int # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # sum :: Num a => Maybe a -> a # product :: Num a => Maybe a -> a #
Traversable Maybe	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Alternative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
Applicative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # (>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Functor Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Monad Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a #
MonadPlus Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
MonadFailure Maybe
Instance details Defined in Basement.Monad Associated Types type Failure Maybe # Methods mFail :: Failure Maybe -> Maybe () #
NFData1 Maybe	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Maybe a -> () #
MonadThrow Maybe
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> Maybe a #
Hashable1 Maybe
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Maybe a -> Int #
KnownNamedFunctor Maybe
Instance details Defined in Morley.Util.Named Methods namedL :: forall (name :: Symbol) a. Label name -> Iso' (NamedF Maybe a name) (ApplyNamedFunctor Maybe a) #
InjValue Maybe
Instance details Defined in Named.Internal Methods injValue :: a -> Maybe a #
SMonadFail Maybe
Instance details Defined in Control.Monad.Fail.Singletons Methods sFail :: forall a (t :: [Char]). Sing t -> Sing (Apply FailSym0 t) #
PApplicative Maybe
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type Pure arg :: f a # type arg <> arg1 :: f b # type LiftA2 arg arg1 arg2 :: f c # type arg > arg1 :: f b # type arg <* arg1 :: f a #
PFunctor Maybe
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type Fmap arg arg1 :: f b # type arg <$ arg1 :: f a #
PMonad Maybe
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type arg >>= arg1 :: m b # type arg >> arg1 :: m b # type Return arg :: m a #
SAlternative Maybe
Instance details Defined in Control.Monad.Singletons.Internal Methods sEmpty :: Sing EmptySym0 # (%<\|>) :: forall a (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<\|>@#@$) t1) t2) #
SApplicative Maybe
Instance details Defined in Control.Monad.Singletons.Internal Methods sPure :: forall a (t :: a). Sing t -> Sing (Apply PureSym0 t) # (%<>) :: forall a b (t1 :: Maybe (a ~> b)) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sLiftA2 :: forall a b c (t1 :: a ~> (b ~> c)) (t2 :: Maybe a) (t3 :: Maybe b). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply LiftA2Sym0 t1) t2) t3) # (%>) :: forall a b (t1 :: Maybe a) (t2 :: Maybe b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%<) :: forall a b (t1 :: Maybe a) (t2 :: Maybe b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) #
SFunctor Maybe
Instance details Defined in Control.Monad.Singletons.Internal Methods sFmap :: forall a b (t1 :: a ~> b) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply FmapSym0 t1) t2) # (%<$) :: forall a b (t1 :: a) (t2 :: Maybe b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<$@#@$) t1) t2) #
SMonad Maybe
Instance details Defined in Control.Monad.Singletons.Internal Methods (%>>=) :: forall a b (t1 :: Maybe a) (t2 :: a ~> Maybe b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>>=@#@$) t1) t2) # (%>>) :: forall a b (t1 :: Maybe a) (t2 :: Maybe b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>>@#@$) t1) t2) # sReturn :: forall a (t :: a). Sing t -> Sing (Apply ReturnSym0 t) #
SMonadPlus Maybe
Instance details Defined in Control.Monad.Singletons.Internal Methods sMzero :: Sing MzeroSym0 # sMplus :: forall a (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MplusSym0 t1) t2) #
PFoldable Maybe
Instance details Defined in Data.Foldable.Singletons Associated Types type Fold arg :: m # type FoldMap arg arg1 :: m # type Foldr arg arg1 arg2 :: b # type Foldr' arg arg1 arg2 :: b # type Foldl arg arg1 arg2 :: b # type Foldl' arg arg1 arg2 :: b # type Foldr1 arg arg1 :: a # type Foldl1 arg arg1 :: a # type ToList arg :: [a] # type Null arg :: Bool # type Length arg :: Nat # type Elem arg arg1 :: Bool # type Maximum arg :: a # type Minimum arg :: a # type Sum arg :: a # type Product arg :: a #
SFoldable Maybe
Instance details Defined in Data.Foldable.Singletons Methods sFold :: forall m (t1 :: Maybe m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a m (t1 :: a ~> m) (t2 :: Maybe a). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Maybe a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Maybe a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Maybe a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Maybe a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a (t1 :: Maybe a). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a (t1 :: Maybe a). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a (t1 :: Maybe a). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a (t1 :: a) (t2 :: Maybe a). SEq a => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a (t1 :: Maybe a). SOrd a => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a (t1 :: Maybe a). SOrd a => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a (t1 :: Maybe a). SNum a => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a (t1 :: Maybe a). SNum a => Sing t1 -> Sing (Apply ProductSym0 t1) #
PTraversable Maybe
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable Maybe
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: Maybe a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: Maybe (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: Maybe a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: Maybe (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) #
MonadError () Maybe	Since: mtl-2.2.2
Instance details Defined in Control.Monad.Error.Class Methods throwError :: () -> Maybe a # catchError :: Maybe a -> (() -> Maybe a) -> Maybe a #
LorentzFunctor Maybe a b
Instance details Defined in Lorentz.Instr Methods lmap :: forall (s :: [Type]). KnownValue b => ('[a] :-> '[b]) -> (Maybe a ': s) :-> (Maybe b ': s) #
() :=> (Alternative Maybe)
Instance details Defined in Data.Constraint Methods ins :: () :- Alternative Maybe #
() :=> (Applicative Maybe)
Instance details Defined in Data.Constraint Methods ins :: () :- Applicative Maybe #
() :=> (Functor Maybe)
Instance details Defined in Data.Constraint Methods ins :: () :- Functor Maybe #
() :=> (MonadPlus Maybe)
Instance details Defined in Data.Constraint Methods ins :: () :- MonadPlus Maybe #
Lift a => Lift (Maybe a :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Maybe a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Maybe a -> Code m (Maybe a) #
Structured a => Structured (Maybe a)
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy (Maybe a) -> Structure # structureHash' :: Tagged (Maybe a) MD5
Semigroup a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: base-2.1*
Instance details Defined in GHC.Base Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Semigroup a => Semigroup (Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Generic (Maybe a)
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
SingKind a => SingKind (Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep (Maybe a) Methods fromSing :: forall (a0 :: Maybe a). Sing a0 -> DemoteRep (Maybe a)
Read a => Read (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (Maybe a) # readList :: ReadS [Maybe a] # readPrec :: ReadPrec (Maybe a) # readListPrec :: ReadPrec [Maybe a] #
Show a => Show (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Default (Maybe a)
Instance details Defined in Data.Default.Class Methods def :: Maybe a #
NFData a => NFData (Maybe a)
Instance details Defined in Control.DeepSeq Methods rnf :: Maybe a -> () #
Buildable a => Buildable (Maybe a)
Instance details Defined in Formatting.Buildable Methods build :: Maybe a -> Builder #
Eq a => Eq (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Ord a => Ord (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
Hashable a => Hashable (Maybe a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Maybe a -> Int # hash :: Maybe a -> Int #
At (Maybe a)
Instance details Defined in Control.Lens.At Methods at :: Index (Maybe a) -> Lens' (Maybe a) (Maybe (IxValue (Maybe a))) #
Ixed (Maybe a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Maybe a) -> Traversal' (Maybe a) (IxValue (Maybe a)) #
HasAnnotation a => HasAnnotation (Maybe a)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Maybe a)) # annOptions :: Maybe AnnOptions #
MapOpHs (Maybe e)
Instance details Defined in Lorentz.Polymorphic Associated Types type MapOpInpHs (Maybe e) # type MapOpResHs (Maybe e) :: Type -> Type #
HasRPCRepr a => HasRPCRepr (Maybe a)
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (Maybe a) #
PolyTypeHasDocC '[a] => TypeHasDoc (Maybe a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Maybe a) :: FieldDescriptions # Methods typeDocName :: Proxy (Maybe a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Maybe a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Maybe a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Maybe a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Maybe a) #
IsoValue a => IsoValue (Maybe a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Maybe a) :: T # Methods toVal :: Maybe a -> Value (ToT (Maybe a)) # fromVal :: Value (ToT (Maybe a)) -> Maybe a #
Semiring a => Semiring (Maybe a)
Instance details Defined in Data.Semiring Methods plus :: Maybe a -> Maybe a -> Maybe a # zero :: Maybe a # times :: Maybe a -> Maybe a -> Maybe a # one :: Maybe a # fromNatural :: Natural -> Maybe a #
PEq (Maybe a)
Instance details Defined in Data.Eq.Singletons Associated Types type arg == arg1 :: Bool # type arg /= arg1 :: Bool #
SEq a => SEq (Maybe a)
Instance details Defined in Data.Eq.Singletons Methods (%==) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (==@#@$) t1) t2) # (%/=) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (/=@#@$) t1) t2) #
PMonoid (Maybe a)
Instance details Defined in Data.Monoid.Singletons Associated Types type Mempty :: a # type Mappend arg arg1 :: a # type Mconcat arg :: a #
SSemigroup a => SMonoid (Maybe a)
Instance details Defined in Data.Monoid.Singletons Methods sMempty :: Sing MemptySym0 # sMappend :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MappendSym0 t1) t2) # sMconcat :: forall (t :: [Maybe a]). Sing t -> Sing (Apply MconcatSym0 t) #
POrd (Maybe a)
Instance details Defined in Data.Ord.Singletons Associated Types type Compare arg arg1 :: Ordering # type arg < arg1 :: Bool # type arg <= arg1 :: Bool # type arg > arg1 :: Bool # type arg >= arg1 :: Bool # type Max arg arg1 :: a # type Min arg arg1 :: a #
SOrd a => SOrd (Maybe a)
Instance details Defined in Data.Ord.Singletons Methods sCompare :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2) # (%<) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) # (%<=) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2) # (%>) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%>=) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2) # sMax :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2) # sMin :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2) #
PSemigroup (Maybe a)
Instance details Defined in Data.Semigroup.Singletons.Internal Associated Types type arg <> arg1 :: a # type Sconcat arg :: a #
SSemigroup a => SSemigroup (Maybe a)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods (%<>) :: forall (t1 :: Maybe a) (t2 :: Maybe a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sSconcat :: forall (t :: NonEmpty (Maybe a)). Sing t -> Sing (Apply SconcatSym0 t) #
PShow (Maybe a)
Instance details Defined in Text.Show.Singletons Associated Types type ShowsPrec arg arg1 arg2 :: Symbol # type Show_ arg :: Symbol # type ShowList arg arg1 :: Symbol #
SShow a => SShow (Maybe a)
Instance details Defined in Text.Show.Singletons Methods sShowsPrec :: forall (t1 :: Nat) (t2 :: Maybe a) (t3 :: Symbol). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3) # sShow_ :: forall (t :: Maybe a). Sing t -> Sing (Apply Show_Sym0 t) # sShowList :: forall (t1 :: [Maybe a]) (t2 :: Symbol). Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2) #
(TypeError (DisallowInstance "Maybe") :: Constraint) => Container (Maybe a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Maybe a) # Methods toList :: Maybe a -> [Element (Maybe a)] # null :: Maybe a -> Bool # foldr :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> Element (Maybe a) -> b) -> b -> Maybe a -> b # foldl' :: (b -> Element (Maybe a) -> b) -> b -> Maybe a -> b # length :: Maybe a -> Int # elem :: Element (Maybe a) -> Maybe a -> Bool # foldMap :: Monoid m => (Element (Maybe a) -> m) -> Maybe a -> m # fold :: Maybe a -> Element (Maybe a) # foldr' :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b # notElem :: Element (Maybe a) -> Maybe a -> Bool # all :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool # any :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool # and :: Maybe a -> Bool # or :: Maybe a -> Bool # find :: (Element (Maybe a) -> Bool) -> Maybe a -> Maybe (Element (Maybe a)) # safeHead :: Maybe a -> Maybe (Element (Maybe a)) # safeMaximum :: Maybe a -> Maybe (Element (Maybe a)) # safeMinimum :: Maybe a -> Maybe (Element (Maybe a)) # safeFoldr1 :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe (Element (Maybe a)) # safeFoldl1 :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe (Element (Maybe a)) #
Generic1 Maybe
Instance details Defined in GHC.Generics Associated Types type Rep1 Maybe :: k -> Type # Methods from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a # to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a #
PMonadFail Maybe
Instance details Defined in Control.Monad.Fail.Singletons Associated Types type Fail arg :: m a #
PAlternative Maybe
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type Empty :: f a # type arg <\|> arg1 :: f a #
PMonadPlus Maybe
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type Mzero :: m a # type Mplus arg arg1 :: m a #
IsoHKD Maybe (a :: Type)
Instance details Defined in Data.Vinyl.XRec Associated Types type HKD Maybe a # Methods unHKD :: HKD Maybe a -> Maybe a # toHKD :: Maybe a -> HKD Maybe a #
SDecide a => TestCoercion (SMaybe :: Maybe a -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods testCoercion :: forall (a0 :: k) (b :: k). SMaybe a0 -> SMaybe b -> Maybe (Coercion a0 b) #
SDecide a => TestEquality (SMaybe :: Maybe a -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods testEquality :: forall (a0 :: k) (b :: k). SMaybe a0 -> SMaybe b -> Maybe (a0 :~: b) #
SingI ('Nothing :: Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing 'Nothing
(Monoid a) :=> (Monoid (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Monoid (Maybe a) #
(Semigroup a) :=> (Semigroup (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Semigroup a :- Semigroup (Maybe a) #
(Read a) :=> (Read (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Read a :- Read (Maybe a) #
(Show a) :=> (Show (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Show a :- Show (Maybe a) #
(Eq a) :=> (Eq (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Eq a :- Eq (Maybe a) #
(Ord a) :=> (Ord (Maybe a))
Instance details Defined in Data.Constraint Methods ins :: Ord a :- Ord (Maybe a) #
Each (Maybe a) (Maybe b) a b
Instance details Defined in Lens.Micro.Internal Methods each :: Traversal (Maybe a) (Maybe b) a b #
CanCastTo a b => CanCastTo (Maybe a :: Type) (Maybe b :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Maybe a) -> Proxy (Maybe b) -> () #
SingI a2 => SingI ('Just a2 :: Maybe a1)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing ('Just a2)
SingI (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing GetFirstSym0 #
SingI (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing GetLastSym0 #
SingI (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing FindIndexSym0 #
SingI (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing FindSym0 #
SingI (GetMaxInternalSym0 :: TyFun (MaxInternal a) (Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing GetMaxInternalSym0 #
SingI (GetMinInternalSym0 :: TyFun (MinInternal a) (Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing GetMinInternalSym0 #
SingI (FirstSym0 :: TyFun (Maybe a) (First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing FirstSym0 #
SingI (LastSym0 :: TyFun (Maybe a) (Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing LastSym0 #
SingI (MaxInternalSym0 :: TyFun (Maybe a) (MaxInternal a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MaxInternalSym0 #
SingI (MinInternalSym0 :: TyFun (Maybe a) (MinInternal a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MinInternalSym0 #
SingI (IsJustSym0 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing IsJustSym0 #
SingI (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing IsNothingSym0 #
SingI (MaybeToListSym0 :: TyFun (Maybe a) [a] -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing MaybeToListSym0 #
SingI (FromJustSym0 :: TyFun (Maybe a) a -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing FromJustSym0 #
SingI (CatMaybesSym0 :: TyFun [Maybe a] [a] -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing CatMaybesSym0 #
SingI (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing ListToMaybeSym0 #
SingI (FromMaybeSym0 :: TyFun a (Maybe a ~> a) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing FromMaybeSym0 #
SEq a => SingI (ElemIndexSym0 :: TyFun a ([a] ~> Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing ElemIndexSym0 #
SingI (JustSym0 :: TyFun a (Maybe a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing JustSym0 #
SuppressUnusedWarnings (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GetMaxInternalSym0 :: TyFun (MaxInternal a) (Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GetMinInternalSym0 :: TyFun (MinInternal a) (Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FirstSym0 :: TyFun (Maybe a) (First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LastSym0 :: TyFun (Maybe a) (Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679180719Sym0 :: TyFun (Maybe a) (Maybe a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357720Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679584139Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130516Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MaxInternalSym0 :: TyFun (Maybe a) (MaxInternal a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MinInternalSym0 :: TyFun (Maybe a) (MinInternal a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsJustSym0 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MaybeToListSym0 :: TyFun (Maybe a) [a] -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromJustSym0 :: TyFun (Maybe a) a -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680071724Sym0 :: TyFun Nat (Maybe a ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (CatMaybesSym0 :: TyFun [Maybe a] [a] -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fail_6989586621679456264Sym0 :: TyFun [Char] (Maybe a) -> Type)
Instance details Defined in Control.Monad.Fail.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (StripPrefixSym0 :: TyFun [a] ([a] ~> Maybe [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromMaybeSym0 :: TyFun a (Maybe a ~> a) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ElemIndexSym0 :: TyFun a ([a] ~> Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621679357459Sym0 :: TyFun a (Maybe a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (JustSym0 :: TyFun a (Maybe a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357729LSym0 :: TyFun k1 (Maybe k1) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SingI (MapMaybeSym0 :: TyFun (a ~> Maybe b) ([a] ~> [b]) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing MapMaybeSym0 #
SFoldable t => SingI (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing FindSym0 #
SingI (UnfoldrSym0 :: TyFun (b ~> Maybe (a, b)) (b ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing UnfoldrSym0 #
SingI d => SingI (FromMaybeSym1 d :: TyFun (Maybe a) a -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing (FromMaybeSym1 d) #
(SEq a, SingI d) => SingI (ElemIndexSym1 d :: TyFun [a] (Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (ElemIndexSym1 d) #
SingI d => SingI (FindIndexSym1 d :: TyFun [a] (Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (FindIndexSym1 d) #
SingI d => SingI (FindSym1 d :: TyFun [a] (Maybe a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (FindSym1 d) #
SEq a => SingI (LookupSym0 :: TyFun a ([(a, b)] ~> Maybe b) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing LookupSym0 #
SingI (Maybe_Sym0 :: TyFun b ((a ~> b) ~> (Maybe a ~> b)) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing Maybe_Sym0 #
SAlternative f => SingI (OptionalSym0 :: TyFun (f a) (f (Maybe a)) -> Type)
Instance details Defined in Control.Applicative.Singletons Methods sing :: Sing OptionalSym0 #
SuppressUnusedWarnings (Foldr_6989586621680193829Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Maybe a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MapMaybeSym0 :: TyFun (a ~> Maybe b) ([a] ~> [b]) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679357336Sym0 :: TyFun (a ~> b) (Maybe a ~> Maybe b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680193813Sym0 :: TyFun (a ~> m) (Maybe a ~> m) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680193845Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Maybe a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (UnfoldrSym0 :: TyFun (b ~> Maybe (a, b)) (b ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357469Sym0 :: TyFun (Maybe (a ~> b)) (Maybe a ~> Maybe b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679180719Sym1 a6989586621679180724 :: TyFun (Maybe a) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357633Sym0 :: TyFun (Maybe a) ((a ~> Maybe b) ~> Maybe b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357496Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357644Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680071724Sym1 a6989586621680071734 :: TyFun (Maybe a) (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357720Sym1 a6989586621679357725 :: TyFun (Maybe a) (Maybe a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679584139Sym1 a6989586621679584144 :: TyFun (Maybe a) (Maybe a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130516Sym1 a6989586621679130521 :: TyFun (Maybe a) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromMaybeSym1 a6989586621679486193 :: TyFun (Maybe a) a -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ElemIndexSym1 a6989586621679731471 :: TyFun [a] (Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FindIndexSym1 a6989586621679731453 :: TyFun [a] (Maybe Nat) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (StripPrefixSym1 a6989586621679880880 :: TyFun [a] (Maybe [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FindSym1 a6989586621679731480 :: TyFun [a] (Maybe a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357348Sym0 :: TyFun a (Maybe b ~> Maybe a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LookupSym0 :: TyFun a ([(a, b)] ~> Maybe b) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Maybe_Sym0 :: TyFun b ((a ~> b) ~> (Maybe a ~> b)) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (OptionalSym0 :: TyFun (f a) (f (Maybe a)) -> Type)
Instance details Defined in Control.Applicative.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193772MkJustSym0 :: TyFun k (TyFun a6989586621680192944 (Maybe a6989586621680192944) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193787MkJustSym0 :: TyFun k (TyFun a6989586621680192945 (Maybe a6989586621680192945) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184048NSym0 :: TyFun k (TyFun k1 (Maybe k1) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184072NSym0 :: TyFun k (TyFun k1 (Maybe k1) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184048MSym0 :: TyFun k1 (TyFun k (Maybe k1) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184072MSym0 :: TyFun k1 (TyFun k (Maybe k1) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SingI d => SingI (Maybe_Sym1 d :: TyFun (a ~> b) (Maybe a ~> b) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing (Maybe_Sym1 d) #
(SEq a, SingI d) => SingI (LookupSym1 d :: TyFun [(a, b)] (Maybe b) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing (LookupSym1 d) #
(SFoldable t, SingI d) => SingI (FindSym1 d :: TyFun (t a) (Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing (FindSym1 d) #
SuppressUnusedWarnings (LiftA2_6989586621679357482Sym0 :: TyFun (a ~> (b ~> c)) (Maybe a ~> (Maybe b ~> Maybe c)) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357633Sym1 a6989586621679357638 :: TyFun (a ~> Maybe b) (Maybe b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679486168RsSym0 :: TyFun (a ~> Maybe k1) (TyFun k (TyFun [a] [k1] -> Type) -> Type) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Maybe_Sym1 a6989586621679484326 :: TyFun (a ~> b) (Maybe a ~> b) -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478666Sym0 :: TyFun (a ~> f b) (Maybe a ~> f (Maybe b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193673MfSym0 :: TyFun (k2 ~> (k3 ~> k2)) (TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193694MfSym0 :: TyFun (k2 ~> (k3 ~> k3)) (TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679357336Sym1 a6989586621679357341 :: TyFun (Maybe a) (Maybe b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357469Sym1 a6989586621679357474 :: TyFun (Maybe a) (Maybe b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680193813Sym1 a6989586621680193822 :: TyFun (Maybe a) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357348Sym1 a6989586621679357353 :: TyFun (Maybe b) (Maybe a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357496Sym1 a6989586621679357501 :: TyFun (Maybe b) (Maybe b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357644Sym1 a6989586621679357653 :: TyFun (Maybe b) (Maybe b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LookupSym1 a6989586621679731178 :: TyFun [(a, b)] (Maybe b) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193772MkJustSym1 a_69895866216801937666989586621680193771 :: TyFun a6989586621680192944 (Maybe a6989586621680192944) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193787MkJustSym1 a_69895866216801937816989586621680193786 :: TyFun a6989586621680192945 (Maybe a6989586621680192945) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680193845Sym1 a6989586621680193851 :: TyFun b (Maybe a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680193829Sym1 a6989586621680193835 :: TyFun b (Maybe a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184048MSym1 x6989586621680184046 :: TyFun k (Maybe k1) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184072MSym1 x6989586621680184070 :: TyFun k (Maybe k1) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680118497Sym0 :: TyFun k (TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680118708Sym0 :: TyFun k (TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184048NSym1 x6989586621680184046 :: TyFun k1 (Maybe k1) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680184072NSym1 x6989586621680184070 :: TyFun k1 (Maybe k1) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FindSym1 a6989586621680193279 :: TyFun (t a) (Maybe a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
(SingI d1, SingI d2) => SingI (Maybe_Sym2 d1 d2 :: TyFun (Maybe a) b -> Type)
Instance details Defined in Data.Maybe.Singletons Methods sing :: Sing (Maybe_Sym2 d1 d2) #
SuppressUnusedWarnings (Lambda_6989586621680118497Sym1 a6989586621680118495 :: TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680118708Sym1 a6989586621680118706 :: TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621679357482Sym1 a6989586621679357488 :: TyFun (Maybe a) (Maybe b ~> Maybe c) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680193845Sym2 a6989586621680193851 a6989586621680193852 :: TyFun (Maybe a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680193829Sym2 a6989586621680193835 a6989586621680193836 :: TyFun (Maybe a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Maybe_Sym2 a6989586621679484326 a6989586621679484327 :: TyFun (Maybe a) b -> Type)
Instance details Defined in Data.Maybe.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478666Sym1 a6989586621680478671 :: TyFun (Maybe a) (f (Maybe b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193694MfSym1 f6989586621680193692 :: TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193673MfSym1 f6989586621680193671 :: TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621679357482Sym2 a6989586621679357488 a6989586621679357489 :: TyFun (Maybe b) (Maybe c) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193694MfSym2 f6989586621680193692 xs6989586621680193693 :: TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680118497Sym2 a6989586621680118495 k6989586621680118496 :: TyFun k1 (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680118708Sym2 a6989586621680118706 k6989586621680118707 :: TyFun k1 (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193673MfSym2 f6989586621680193671 xs6989586621680193672 :: TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193673MfSym3 f6989586621680193671 xs6989586621680193672 a6989586621680193674 :: TyFun (Maybe k3) (Maybe k2) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193694MfSym3 f6989586621680193692 xs6989586621680193693 a6989586621680193695 :: TyFun k3 (Maybe k3) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
(HasAnnotation (Maybe a), KnownSymbol name) => HasAnnotation (NamedF Maybe a name)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (NamedF Maybe a name)) # annOptions :: Maybe AnnOptions #
Unwrappable (NamedF Maybe a name)
Instance details Defined in Lorentz.Wrappable Associated Types type Unwrappabled (NamedF Maybe a name) #
Wrappable (NamedF Maybe a name)
Instance details Defined in Lorentz.Wrappable
HasRPCRepr a => HasRPCRepr (NamedF Maybe a name)
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (NamedF Maybe a name) #
IsoValue a => IsoValue (NamedF Maybe a name)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (NamedF Maybe a name) :: T # Methods toVal :: NamedF Maybe a name -> Value (ToT (NamedF Maybe a name)) # fromVal :: Value (ToT (NamedF Maybe a name)) -> NamedF Maybe a name #
type Failure Maybe
Instance details Defined in Basement.Monad type Failure Maybe = ()
type Pure (a :: k1)
Instance details Defined in Control.Monad.Singletons.Internal type Pure (a :: k1) = Apply (Pure_6989586621679357459Sym0 :: TyFun k1 (Maybe k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Control.Monad.Singletons.Internal type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (Maybe a) -> Type) arg
type Fold (arg :: Maybe m)
Instance details Defined in Data.Foldable.Singletons type Fold (arg :: Maybe m) = Apply (Fold_6989586621680193565Sym0 :: TyFun (Maybe m) m -> Type) arg
type Length (arg :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Length (arg :: Maybe a) = Apply (Length_6989586621680193731Sym0 :: TyFun (Maybe a) Nat -> Type) arg
type Maximum (arg :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Maximum (arg :: Maybe a) = Apply (Maximum_6989586621680193764Sym0 :: TyFun (Maybe a) a -> Type) arg
type Minimum (arg :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Minimum (arg :: Maybe a) = Apply (Minimum_6989586621680193779Sym0 :: TyFun (Maybe a) a -> Type) arg
type Null (arg :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Null (arg :: Maybe a) = Apply (Null_6989586621680193714Sym0 :: TyFun (Maybe a) Bool -> Type) arg
type Product (arg :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Product (arg :: Maybe a) = Apply (Product_6989586621680193803Sym0 :: TyFun (Maybe a) a -> Type) arg
type Sum (arg :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Sum (arg :: Maybe a) = Apply (Sum_6989586621680193794Sym0 :: TyFun (Maybe a) a -> Type) arg
type ToList (arg :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type ToList (arg :: Maybe a) = Apply (ToList_6989586621680193705Sym0 :: TyFun (Maybe a) [a] -> Type) arg
type Elem (arg1 :: a) (arg2 :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Elem (arg1 :: a) (arg2 :: Maybe a) = Apply (Apply (Elem_6989586621680193750Sym0 :: TyFun a (Maybe a ~> Bool) -> Type) arg1) arg2
type Foldl1 (arg1 :: a ~> (a ~> a)) (arg2 :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Foldl1 (arg1 :: a ~> (a ~> a)) (arg2 :: Maybe a) = Apply (Apply (Foldl1_6989586621680193685Sym0 :: TyFun (a ~> (a ~> a)) (Maybe a ~> a) -> Type) arg1) arg2
type Foldr1 (arg1 :: a ~> (a ~> a)) (arg2 :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Foldr1 (arg1 :: a ~> (a ~> a)) (arg2 :: Maybe a) = Apply (Apply (Foldr1_6989586621680193664Sym0 :: TyFun (a ~> (a ~> a)) (Maybe a ~> a) -> Type) arg1) arg2
type Sequence (arg :: Maybe (m a))
Instance details Defined in Data.Traversable.Singletons type Sequence (arg :: Maybe (m a)) = Apply (Sequence_6989586621680471117Sym0 :: TyFun (Maybe (m a)) (m (Maybe a)) -> Type) arg
type SequenceA (arg :: Maybe (f a))
Instance details Defined in Data.Traversable.Singletons type SequenceA (arg :: Maybe (f a)) = Apply (SequenceA_6989586621680471093Sym0 :: TyFun (Maybe (f a)) (f (Maybe a)) -> Type) arg
type (a2 :: Maybe a1) *> (a3 :: Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type (a2 :: Maybe a1) *> (a3 :: Maybe b) = Apply (Apply (TFHelper_6989586621679357496Sym0 :: TyFun (Maybe a1) (Maybe b ~> Maybe b) -> Type) a2) a3
type (a1 :: k1) <$ (a2 :: Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type (a1 :: k1) <$ (a2 :: Maybe b) = Apply (Apply (TFHelper_6989586621679357348Sym0 :: TyFun k1 (Maybe b ~> Maybe k1) -> Type) a1) a2
type (arg1 :: Maybe a) <* (arg2 :: Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type (arg1 :: Maybe a) <* (arg2 :: Maybe b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe a) -> Type) arg1) arg2
type (a2 :: Maybe (a1 ~> b)) <*> (a3 :: Maybe a1)
Instance details Defined in Control.Monad.Singletons.Internal type (a2 :: Maybe (a1 ~> b)) <*> (a3 :: Maybe a1) = Apply (Apply (TFHelper_6989586621679357469Sym0 :: TyFun (Maybe (a1 ~> b)) (Maybe a1 ~> Maybe b) -> Type) a2) a3
type (a2 :: Maybe a1) >> (a3 :: Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type (a2 :: Maybe a1) >> (a3 :: Maybe b) = Apply (Apply (TFHelper_6989586621679357644Sym0 :: TyFun (Maybe a1) (Maybe b ~> Maybe b) -> Type) a2) a3
type (a2 :: Maybe a1) >>= (a3 :: a1 ~> Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type (a2 :: Maybe a1) >>= (a3 :: a1 ~> Maybe b) = Apply (Apply (TFHelper_6989586621679357633Sym0 :: TyFun (Maybe a1) ((a1 ~> Maybe b) ~> Maybe b) -> Type) a2) a3
type Fmap (a2 :: a1 ~> b) (a3 :: Maybe a1)
Instance details Defined in Control.Monad.Singletons.Internal type Fmap (a2 :: a1 ~> b) (a3 :: Maybe a1) = Apply (Apply (Fmap_6989586621679357336Sym0 :: TyFun (a1 ~> b) (Maybe a1 ~> Maybe b) -> Type) a2) a3
type FoldMap (a2 :: a1 ~> k2) (a3 :: Maybe a1)
Instance details Defined in Data.Foldable.Singletons type FoldMap (a2 :: a1 ~> k2) (a3 :: Maybe a1) = Apply (Apply (FoldMap_6989586621680193813Sym0 :: TyFun (a1 ~> k2) (Maybe a1 ~> k2) -> Type) a2) a3
type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Maybe a1)
Instance details Defined in Data.Foldable.Singletons type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Maybe a1) = Apply (Apply (Apply (Foldl_6989586621680193845Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (Maybe a1 ~> k2)) -> Type) a2) a3) a4
type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: Maybe a) = Apply (Apply (Apply (Foldl'_6989586621680193642Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Maybe a ~> b)) -> Type) arg1) arg2) arg3
type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Maybe a1)
Instance details Defined in Data.Foldable.Singletons type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Maybe a1) = Apply (Apply (Apply (Foldr_6989586621680193829Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Maybe a1 ~> k2)) -> Type) a2) a3) a4
type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: Maybe a) = Apply (Apply (Apply (Foldr'_6989586621680193604Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Maybe a ~> b)) -> Type) arg1) arg2) arg3
type MapM (arg1 :: a ~> m b) (arg2 :: Maybe a)
Instance details Defined in Data.Traversable.Singletons type MapM (arg1 :: a ~> m b) (arg2 :: Maybe a) = Apply (Apply (MapM_6989586621680471103Sym0 :: TyFun (a ~> m b) (Maybe a ~> m (Maybe b)) -> Type) arg1) arg2
type Traverse (a2 :: a1 ~> f b) (a3 :: Maybe a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a2 :: a1 ~> f b) (a3 :: Maybe a1) = Apply (Apply (Traverse_6989586621680478666Sym0 :: TyFun (a1 ~> f b) (Maybe a1 ~> f (Maybe b)) -> Type) a2) a3
type LiftA2 (a2 :: a1 ~> (b ~> c)) (a3 :: Maybe a1) (a4 :: Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type LiftA2 (a2 :: a1 ~> (b ~> c)) (a3 :: Maybe a1) (a4 :: Maybe b) = Apply (Apply (Apply (LiftA2_6989586621679357482Sym0 :: TyFun (a1 ~> (b ~> c)) (Maybe a1 ~> (Maybe b ~> Maybe c)) -> Type) a2) a3) a4
type Apply (Pure_6989586621679357459Sym0 :: TyFun a (Maybe a) -> Type) (a6989586621679357465 :: a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Pure_6989586621679357459Sym0 :: TyFun a (Maybe a) -> Type) (a6989586621679357465 :: a) = Pure_6989586621679357459 a6989586621679357465
type Apply (JustSym0 :: TyFun a (Maybe a) -> Type) (a6989586621679028273 :: a)
Instance details Defined in Data.Singletons.Base.Instances type Apply (JustSym0 :: TyFun a (Maybe a) -> Type) (a6989586621679028273 :: a) = 'Just a6989586621679028273
type Apply (Let6989586621679357729LSym0 :: TyFun k1 (Maybe k1) -> Type) (wild_69895866216793565086989586621679357728 :: k1)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357729LSym0 :: TyFun k1 (Maybe k1) -> Type) (wild_69895866216793565086989586621679357728 :: k1) = Let6989586621679357729L wild_69895866216793565086989586621679357728
type Apply (Let6989586621680193772MkJustSym1 a_69895866216801937666989586621680193771 :: TyFun a (Maybe a) -> Type) (a6989586621680193775 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193772MkJustSym1 a_69895866216801937666989586621680193771 :: TyFun a (Maybe a) -> Type) (a6989586621680193775 :: a) = Let6989586621680193772MkJust a_69895866216801937666989586621680193771 a6989586621680193775
type Apply (Let6989586621680193787MkJustSym1 a_69895866216801937816989586621680193786 :: TyFun a (Maybe a) -> Type) (a6989586621680193790 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193787MkJustSym1 a_69895866216801937816989586621680193786 :: TyFun a (Maybe a) -> Type) (a6989586621680193790 :: a) = Let6989586621680193787MkJust a_69895866216801937816989586621680193786 a6989586621680193790
type Apply (Let6989586621680184048MSym1 x6989586621680184046 :: TyFun k (Maybe k1) -> Type) (y6989586621680184047 :: k)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184048MSym1 x6989586621680184046 :: TyFun k (Maybe k1) -> Type) (y6989586621680184047 :: k) = Let6989586621680184048M x6989586621680184046 y6989586621680184047
type Apply (Let6989586621680184072MSym1 x6989586621680184070 :: TyFun k (Maybe k1) -> Type) (y6989586621680184071 :: k)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184072MSym1 x6989586621680184070 :: TyFun k (Maybe k1) -> Type) (y6989586621680184071 :: k) = Let6989586621680184072M x6989586621680184070 y6989586621680184071
type Apply (Let6989586621680184048NSym1 x6989586621680184046 :: TyFun k1 (Maybe k1) -> Type) (y6989586621680184047 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184048NSym1 x6989586621680184046 :: TyFun k1 (Maybe k1) -> Type) (y6989586621680184047 :: k1) = Let6989586621680184048N x6989586621680184046 y6989586621680184047
type Apply (Let6989586621680184072NSym1 x6989586621680184070 :: TyFun k1 (Maybe k1) -> Type) (y6989586621680184071 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184072NSym1 x6989586621680184070 :: TyFun k1 (Maybe k1) -> Type) (y6989586621680184071 :: k1) = Let6989586621680184072N x6989586621680184070 y6989586621680184071
type Apply (Lambda_6989586621680118497Sym2 a6989586621680118495 k6989586621680118496 :: TyFun k1 (Maybe a) -> Type) (x6989586621680118499 :: k1)
Instance details Defined in Data.Monoid.Singletons type Apply (Lambda_6989586621680118497Sym2 a6989586621680118495 k6989586621680118496 :: TyFun k1 (Maybe a) -> Type) (x6989586621680118499 :: k1) = Lambda_6989586621680118497 a6989586621680118495 k6989586621680118496 x6989586621680118499
type Apply (Lambda_6989586621680118708Sym2 a6989586621680118706 k6989586621680118707 :: TyFun k1 (Maybe a) -> Type) (x6989586621680118710 :: k1)
Instance details Defined in Data.Monoid.Singletons type Apply (Lambda_6989586621680118708Sym2 a6989586621680118706 k6989586621680118707 :: TyFun k1 (Maybe a) -> Type) (x6989586621680118710 :: k1) = Lambda_6989586621680118708 a6989586621680118706 k6989586621680118707 x6989586621680118710
type Apply (Let6989586621680193694MfSym3 f6989586621680193692 xs6989586621680193693 a6989586621680193695 :: TyFun k3 (Maybe k3) -> Type) (a6989586621680193696 :: k3)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193694MfSym3 f6989586621680193692 xs6989586621680193693 a6989586621680193695 :: TyFun k3 (Maybe k3) -> Type) (a6989586621680193696 :: k3) = Let6989586621680193694Mf f6989586621680193692 xs6989586621680193693 a6989586621680193695 a6989586621680193696
type Apply (ShowsPrec_6989586621680071724Sym0 :: TyFun Nat (Maybe a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680071734 :: Nat)
Instance details Defined in Text.Show.Singletons type Apply (ShowsPrec_6989586621680071724Sym0 :: TyFun Nat (Maybe a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680071734 :: Nat) = ShowsPrec_6989586621680071724Sym1 a6989586621680071734 :: TyFun (Maybe a) (Symbol ~> Symbol) -> Type
type Apply (FromMaybeSym0 :: TyFun a (Maybe a ~> a) -> Type) (a6989586621679486193 :: a)
Instance details Defined in Data.Maybe.Singletons type Apply (FromMaybeSym0 :: TyFun a (Maybe a ~> a) -> Type) (a6989586621679486193 :: a) = FromMaybeSym1 a6989586621679486193
type Apply (ElemIndexSym0 :: TyFun a ([a] ~> Maybe Nat) -> Type) (a6989586621679731471 :: a)
Instance details Defined in Data.List.Singletons.Internal type Apply (ElemIndexSym0 :: TyFun a ([a] ~> Maybe Nat) -> Type) (a6989586621679731471 :: a) = ElemIndexSym1 a6989586621679731471
type Apply (TFHelper_6989586621679357348Sym0 :: TyFun a (Maybe b ~> Maybe a) -> Type) (a6989586621679357353 :: a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357348Sym0 :: TyFun a (Maybe b ~> Maybe a) -> Type) (a6989586621679357353 :: a) = TFHelper_6989586621679357348Sym1 a6989586621679357353 :: TyFun (Maybe b) (Maybe a) -> Type
type Apply (LookupSym0 :: TyFun a ([(a, b)] ~> Maybe b) -> Type) (a6989586621679731178 :: a)
Instance details Defined in Data.List.Singletons.Internal type Apply (LookupSym0 :: TyFun a ([(a, b)] ~> Maybe b) -> Type) (a6989586621679731178 :: a) = LookupSym1 a6989586621679731178 :: TyFun [(a, b)] (Maybe b) -> Type
type Apply (Maybe_Sym0 :: TyFun b ((a ~> b) ~> (Maybe a ~> b)) -> Type) (a6989586621679484326 :: b)
Instance details Defined in Data.Maybe.Singletons type Apply (Maybe_Sym0 :: TyFun b ((a ~> b) ~> (Maybe a ~> b)) -> Type) (a6989586621679484326 :: b) = Maybe_Sym1 a6989586621679484326 :: TyFun (a ~> b) (Maybe a ~> b) -> Type
type Apply (Let6989586621680193772MkJustSym0 :: TyFun k (TyFun a6989586621680192944 (Maybe a6989586621680192944) -> Type) -> Type) (a_69895866216801937666989586621680193771 :: k)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193772MkJustSym0 :: TyFun k (TyFun a6989586621680192944 (Maybe a6989586621680192944) -> Type) -> Type) (a_69895866216801937666989586621680193771 :: k) = Let6989586621680193772MkJustSym1 a_69895866216801937666989586621680193771 :: TyFun a6989586621680192944 (Maybe a6989586621680192944) -> Type
type Apply (Let6989586621680193787MkJustSym0 :: TyFun k (TyFun a6989586621680192945 (Maybe a6989586621680192945) -> Type) -> Type) (a_69895866216801937816989586621680193786 :: k)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193787MkJustSym0 :: TyFun k (TyFun a6989586621680192945 (Maybe a6989586621680192945) -> Type) -> Type) (a_69895866216801937816989586621680193786 :: k) = Let6989586621680193787MkJustSym1 a_69895866216801937816989586621680193786 :: TyFun a6989586621680192945 (Maybe a6989586621680192945) -> Type
type Apply (Let6989586621680184048NSym0 :: TyFun k (TyFun k1 (Maybe k1) -> Type) -> Type) (x6989586621680184046 :: k)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184048NSym0 :: TyFun k (TyFun k1 (Maybe k1) -> Type) -> Type) (x6989586621680184046 :: k) = Let6989586621680184048NSym1 x6989586621680184046 :: TyFun k1 (Maybe k1) -> Type
type Apply (Let6989586621680184072NSym0 :: TyFun k (TyFun k1 (Maybe k1) -> Type) -> Type) (x6989586621680184070 :: k)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184072NSym0 :: TyFun k (TyFun k1 (Maybe k1) -> Type) -> Type) (x6989586621680184070 :: k) = Let6989586621680184072NSym1 x6989586621680184070 :: TyFun k1 (Maybe k1) -> Type
type Apply (Let6989586621680184048MSym0 :: TyFun k1 (TyFun k (Maybe k1) -> Type) -> Type) (x6989586621680184046 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184048MSym0 :: TyFun k1 (TyFun k (Maybe k1) -> Type) -> Type) (x6989586621680184046 :: k1) = Let6989586621680184048MSym1 x6989586621680184046 :: TyFun k (Maybe k1) -> Type
type Apply (Let6989586621680184072MSym0 :: TyFun k1 (TyFun k (Maybe k1) -> Type) -> Type) (x6989586621680184070 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680184072MSym0 :: TyFun k1 (TyFun k (Maybe k1) -> Type) -> Type) (x6989586621680184070 :: k1) = Let6989586621680184072MSym1 x6989586621680184070 :: TyFun k (Maybe k1) -> Type
type Apply (Foldl_6989586621680193845Sym1 a6989586621680193851 :: TyFun b (Maybe a ~> b) -> Type) (a6989586621680193852 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680193845Sym1 a6989586621680193851 :: TyFun b (Maybe a ~> b) -> Type) (a6989586621680193852 :: b) = Foldl_6989586621680193845Sym2 a6989586621680193851 a6989586621680193852
type Apply (Foldr_6989586621680193829Sym1 a6989586621680193835 :: TyFun b (Maybe a ~> b) -> Type) (a6989586621680193836 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680193829Sym1 a6989586621680193835 :: TyFun b (Maybe a ~> b) -> Type) (a6989586621680193836 :: b) = Foldr_6989586621680193829Sym2 a6989586621680193835 a6989586621680193836
type Apply (Lambda_6989586621680118497Sym0 :: TyFun k (TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) (a6989586621680118495 :: k)
Instance details Defined in Data.Monoid.Singletons type Apply (Lambda_6989586621680118497Sym0 :: TyFun k (TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) (a6989586621680118495 :: k) = Lambda_6989586621680118497Sym1 a6989586621680118495 :: TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type
type Apply (Lambda_6989586621680118708Sym0 :: TyFun k (TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) (a6989586621680118706 :: k)
Instance details Defined in Data.Monoid.Singletons type Apply (Lambda_6989586621680118708Sym0 :: TyFun k (TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) (a6989586621680118706 :: k) = Lambda_6989586621680118708Sym1 a6989586621680118706 :: TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type
type Apply (Let6989586621680193694MfSym1 f6989586621680193692 :: TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type) (xs6989586621680193693 :: k)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193694MfSym1 f6989586621680193692 :: TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type) (xs6989586621680193693 :: k) = Let6989586621680193694MfSym2 f6989586621680193692 xs6989586621680193693
type Apply (Let6989586621680193673MfSym1 f6989586621680193671 :: TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type) (xs6989586621680193672 :: k)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193673MfSym1 f6989586621680193671 :: TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type) (xs6989586621680193672 :: k) = Let6989586621680193673MfSym2 f6989586621680193671 xs6989586621680193672
type Apply (Let6989586621680193673MfSym2 f6989586621680193671 xs6989586621680193672 :: TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) (a6989586621680193674 :: k2)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193673MfSym2 f6989586621680193671 xs6989586621680193672 :: TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) (a6989586621680193674 :: k2) = Let6989586621680193673MfSym3 f6989586621680193671 xs6989586621680193672 a6989586621680193674
type Eval (FoldMap f ('Just x) :: a2 -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (FoldMap f ('Just x) :: a2 -> Type) = Eval (f x)
type Eval (FoldMap f ('Nothing :: Maybe a1) :: a2 -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (FoldMap f ('Nothing :: Maybe a1) :: a2 -> Type) = MEmpty :: a2
type Eval (Foldr f y ('Just x) :: a2 -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (Foldr f y ('Just x) :: a2 -> Type) = Eval (f x y)
type Eval (Foldr f y ('Nothing :: Maybe a1) :: a2 -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (Foldr f y ('Nothing :: Maybe a1) :: a2 -> Type) = y
type DemoteRep (Maybe a)
Instance details Defined in GHC.Generics type DemoteRep (Maybe a) = Maybe (DemoteRep a)
type Rep (Maybe a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep (Maybe a) = D1 ('MetaData "Maybe" "GHC.Maybe" "base" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
data Sing (b :: Maybe a)
Instance details Defined in GHC.Generics data Sing (b :: Maybe a) where SNothing :: forall {a}. Sing ('Nothing :: Maybe a) SJust :: forall {a} (a1 :: a). Sing a1 -> Sing ('Just a1)
type MEmpty
Instance details Defined in Fcf.Class.Monoid type MEmpty = 'Nothing :: Maybe a
type Index (Maybe a)
Instance details Defined in Control.Lens.At type Index (Maybe a) = ()
type IxValue (Maybe a)
Instance details Defined in Control.Lens.At type IxValue (Maybe a) = a
type MapOpInpHs (Maybe e)
Instance details Defined in Lorentz.Polymorphic type MapOpInpHs (Maybe e) = e
type MapOpResHs (Maybe e)
Instance details Defined in Lorentz.Polymorphic type MapOpResHs (Maybe e) = Maybe
type AsRPC (Maybe a)
Instance details Defined in Morley.AsRPC type AsRPC (Maybe a) = Maybe (AsRPC a)
type TypeDocFieldDescriptions (Maybe a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Maybe a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (Maybe a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Maybe a) = 'TOption (ToT a)
type Demote (Maybe a)
Instance details Defined in Data.Singletons.Base.Instances type Demote (Maybe a) = Maybe (Demote a)
type Sing
Instance details Defined in Data.Singletons.Base.Instances type Sing = SMaybe :: Maybe a -> Type
type Mempty
Instance details Defined in Data.Monoid.Singletons type Mempty = Mempty_6989586621680102643Sym0 :: Maybe a
type Element (Maybe a)
Instance details Defined in Universum.Container.Class type Element (Maybe a) = ElementDefault (Maybe a)
type Rep1 Maybe	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep1 Maybe = D1 ('MetaData "Maybe" "GHC.Maybe" "base" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type Mconcat (arg :: [Maybe a])
Instance details Defined in Data.Monoid.Singletons type Mconcat (arg :: [Maybe a]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [Maybe a] (Maybe a) -> Type) arg
type Sconcat (arg :: NonEmpty (Maybe a))
Instance details Defined in Data.Semigroup.Singletons.Internal type Sconcat (arg :: NonEmpty (Maybe a)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (Maybe a)) (Maybe a) -> Type) arg
type Show_ (arg :: Maybe a)
Instance details Defined in Text.Show.Singletons type Show_ (arg :: Maybe a) = Apply (Show__6989586621680047550Sym0 :: TyFun (Maybe a) Symbol -> Type) arg
type Empty
Instance details Defined in Control.Monad.Singletons.Internal type Empty = Empty_6989586621679357715Sym0 :: Maybe a
type Mzero
Instance details Defined in Control.Monad.Singletons.Internal type Mzero = Mzero_6989586621679287185Sym0 :: Maybe a
type (arg1 :: Maybe a) /= (arg2 :: Maybe a)
Instance details Defined in Data.Eq.Singletons type (arg1 :: Maybe a) /= (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type) arg1) arg2
type (a2 :: Maybe a1) == (a3 :: Maybe a1)
Instance details Defined in Data.Eq.Singletons type (a2 :: Maybe a1) == (a3 :: Maybe a1) = Apply (Apply (TFHelper_6989586621679130516Sym0 :: TyFun (Maybe a1) (Maybe a1 ~> Bool) -> Type) a2) a3
type Mappend (arg1 :: Maybe a) (arg2 :: Maybe a)
Instance details Defined in Data.Monoid.Singletons type Mappend (arg1 :: Maybe a) (arg2 :: Maybe a) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) arg1) arg2
type (arg1 :: Maybe a) < (arg2 :: Maybe a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Maybe a) < (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type) arg1) arg2
type (arg1 :: Maybe a) <= (arg2 :: Maybe a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Maybe a) <= (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type) arg1) arg2
type (arg1 :: Maybe a) > (arg2 :: Maybe a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Maybe a) > (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type) arg1) arg2
type (arg1 :: Maybe a) >= (arg2 :: Maybe a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Maybe a) >= (arg2 :: Maybe a) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type) arg1) arg2
type Compare (a2 :: Maybe a1) (a3 :: Maybe a1)
Instance details Defined in Data.Ord.Singletons type Compare (a2 :: Maybe a1) (a3 :: Maybe a1) = Apply (Apply (Compare_6989586621679180719Sym0 :: TyFun (Maybe a1) (Maybe a1 ~> Ordering) -> Type) a2) a3
type Max (arg1 :: Maybe a) (arg2 :: Maybe a)
Instance details Defined in Data.Ord.Singletons type Max (arg1 :: Maybe a) (arg2 :: Maybe a) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) arg1) arg2
type Min (arg1 :: Maybe a) (arg2 :: Maybe a)
Instance details Defined in Data.Ord.Singletons type Min (arg1 :: Maybe a) (arg2 :: Maybe a) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) arg1) arg2
type (a2 :: Maybe a1) <> (a3 :: Maybe a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Maybe a1) <> (a3 :: Maybe a1) = Apply (Apply (TFHelper_6989586621679584139Sym0 :: TyFun (Maybe a1) (Maybe a1 ~> Maybe a1) -> Type) a2) a3
type ShowList (arg1 :: [Maybe a]) arg2
Instance details Defined in Text.Show.Singletons type ShowList (arg1 :: [Maybe a]) arg2 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Maybe a] (Symbol ~> Symbol) -> Type) arg1) arg2
type HKD Maybe (a :: Type)
Instance details Defined in Data.Vinyl.XRec type HKD Maybe (a :: Type) = Maybe a
type Fail a2
Instance details Defined in Control.Monad.Fail.Singletons type Fail a2 = Apply (Fail_6989586621679456264Sym0 :: TyFun [Char] (Maybe a1) -> Type) a2
type ShowsPrec a2 (a3 :: Maybe a1) a4
Instance details Defined in Text.Show.Singletons type ShowsPrec a2 (a3 :: Maybe a1) a4 = Apply (Apply (Apply (ShowsPrec_6989586621680071724Sym0 :: TyFun Nat (Maybe a1 ~> (Symbol ~> Symbol)) -> Type) a2) a3) a4
type (a2 :: Maybe a1) <\|> (a3 :: Maybe a1)
Instance details Defined in Control.Monad.Singletons.Internal type (a2 :: Maybe a1) <\|> (a3 :: Maybe a1) = Apply (Apply (TFHelper_6989586621679357720Sym0 :: TyFun (Maybe a1) (Maybe a1 ~> Maybe a1) -> Type) a2) a3
type Mplus (arg1 :: Maybe a) (arg2 :: Maybe a)
Instance details Defined in Control.Monad.Singletons.Internal type Mplus (arg1 :: Maybe a) (arg2 :: Maybe a) = Apply (Apply (Mplus_6989586621679287190Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) arg1) arg2
type (a2 :: Maybe a1) <> ('Nothing :: Maybe a1)
Instance details Defined in Fcf.Class.Monoid type (a2 :: Maybe a1) <> ('Nothing :: Maybe a1) = a2
type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679486210 :: Maybe a)
Instance details Defined in Data.Maybe.Singletons type Apply (IsJustSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679486210 :: Maybe a) = IsJust a6989586621679486210
type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679486207 :: Maybe a)
Instance details Defined in Data.Maybe.Singletons type Apply (IsNothingSym0 :: TyFun (Maybe a) Bool -> Type) (a6989586621679486207 :: Maybe a) = IsNothing a6989586621679486207
type Apply (FromJustSym0 :: TyFun (Maybe a) a -> Type) (a6989586621679486203 :: Maybe a)
Instance details Defined in Data.Maybe.Singletons type Apply (FromJustSym0 :: TyFun (Maybe a) a -> Type) (a6989586621679486203 :: Maybe a) = FromJust a6989586621679486203
type Apply (Compare_6989586621679180719Sym1 a6989586621679180724 :: TyFun (Maybe a) Ordering -> Type) (a6989586621679180725 :: Maybe a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679180719Sym1 a6989586621679180724 :: TyFun (Maybe a) Ordering -> Type) (a6989586621679180725 :: Maybe a) = Compare_6989586621679180719 a6989586621679180724 a6989586621679180725
type Apply (TFHelper_6989586621679130516Sym1 a6989586621679130521 :: TyFun (Maybe a) Bool -> Type) (a6989586621679130522 :: Maybe a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130516Sym1 a6989586621679130521 :: TyFun (Maybe a) Bool -> Type) (a6989586621679130522 :: Maybe a) = TFHelper_6989586621679130516 a6989586621679130521 a6989586621679130522
type Apply (FromMaybeSym1 a6989586621679486193 :: TyFun (Maybe a) a -> Type) (a6989586621679486194 :: Maybe a)
Instance details Defined in Data.Maybe.Singletons type Apply (FromMaybeSym1 a6989586621679486193 :: TyFun (Maybe a) a -> Type) (a6989586621679486194 :: Maybe a) = FromMaybe a6989586621679486193 a6989586621679486194
type Apply (FoldMap_6989586621680193813Sym1 a6989586621680193822 :: TyFun (Maybe a) m -> Type) (a6989586621680193823 :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680193813Sym1 a6989586621680193822 :: TyFun (Maybe a) m -> Type) (a6989586621680193823 :: Maybe a) = FoldMap_6989586621680193813 a6989586621680193822 a6989586621680193823
type Apply (Foldl_6989586621680193845Sym2 a6989586621680193851 a6989586621680193852 :: TyFun (Maybe a) b -> Type) (a6989586621680193853 :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680193845Sym2 a6989586621680193851 a6989586621680193852 :: TyFun (Maybe a) b -> Type) (a6989586621680193853 :: Maybe a) = Foldl_6989586621680193845 a6989586621680193851 a6989586621680193852 a6989586621680193853
type Apply (Foldr_6989586621680193829Sym2 a6989586621680193835 a6989586621680193836 :: TyFun (Maybe a) b -> Type) (a6989586621680193837 :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680193829Sym2 a6989586621680193835 a6989586621680193836 :: TyFun (Maybe a) b -> Type) (a6989586621680193837 :: Maybe a) = Foldr_6989586621680193829 a6989586621680193835 a6989586621680193836 a6989586621680193837
type Apply (Maybe_Sym2 a6989586621679484326 a6989586621679484327 :: TyFun (Maybe a) b -> Type) (a6989586621679484328 :: Maybe a)
Instance details Defined in Data.Maybe.Singletons type Apply (Maybe_Sym2 a6989586621679484326 a6989586621679484327 :: TyFun (Maybe a) b -> Type) (a6989586621679484328 :: Maybe a) = Maybe_ a6989586621679484326 a6989586621679484327 a6989586621679484328
type ('Nothing :: Maybe a) <> (b :: Maybe a)
Instance details Defined in Fcf.Class.Monoid type ('Nothing :: Maybe a) <> (b :: Maybe a) = b
type Apply (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type) (a6989586621680107980 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type) (a6989586621680107980 :: First a) = GetFirst a6989586621680107980
type Apply (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type) (a6989586621680108004 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type) (a6989586621680108004 :: Last a) = GetLast a6989586621680108004
type Apply (GetMaxInternalSym0 :: TyFun (MaxInternal a) (Maybe a) -> Type) (a6989586621680182210 :: MaxInternal a)
Instance details Defined in Data.Foldable.Singletons type Apply (GetMaxInternalSym0 :: TyFun (MaxInternal a) (Maybe a) -> Type) (a6989586621680182210 :: MaxInternal a) = GetMaxInternal a6989586621680182210
type Apply (GetMinInternalSym0 :: TyFun (MinInternal a) (Maybe a) -> Type) (a6989586621680182206 :: MinInternal a)
Instance details Defined in Data.Foldable.Singletons type Apply (GetMinInternalSym0 :: TyFun (MinInternal a) (Maybe a) -> Type) (a6989586621680182206 :: MinInternal a) = GetMinInternal a6989586621680182206
type Apply (FirstSym0 :: TyFun (Maybe a) (First a) -> Type) (a6989586621680107977 :: Maybe a)
Instance details Defined in Data.Monoid.Singletons type Apply (FirstSym0 :: TyFun (Maybe a) (First a) -> Type) (a6989586621680107977 :: Maybe a) = 'First a6989586621680107977
type Apply (LastSym0 :: TyFun (Maybe a) (Last a) -> Type) (a6989586621680108001 :: Maybe a)
Instance details Defined in Data.Monoid.Singletons type Apply (LastSym0 :: TyFun (Maybe a) (Last a) -> Type) (a6989586621680108001 :: Maybe a) = 'Last a6989586621680108001
type Apply (MaxInternalSym0 :: TyFun (Maybe a) (MaxInternal a) -> Type) (a6989586621680182200 :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Apply (MaxInternalSym0 :: TyFun (Maybe a) (MaxInternal a) -> Type) (a6989586621680182200 :: Maybe a) = 'MaxInternal a6989586621680182200
type Apply (MinInternalSym0 :: TyFun (Maybe a) (MinInternal a) -> Type) (a6989586621680182203 :: Maybe a)
Instance details Defined in Data.Foldable.Singletons type Apply (MinInternalSym0 :: TyFun (Maybe a) (MinInternal a) -> Type) (a6989586621680182203 :: Maybe a) = 'MinInternal a6989586621680182203
type Apply (MaybeToListSym0 :: TyFun (Maybe a) [a] -> Type) (a6989586621679486188 :: Maybe a)
Instance details Defined in Data.Maybe.Singletons type Apply (MaybeToListSym0 :: TyFun (Maybe a) [a] -> Type) (a6989586621679486188 :: Maybe a) = MaybeToList a6989586621679486188
type Apply (CatMaybesSym0 :: TyFun [Maybe a] [a] -> Type) (a6989586621679486178 :: [Maybe a])
Instance details Defined in Data.Maybe.Singletons type Apply (CatMaybesSym0 :: TyFun [Maybe a] [a] -> Type) (a6989586621679486178 :: [Maybe a]) = CatMaybes a6989586621679486178
type Apply (Fail_6989586621679456264Sym0 :: TyFun [Char] (Maybe a) -> Type) (a6989586621679456268 :: [Char])
Instance details Defined in Control.Monad.Fail.Singletons type Apply (Fail_6989586621679456264Sym0 :: TyFun [Char] (Maybe a) -> Type) (a6989586621679456268 :: [Char]) = Fail_6989586621679456264 a6989586621679456268 :: Maybe a
type Apply (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> Type) (a6989586621679486184 :: [a])
Instance details Defined in Data.Maybe.Singletons type Apply (ListToMaybeSym0 :: TyFun [a] (Maybe a) -> Type) (a6989586621679486184 :: [a]) = ListToMaybe a6989586621679486184
type Apply (TFHelper_6989586621679357720Sym1 a6989586621679357725 :: TyFun (Maybe a) (Maybe a) -> Type) (a6989586621679357726 :: Maybe a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357720Sym1 a6989586621679357725 :: TyFun (Maybe a) (Maybe a) -> Type) (a6989586621679357726 :: Maybe a) = TFHelper_6989586621679357720 a6989586621679357725 a6989586621679357726
type Apply (TFHelper_6989586621679584139Sym1 a6989586621679584144 :: TyFun (Maybe a) (Maybe a) -> Type) (a6989586621679584145 :: Maybe a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679584139Sym1 a6989586621679584144 :: TyFun (Maybe a) (Maybe a) -> Type) (a6989586621679584145 :: Maybe a) = TFHelper_6989586621679584139 a6989586621679584144 a6989586621679584145
type Apply (ElemIndexSym1 a6989586621679731471 :: TyFun [a] (Maybe Nat) -> Type) (a6989586621679731472 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (ElemIndexSym1 a6989586621679731471 :: TyFun [a] (Maybe Nat) -> Type) (a6989586621679731472 :: [a]) = ElemIndex a6989586621679731471 a6989586621679731472
type Apply (FindIndexSym1 a6989586621679731453 :: TyFun [a] (Maybe Nat) -> Type) (a6989586621679731454 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (FindIndexSym1 a6989586621679731453 :: TyFun [a] (Maybe Nat) -> Type) (a6989586621679731454 :: [a]) = FindIndex a6989586621679731453 a6989586621679731454
type Apply (StripPrefixSym1 a6989586621679880880 :: TyFun [a] (Maybe [a]) -> Type) (a6989586621679880881 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (StripPrefixSym1 a6989586621679880880 :: TyFun [a] (Maybe [a]) -> Type) (a6989586621679880881 :: [a]) = StripPrefix a6989586621679880880 a6989586621679880881
type Apply (FindSym1 a6989586621679731480 :: TyFun [a] (Maybe a) -> Type) (a6989586621679731481 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (FindSym1 a6989586621679731480 :: TyFun [a] (Maybe a) -> Type) (a6989586621679731481 :: [a]) = Find a6989586621679731480 a6989586621679731481
type Apply (OptionalSym0 :: TyFun (f a) (f (Maybe a)) -> Type) (a6989586621680883106 :: f a)
Instance details Defined in Control.Applicative.Singletons type Apply (OptionalSym0 :: TyFun (f a) (f (Maybe a)) -> Type) (a6989586621680883106 :: f a) = Optional a6989586621680883106
type Apply (Fmap_6989586621679357336Sym1 a6989586621679357341 :: TyFun (Maybe a) (Maybe b) -> Type) (a6989586621679357342 :: Maybe a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Fmap_6989586621679357336Sym1 a6989586621679357341 :: TyFun (Maybe a) (Maybe b) -> Type) (a6989586621679357342 :: Maybe a) = Fmap_6989586621679357336 a6989586621679357341 a6989586621679357342
type Apply (TFHelper_6989586621679357469Sym1 a6989586621679357474 :: TyFun (Maybe a) (Maybe b) -> Type) (a6989586621679357475 :: Maybe a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357469Sym1 a6989586621679357474 :: TyFun (Maybe a) (Maybe b) -> Type) (a6989586621679357475 :: Maybe a) = TFHelper_6989586621679357469 a6989586621679357474 a6989586621679357475
type Apply (TFHelper_6989586621679357348Sym1 a6989586621679357353 :: TyFun (Maybe b) (Maybe a) -> Type) (a6989586621679357354 :: Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357348Sym1 a6989586621679357353 :: TyFun (Maybe b) (Maybe a) -> Type) (a6989586621679357354 :: Maybe b) = TFHelper_6989586621679357348 a6989586621679357353 a6989586621679357354
type Apply (TFHelper_6989586621679357496Sym1 a6989586621679357501 :: TyFun (Maybe b) (Maybe b) -> Type) (a6989586621679357502 :: Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357496Sym1 a6989586621679357501 :: TyFun (Maybe b) (Maybe b) -> Type) (a6989586621679357502 :: Maybe b) = TFHelper_6989586621679357496 a6989586621679357501 a6989586621679357502
type Apply (TFHelper_6989586621679357644Sym1 a6989586621679357653 :: TyFun (Maybe b) (Maybe b) -> Type) (a6989586621679357654 :: Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357644Sym1 a6989586621679357653 :: TyFun (Maybe b) (Maybe b) -> Type) (a6989586621679357654 :: Maybe b) = TFHelper_6989586621679357644 a6989586621679357653 a6989586621679357654
type Apply (LookupSym1 a6989586621679731178 :: TyFun [(a, b)] (Maybe b) -> Type) (a6989586621679731179 :: [(a, b)])
Instance details Defined in Data.List.Singletons.Internal type Apply (LookupSym1 a6989586621679731178 :: TyFun [(a, b)] (Maybe b) -> Type) (a6989586621679731179 :: [(a, b)]) = Lookup a6989586621679731178 a6989586621679731179
type Apply (FindSym1 a6989586621680193279 :: TyFun (t a) (Maybe a) -> Type) (a6989586621680193280 :: t a)
Instance details Defined in Data.Foldable.Singletons type Apply (FindSym1 a6989586621680193279 :: TyFun (t a) (Maybe a) -> Type) (a6989586621680193280 :: t a) = Find a6989586621680193279 a6989586621680193280
type Apply (Traverse_6989586621680478666Sym1 a6989586621680478671 :: TyFun (Maybe a) (f (Maybe b)) -> Type) (a6989586621680478672 :: Maybe a)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478666Sym1 a6989586621680478671 :: TyFun (Maybe a) (f (Maybe b)) -> Type) (a6989586621680478672 :: Maybe a) = Traverse_6989586621680478666 a6989586621680478671 a6989586621680478672
type Apply (LiftA2_6989586621679357482Sym2 a6989586621679357488 a6989586621679357489 :: TyFun (Maybe b) (Maybe c) -> Type) (a6989586621679357490 :: Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (LiftA2_6989586621679357482Sym2 a6989586621679357488 a6989586621679357489 :: TyFun (Maybe b) (Maybe c) -> Type) (a6989586621679357490 :: Maybe b) = LiftA2_6989586621679357482 a6989586621679357488 a6989586621679357489 a6989586621679357490
type Apply (Let6989586621680193673MfSym3 f6989586621680193671 xs6989586621680193672 a6989586621680193674 :: TyFun (Maybe k3) (Maybe k2) -> Type) (a6989586621680193675 :: Maybe k3)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193673MfSym3 f6989586621680193671 xs6989586621680193672 a6989586621680193674 :: TyFun (Maybe k3) (Maybe k2) -> Type) (a6989586621680193675 :: Maybe k3) = Let6989586621680193673Mf f6989586621680193671 xs6989586621680193672 a6989586621680193674 a6989586621680193675
type Eval (Init ('[] :: [a]) :: Maybe [a] -> Type)
Instance details Defined in Fcf.Data.List type Eval (Init ('[] :: [a]) :: Maybe [a] -> Type) = 'Nothing :: Maybe [a]
type Eval (Tail (_a ': as) :: Maybe [a] -> Type)
Instance details Defined in Fcf.Data.List type Eval (Tail (_a ': as) :: Maybe [a] -> Type) = 'Just as
type Eval (Tail ('[] :: [a]) :: Maybe [a] -> Type)
Instance details Defined in Fcf.Data.List type Eval (Tail ('[] :: [a]) :: Maybe [a] -> Type) = 'Nothing :: Maybe [a]
type Eval (Init (a2 ': (b ': as)) :: Maybe [a1] -> Type)
Instance details Defined in Fcf.Data.List type Eval (Init (a2 ': (b ': as)) :: Maybe [a1] -> Type) = Eval ((Map (Cons a2) :: Maybe [a1] -> Maybe [a1] -> Type) =<< Init (b ': as))
type Eval (Init '[a2] :: Maybe [a1] -> Type)
Instance details Defined in Fcf.Data.List type Eval (Init '[a2] :: Maybe [a1] -> Type) = 'Just ('[] :: [a1])
type Eval (Head ('[] :: [a]) :: Maybe a -> Type)
Instance details Defined in Fcf.Data.List type Eval (Head ('[] :: [a]) :: Maybe a -> Type) = 'Nothing :: Maybe a
type Eval (Last ('[] :: [a]) :: Maybe a -> Type)
Instance details Defined in Fcf.Data.List type Eval (Last ('[] :: [a]) :: Maybe a -> Type) = 'Nothing :: Maybe a
type Eval (Head (a2 ': _as) :: Maybe a1 -> Type)
Instance details Defined in Fcf.Data.List type Eval (Head (a2 ': _as) :: Maybe a1 -> Type) = 'Just a2
type Eval (Last (a2 ': (b ': as)) :: Maybe a1 -> Type)
Instance details Defined in Fcf.Data.List type Eval (Last (a2 ': (b ': as)) :: Maybe a1 -> Type) = Eval (Last (b ': as))
type Eval (Last '[a2] :: Maybe a1 -> Type)
Instance details Defined in Fcf.Data.List type Eval (Last '[a2] :: Maybe a1 -> Type) = 'Just a2
type Apply (Compare_6989586621679180719Sym0 :: TyFun (Maybe a) (Maybe a ~> Ordering) -> Type) (a6989586621679180724 :: Maybe a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679180719Sym0 :: TyFun (Maybe a) (Maybe a ~> Ordering) -> Type) (a6989586621679180724 :: Maybe a) = Compare_6989586621679180719Sym1 a6989586621679180724
type Apply (TFHelper_6989586621679357720Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) (a6989586621679357725 :: Maybe a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357720Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) (a6989586621679357725 :: Maybe a) = TFHelper_6989586621679357720Sym1 a6989586621679357725
type Apply (TFHelper_6989586621679584139Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) (a6989586621679584144 :: Maybe a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679584139Sym0 :: TyFun (Maybe a) (Maybe a ~> Maybe a) -> Type) (a6989586621679584144 :: Maybe a) = TFHelper_6989586621679584139Sym1 a6989586621679584144
type Apply (TFHelper_6989586621679130516Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type) (a6989586621679130521 :: Maybe a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130516Sym0 :: TyFun (Maybe a) (Maybe a ~> Bool) -> Type) (a6989586621679130521 :: Maybe a) = TFHelper_6989586621679130516Sym1 a6989586621679130521
type Apply (StripPrefixSym0 :: TyFun [a] ([a] ~> Maybe [a]) -> Type) (a6989586621679880880 :: [a])
Instance details Defined in Data.List.Singletons.Internal type Apply (StripPrefixSym0 :: TyFun [a] ([a] ~> Maybe [a]) -> Type) (a6989586621679880880 :: [a]) = StripPrefixSym1 a6989586621679880880
type ('Just a2 :: Maybe a1) <> ('Just b :: Maybe a1)
Instance details Defined in Fcf.Class.Monoid type ('Just a2 :: Maybe a1) <> ('Just b :: Maybe a1) = 'Just (a2 <> b)
type Apply (TFHelper_6989586621679357469Sym0 :: TyFun (Maybe (a ~> b)) (Maybe a ~> Maybe b) -> Type) (a6989586621679357474 :: Maybe (a ~> b))
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357469Sym0 :: TyFun (Maybe (a ~> b)) (Maybe a ~> Maybe b) -> Type) (a6989586621679357474 :: Maybe (a ~> b)) = TFHelper_6989586621679357469Sym1 a6989586621679357474
type Apply (TFHelper_6989586621679357633Sym0 :: TyFun (Maybe a) ((a ~> Maybe b) ~> Maybe b) -> Type) (a6989586621679357638 :: Maybe a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357633Sym0 :: TyFun (Maybe a) ((a ~> Maybe b) ~> Maybe b) -> Type) (a6989586621679357638 :: Maybe a) = TFHelper_6989586621679357633Sym1 a6989586621679357638 :: TyFun (a ~> Maybe b) (Maybe b) -> Type
type Apply (TFHelper_6989586621679357496Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe b) -> Type) (a6989586621679357501 :: Maybe a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357496Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe b) -> Type) (a6989586621679357501 :: Maybe a) = TFHelper_6989586621679357496Sym1 a6989586621679357501 :: TyFun (Maybe b) (Maybe b) -> Type
type Apply (TFHelper_6989586621679357644Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe b) -> Type) (a6989586621679357653 :: Maybe a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357644Sym0 :: TyFun (Maybe a) (Maybe b ~> Maybe b) -> Type) (a6989586621679357653 :: Maybe a) = TFHelper_6989586621679357644Sym1 a6989586621679357653 :: TyFun (Maybe b) (Maybe b) -> Type
type Apply (ShowsPrec_6989586621680071724Sym1 a6989586621680071734 :: TyFun (Maybe a) (Symbol ~> Symbol) -> Type) (a6989586621680071735 :: Maybe a)
Instance details Defined in Text.Show.Singletons type Apply (ShowsPrec_6989586621680071724Sym1 a6989586621680071734 :: TyFun (Maybe a) (Symbol ~> Symbol) -> Type) (a6989586621680071735 :: Maybe a) = ShowsPrec_6989586621680071724Sym2 a6989586621680071734 a6989586621680071735
type Apply (LiftA2_6989586621679357482Sym1 a6989586621679357488 :: TyFun (Maybe a) (Maybe b ~> Maybe c) -> Type) (a6989586621679357489 :: Maybe a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (LiftA2_6989586621679357482Sym1 a6989586621679357488 :: TyFun (Maybe a) (Maybe b ~> Maybe c) -> Type) (a6989586621679357489 :: Maybe a) = LiftA2_6989586621679357482Sym2 a6989586621679357488 a6989586621679357489
type Apply (Let6989586621680193694MfSym2 f6989586621680193692 xs6989586621680193693 :: TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) (a6989586621680193695 :: Maybe k2)
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193694MfSym2 f6989586621680193692 xs6989586621680193693 :: TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) (a6989586621680193695 :: Maybe k2) = Let6989586621680193694MfSym3 f6989586621680193692 xs6989586621680193693 a6989586621680193695
type Eval (NumIter a s :: Maybe (k, Nat) -> Type)
Instance details Defined in Fcf.Data.List type Eval (NumIter a s :: Maybe (k, Nat) -> Type) = If (Eval (s > 0)) ('Just '(a, s - 1)) ('Nothing :: Maybe (k, Nat))
type Eval (FindIndex _p ('[] :: [a]) :: Maybe Nat -> Type)
Instance details Defined in Fcf.Data.List type Eval (FindIndex _p ('[] :: [a]) :: Maybe Nat -> Type) = 'Nothing :: Maybe Nat
type Eval (FindIndex p (a2 ': as) :: Maybe Nat -> Type)
Instance details Defined in Fcf.Data.List type Eval (FindIndex p (a2 ': as) :: Maybe Nat -> Type) = Eval (If (Eval (p a2)) (Pure ('Just 0)) ((Map ((+) 1) :: Maybe Nat -> Maybe Nat -> Type) =<< FindIndex p as))
type Eval (Find _p ('[] :: [a]) :: Maybe a -> Type)
Instance details Defined in Fcf.Data.List type Eval (Find _p ('[] :: [a]) :: Maybe a -> Type) = 'Nothing :: Maybe a
type Eval (Find p (a2 ': as) :: Maybe a1 -> Type)
Instance details Defined in Fcf.Data.List type Eval (Find p (a2 ': as) :: Maybe a1 -> Type) = Eval (If (Eval (p a2)) (Pure ('Just a2)) (Find p as))
type Eval (Lookup a as :: Maybe b -> Type)
Instance details Defined in Fcf.Data.List type Eval (Lookup a as :: Maybe b -> Type) = Eval (Map (Snd :: (k, b) -> b -> Type) (Eval (Find ((TyEq a :: k -> Bool -> Type) <=< (Fst :: (k, b) -> k -> Type)) as)))
type Eval ('Just x <\|> _1 :: Maybe a -> Type)
Instance details Defined in Morley.Util.Fcf type Eval ('Just x <\|> _1 :: Maybe a -> Type) = 'Just x
type Eval (('Nothing :: Maybe a) <\|> m :: Maybe a -> Type)
Instance details Defined in Morley.Util.Fcf type Eval (('Nothing :: Maybe a) <\|> m :: Maybe a -> Type) = m
type Eval (Map f ('Just a3) :: Maybe a2 -> Type)
Instance details Defined in Fcf.Class.Functor type Eval (Map f ('Just a3) :: Maybe a2 -> Type) = 'Just (Eval (f a3))
type Eval (Map f ('Nothing :: Maybe a) :: Maybe b -> Type)
Instance details Defined in Fcf.Class.Functor type Eval (Map f ('Nothing :: Maybe a) :: Maybe b -> Type) = 'Nothing :: Maybe b
type Apply (TFHelper_6989586621679357633Sym1 a6989586621679357638 :: TyFun (a ~> Maybe b) (Maybe b) -> Type) (a6989586621679357639 :: a ~> Maybe b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357633Sym1 a6989586621679357638 :: TyFun (a ~> Maybe b) (Maybe b) -> Type) (a6989586621679357639 :: a ~> Maybe b) = TFHelper_6989586621679357633 a6989586621679357638 a6989586621679357639
type Apply (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type) (a6989586621679731453 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (FindIndexSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe Nat) -> Type) (a6989586621679731453 :: a ~> Bool) = FindIndexSym1 a6989586621679731453
type Apply (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type) (a6989586621679731480 :: a ~> Bool)
Instance details Defined in Data.List.Singletons.Internal type Apply (FindSym0 :: TyFun (a ~> Bool) ([a] ~> Maybe a) -> Type) (a6989586621679731480 :: a ~> Bool) = FindSym1 a6989586621679731480
type Apply (Foldr_6989586621680193829Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Maybe a ~> b)) -> Type) (a6989586621680193835 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680193829Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Maybe a ~> b)) -> Type) (a6989586621680193835 :: a ~> (b ~> b)) = Foldr_6989586621680193829Sym1 a6989586621680193835
type Apply (MapMaybeSym0 :: TyFun (a ~> Maybe b) ([a] ~> [b]) -> Type) (a6989586621679486163 :: a ~> Maybe b)
Instance details Defined in Data.Maybe.Singletons type Apply (MapMaybeSym0 :: TyFun (a ~> Maybe b) ([a] ~> [b]) -> Type) (a6989586621679486163 :: a ~> Maybe b) = MapMaybeSym1 a6989586621679486163
type Apply (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type) (a6989586621680193279 :: a ~> Bool)
Instance details Defined in Data.Foldable.Singletons type Apply (FindSym0 :: TyFun (a ~> Bool) (t a ~> Maybe a) -> Type) (a6989586621680193279 :: a ~> Bool) = FindSym1 a6989586621680193279 :: TyFun (t a) (Maybe a) -> Type
type Apply (Fmap_6989586621679357336Sym0 :: TyFun (a ~> b) (Maybe a ~> Maybe b) -> Type) (a6989586621679357341 :: a ~> b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Fmap_6989586621679357336Sym0 :: TyFun (a ~> b) (Maybe a ~> Maybe b) -> Type) (a6989586621679357341 :: a ~> b) = Fmap_6989586621679357336Sym1 a6989586621679357341
type Apply (FoldMap_6989586621680193813Sym0 :: TyFun (a ~> m) (Maybe a ~> m) -> Type) (a6989586621680193822 :: a ~> m)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680193813Sym0 :: TyFun (a ~> m) (Maybe a ~> m) -> Type) (a6989586621680193822 :: a ~> m) = FoldMap_6989586621680193813Sym1 a6989586621680193822
type Apply (Foldl_6989586621680193845Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Maybe a ~> b)) -> Type) (a6989586621680193851 :: b ~> (a ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680193845Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Maybe a ~> b)) -> Type) (a6989586621680193851 :: b ~> (a ~> b)) = Foldl_6989586621680193845Sym1 a6989586621680193851
type Apply (UnfoldrSym0 :: TyFun (b ~> Maybe (a, b)) (b ~> [a]) -> Type) (a6989586621679731870 :: b ~> Maybe (a, b))
Instance details Defined in Data.List.Singletons.Internal type Apply (UnfoldrSym0 :: TyFun (b ~> Maybe (a, b)) (b ~> [a]) -> Type) (a6989586621679731870 :: b ~> Maybe (a, b)) = UnfoldrSym1 a6989586621679731870
type Apply (LiftA2_6989586621679357482Sym0 :: TyFun (a ~> (b ~> c)) (Maybe a ~> (Maybe b ~> Maybe c)) -> Type) (a6989586621679357488 :: a ~> (b ~> c))
Instance details Defined in Control.Monad.Singletons.Internal type Apply (LiftA2_6989586621679357482Sym0 :: TyFun (a ~> (b ~> c)) (Maybe a ~> (Maybe b ~> Maybe c)) -> Type) (a6989586621679357488 :: a ~> (b ~> c)) = LiftA2_6989586621679357482Sym1 a6989586621679357488
type Apply (Let6989586621679486168RsSym0 :: TyFun (a ~> Maybe k1) (TyFun k (TyFun [a] [k1] -> Type) -> Type) -> Type) (f6989586621679486165 :: a ~> Maybe k1)
Instance details Defined in Data.Maybe.Singletons type Apply (Let6989586621679486168RsSym0 :: TyFun (a ~> Maybe k1) (TyFun k (TyFun [a] [k1] -> Type) -> Type) -> Type) (f6989586621679486165 :: a ~> Maybe k1) = Let6989586621679486168RsSym1 f6989586621679486165 :: TyFun k (TyFun [a] [k1] -> Type) -> Type
type Apply (Maybe_Sym1 a6989586621679484326 :: TyFun (a ~> b) (Maybe a ~> b) -> Type) (a6989586621679484327 :: a ~> b)
Instance details Defined in Data.Maybe.Singletons type Apply (Maybe_Sym1 a6989586621679484326 :: TyFun (a ~> b) (Maybe a ~> b) -> Type) (a6989586621679484327 :: a ~> b) = Maybe_Sym2 a6989586621679484326 a6989586621679484327
type Apply (Traverse_6989586621680478666Sym0 :: TyFun (a ~> f b) (Maybe a ~> f (Maybe b)) -> Type) (a6989586621680478671 :: a ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478666Sym0 :: TyFun (a ~> f b) (Maybe a ~> f (Maybe b)) -> Type) (a6989586621680478671 :: a ~> f b) = Traverse_6989586621680478666Sym1 a6989586621680478671
type Apply (Let6989586621680193673MfSym0 :: TyFun (k2 ~> (k3 ~> k2)) (TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type) -> Type) (f6989586621680193671 :: k2 ~> (k3 ~> k2))
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193673MfSym0 :: TyFun (k2 ~> (k3 ~> k2)) (TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type) -> Type) (f6989586621680193671 :: k2 ~> (k3 ~> k2)) = Let6989586621680193673MfSym1 f6989586621680193671 :: TyFun k (TyFun k2 (TyFun (Maybe k3) (Maybe k2) -> Type) -> Type) -> Type
type Apply (Let6989586621680193694MfSym0 :: TyFun (k2 ~> (k3 ~> k3)) (TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type) -> Type) (f6989586621680193692 :: k2 ~> (k3 ~> k3))
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193694MfSym0 :: TyFun (k2 ~> (k3 ~> k3)) (TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type) -> Type) (f6989586621680193692 :: k2 ~> (k3 ~> k3)) = Let6989586621680193694MfSym1 f6989586621680193692 :: TyFun k (TyFun (Maybe k2) (TyFun k3 (Maybe k3) -> Type) -> Type) -> Type
type Apply (Lambda_6989586621680118497Sym1 a6989586621680118495 :: TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) (k6989586621680118496 :: k1 ~> First a)
Instance details Defined in Data.Monoid.Singletons type Apply (Lambda_6989586621680118497Sym1 a6989586621680118495 :: TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) (k6989586621680118496 :: k1 ~> First a) = Lambda_6989586621680118497Sym2 a6989586621680118495 k6989586621680118496
type Apply (Lambda_6989586621680118708Sym1 a6989586621680118706 :: TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) (k6989586621680118707 :: k1 ~> Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (Lambda_6989586621680118708Sym1 a6989586621680118706 :: TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) (k6989586621680118707 :: k1 ~> Last a) = Lambda_6989586621680118708Sym2 a6989586621680118706 k6989586621680118707
type Unwrappabled (NamedF Maybe a name)
Instance details Defined in Lorentz.Wrappable type Unwrappabled (NamedF Maybe a name) = Maybe a
type AsRPC (NamedF Maybe a name)
Instance details Defined in Morley.AsRPC type AsRPC (NamedF Maybe a name) = NamedF Maybe (AsRPC a) name
type ToT (NamedF Maybe a name)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (NamedF Maybe a name) = ToT (Maybe a)

data Ordering #

Constructors

LT
EQ
GT

Instances

Instances details

Structured Ordering
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Ordering -> Structure # structureHash' :: Tagged Ordering MD5
Monoid Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Semigroup Ordering	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Bounded Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering # maxBound :: Ordering #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Generic Ordering
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Read Ordering	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Ordering # readList :: ReadS [Ordering] # readPrec :: ReadPrec Ordering # readListPrec :: ReadPrec [Ordering] #
Show Ordering	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Default Ordering
Instance details Defined in Data.Default.Class Methods def :: Ordering #
NFData Ordering
Instance details Defined in Control.DeepSeq Methods rnf :: Ordering -> () #
Eq Ordering
Instance details Defined in GHC.Classes Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Ord Ordering
Instance details Defined in GHC.Classes Methods compare :: Ordering -> Ordering -> Ordering # (<) :: Ordering -> Ordering -> Bool # (<=) :: Ordering -> Ordering -> Bool # (>) :: Ordering -> Ordering -> Bool # (>=) :: Ordering -> Ordering -> Bool # max :: Ordering -> Ordering -> Ordering # min :: Ordering -> Ordering -> Ordering #
Hashable Ordering
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ordering -> Int # hash :: Ordering -> Int #
PEq Ordering
Instance details Defined in Data.Eq.Singletons Associated Types type arg == arg1 :: Bool # type arg /= arg1 :: Bool #
SEq Ordering
Instance details Defined in Data.Eq.Singletons Methods (%==) :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply (==@#@$) t1) t2) # (%/=) :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply (/=@#@$) t1) t2) #
PMonoid Ordering
Instance details Defined in Data.Monoid.Singletons Associated Types type Mempty :: a # type Mappend arg arg1 :: a # type Mconcat arg :: a #
SMonoid Ordering
Instance details Defined in Data.Monoid.Singletons Methods sMempty :: Sing MemptySym0 # sMappend :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply MappendSym0 t1) t2) # sMconcat :: forall (t :: [Ordering]). Sing t -> Sing (Apply MconcatSym0 t) #
POrd Ordering
Instance details Defined in Data.Ord.Singletons Associated Types type Compare arg arg1 :: Ordering # type arg < arg1 :: Bool # type arg <= arg1 :: Bool # type arg > arg1 :: Bool # type arg >= arg1 :: Bool # type Max arg arg1 :: a # type Min arg arg1 :: a #
SOrd Ordering
Instance details Defined in Data.Ord.Singletons Methods sCompare :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2) # (%<) :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) # (%<=) :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2) # (%>) :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%>=) :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2) # sMax :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2) # sMin :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2) #
PSemigroup Ordering
Instance details Defined in Data.Semigroup.Singletons.Internal Associated Types type arg <> arg1 :: a # type Sconcat arg :: a #
SSemigroup Ordering
Instance details Defined in Data.Semigroup.Singletons.Internal Methods (%<>) :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sSconcat :: forall (t :: NonEmpty Ordering). Sing t -> Sing (Apply SconcatSym0 t) #
PBounded Ordering
Instance details Defined in Data.Singletons.Base.Enum Associated Types type MinBound :: a # type MaxBound :: a #
PEnum Ordering
Instance details Defined in Data.Singletons.Base.Enum Associated Types type Succ arg :: a # type Pred arg :: a # type ToEnum arg :: a # type FromEnum arg :: Nat # type EnumFromTo arg arg1 :: [a] # type EnumFromThenTo arg arg1 arg2 :: [a] #
SBounded Ordering
Instance details Defined in Data.Singletons.Base.Enum Methods sMinBound :: Sing MinBoundSym0 # sMaxBound :: Sing MaxBoundSym0 #
SEnum Ordering
Instance details Defined in Data.Singletons.Base.Enum Methods sSucc :: forall (t :: Ordering). Sing t -> Sing (Apply SuccSym0 t) # sPred :: forall (t :: Ordering). Sing t -> Sing (Apply PredSym0 t) # sToEnum :: forall (t :: Nat). Sing t -> Sing (Apply ToEnumSym0 t) # sFromEnum :: forall (t :: Ordering). Sing t -> Sing (Apply FromEnumSym0 t) # sEnumFromTo :: forall (t1 :: Ordering) (t2 :: Ordering). Sing t1 -> Sing t2 -> Sing (Apply (Apply EnumFromToSym0 t1) t2) # sEnumFromThenTo :: forall (t1 :: Ordering) (t2 :: Ordering) (t3 :: Ordering). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply EnumFromThenToSym0 t1) t2) t3) #
PShow Ordering
Instance details Defined in Text.Show.Singletons Associated Types type ShowsPrec arg arg1 arg2 :: Symbol # type Show_ arg :: Symbol # type ShowList arg arg1 :: Symbol #
SShow Ordering
Instance details Defined in Text.Show.Singletons Methods sShowsPrec :: forall (t1 :: Nat) (t2 :: Ordering) (t3 :: Symbol). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3) # sShow_ :: forall (t :: Ordering). Sing t -> Sing (Apply Show_Sym0 t) # sShowList :: forall (t1 :: [Ordering]) (t2 :: Symbol). Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2) #
TestCoercion SOrdering
Instance details Defined in Data.Singletons.Base.Instances Methods testCoercion :: forall (a :: k) (b :: k). SOrdering a -> SOrdering b -> Maybe (Coercion a b) #
TestEquality SOrdering
Instance details Defined in Data.Singletons.Base.Instances Methods testEquality :: forall (a :: k) (b :: k). SOrdering a -> SOrdering b -> Maybe (a :~: b) #
() :=> (Monoid Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Monoid Ordering #
() :=> (Semigroup Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Semigroup Ordering #
() :=> (Bounded Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Ordering #
() :=> (Enum Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Ordering #
() :=> (Read Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Ordering #
() :=> (Show Ordering)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Ordering #
SingI ThenCmpSym0
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ThenCmpSym0 #
SuppressUnusedWarnings Compare_6989586621679613584Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings Compare_6989586621679613601Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings Compare_6989586621679181460Sym0
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings Compare_6989586621679181849Sym0
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ThenCmpSym0
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings TFHelper_6989586621679584129Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings TFHelper_6989586621679131028Sym0
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings FromEnum_6989586621679544325Sym0
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings Compare_6989586621679181858Sym0
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings Compare_6989586621679181840Sym0
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ToEnum_6989586621679544309Sym0
Instance details Defined in Data.Singletons.Base.Enum Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ShowsPrec_6989586621680071856Sym0
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SingI d => SingI (ThenCmpSym1 d :: TyFun Ordering Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (ThenCmpSym1 d) #
SingI (SortBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing SortBySym0 #
SingI (ListsortBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods sing :: Sing ListsortBySym0 #
SingI (MaximumBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing MaximumBySym0 #
SingI (MinimumBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing MinimumBySym0 #
SingI (InsertBySym0 :: TyFun (a ~> (a ~> Ordering)) (a ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods sing :: Sing InsertBySym0 #
SOrd a => SingI (CompareSym0 :: TyFun a (a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing CompareSym0 #
SuppressUnusedWarnings (Compare_6989586621679181827Sym0 :: TyFun (Identity a) (Identity a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680111321Sym0 :: TyFun (First a) (First a ~> Ordering) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680111341Sym0 :: TyFun (Last a) (Last a ~> Ordering) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679179242Sym0 :: TyFun (Down a) (Down a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613701Sym0 :: TyFun (First a) (First a ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613721Sym0 :: TyFun (Last a) (Last a ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613681Sym0 :: TyFun (Max a) (Max a ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613661Sym0 :: TyFun (Min a) (Min a ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613741Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613584Sym1 a6989586621679613589 :: TyFun All Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613601Sym1 a6989586621679613606 :: TyFun Any Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613565Sym0 :: TyFun (Dual a) (Dual a ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613641Sym0 :: TyFun (Product a) (Product a ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613621Sym0 :: TyFun (Sum a) (Sum a ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181460Sym1 a6989586621679181465 :: TyFun Void Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181443Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181849Sym1 a6989586621679181854 :: TyFun Ordering Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ThenCmpSym1 a6989586621679166082 :: TyFun Ordering Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679584129Sym1 a6989586621679584134 :: TyFun Ordering Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680071856Sym1 a6989586621680071868 :: TyFun Ordering (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679131028Sym1 a6989586621679131033 :: TyFun Ordering Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (SortBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ListsortBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> [a]) -> Type)
Instance details Defined in Data.List.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MaximumBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MinimumBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> a) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (InsertBySym0 :: TyFun (a ~> (a ~> Ordering)) (a ~> ([a] ~> [a])) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679180719Sym0 :: TyFun (Maybe a) (Maybe a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181858Sym1 a6989586621679181863 :: TyFun () Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181840Sym1 a6989586621679181845 :: TyFun Bool Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181370Sym0 :: TyFun [a] ([a] ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (CompareSym0 :: TyFun a (a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679166132Sym0 :: TyFun a (a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166162Scrutinee_6989586621679163725Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166178Scrutinee_6989586621679163727Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166194Scrutinee_6989586621679163729Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166210Scrutinee_6989586621679163731Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SFoldable t => SingI (MaximumBySym0 :: TyFun (a ~> (a ~> Ordering)) (t a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MaximumBySym0 #
SFoldable t => SingI (MinimumBySym0 :: TyFun (a ~> (a ~> Ordering)) (t a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sing :: Sing MinimumBySym0 #
SOrd a => SingI (ComparingSym0 :: TyFun (b ~> a) (b ~> (b ~> Ordering)) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing ComparingSym0 #
(SOrd a, SingI d) => SingI (CompareSym1 d :: TyFun a Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (CompareSym1 d) #
SuppressUnusedWarnings (Compare_6989586621679181415Sym0 :: TyFun (Either a b) (Either a b ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181827Sym1 a6989586621679181832 :: TyFun (Identity a) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680111321Sym1 a6989586621680111326 :: TyFun (First a) Ordering -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680111341Sym1 a6989586621680111346 :: TyFun (Last a) Ordering -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679179242Sym1 a6989586621679179247 :: TyFun (Down a) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680163447Sym0 :: TyFun (Proxy s) (Proxy s ~> Ordering) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680605396Sym0 :: TyFun (Arg a b) (Arg a b ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613701Sym1 a6989586621679613706 :: TyFun (First a) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613721Sym1 a6989586621679613726 :: TyFun (Last a) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613681Sym1 a6989586621679613686 :: TyFun (Max a) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613661Sym1 a6989586621679613666 :: TyFun (Min a) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613741Sym1 a6989586621679613746 :: TyFun (WrappedMonoid m) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613565Sym1 a6989586621679613570 :: TyFun (Dual a) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613641Sym1 a6989586621679613646 :: TyFun (Product a) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613621Sym1 a6989586621679613626 :: TyFun (Sum a) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181443Sym1 a6989586621679181448 :: TyFun (NonEmpty a) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MaximumBySym0 :: TyFun (a ~> (a ~> Ordering)) (t a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MinimumBySym0 :: TyFun (a ~> (a ~> Ordering)) (t a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ComparingSym0 :: TyFun (b ~> a) (b ~> (b ~> Ordering)) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193310Min'Sym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680193330Max'Sym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679180719Sym1 a6989586621679180724 :: TyFun (Maybe a) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181483Sym0 :: TyFun (a, b) ((a, b) ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181370Sym1 a6989586621679181375 :: TyFun [a] Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (CompareSym1 a6989586621679166098 :: TyFun a Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679166132Sym1 a6989586621679166137 :: TyFun a Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166162Scrutinee_6989586621679163725Sym1 x6989586621679166160 :: TyFun k1 Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166178Scrutinee_6989586621679163727Sym1 x6989586621679166176 :: TyFun k1 Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166194Scrutinee_6989586621679163729Sym1 x6989586621679166192 :: TyFun k1 Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679166210Scrutinee_6989586621679163731Sym1 x6989586621679166208 :: TyFun k1 Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
(SOrd a, SingI d) => SingI (ComparingSym1 d :: TyFun b (b ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (ComparingSym1 d) #
SuppressUnusedWarnings (Compare_6989586621679181415Sym1 a6989586621679181420 :: TyFun (Either a b) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680428560Sym0 :: TyFun (Const a b) (Const a b ~> Ordering) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680163447Sym1 a6989586621680163452 :: TyFun (Proxy s) Ordering -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680605396Sym1 a6989586621680605401 :: TyFun (Arg a b) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731508MinBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679731529MaxBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Data.List.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181483Sym1 a6989586621679181488 :: TyFun (a, b) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181521Sym0 :: TyFun (a, b, c) ((a, b, c) ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ComparingSym1 a6989586621679166089 :: TyFun b (b ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
(SOrd a, SingI d1, SingI d2) => SingI (ComparingSym2 d1 d2 :: TyFun b Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing (ComparingSym2 d1 d2) #
SuppressUnusedWarnings (Compare_6989586621680428560Sym1 a6989586621680428565 :: TyFun (Const a b) Ordering -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181521Sym1 a6989586621679181526 :: TyFun (a, b, c) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181570Sym0 :: TyFun (a, b, c, d) ((a, b, c, d) ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ComparingSym2 a6989586621679166089 a6989586621679166090 :: TyFun b Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181570Sym1 a6989586621679181575 :: TyFun (a, b, c, d) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181630Sym0 :: TyFun (a, b, c, d, e) ((a, b, c, d, e) ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181630Sym1 a6989586621679181635 :: TyFun (a, b, c, d, e) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181701Sym0 :: TyFun (a, b, c, d, e, f) ((a, b, c, d, e, f) ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181701Sym1 a6989586621679181706 :: TyFun (a, b, c, d, e, f) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181783Sym0 :: TyFun (a, b, c, d, e, f, g) ((a, b, c, d, e, f, g) ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181783Sym1 a6989586621679181788 :: TyFun (a, b, c, d, e, f, g) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
type Rep Ordering	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep Ordering = D1 ('MetaData "Ordering" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "LT" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "EQ" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GT" 'PrefixI 'False) (U1 :: Type -> Type)))
type MEmpty
Instance details Defined in Fcf.Class.Monoid type MEmpty = 'EQ
type Demote Ordering
Instance details Defined in Data.Singletons.Base.Instances type Demote Ordering = Ordering
type Sing
Instance details Defined in Data.Singletons.Base.Instances type Sing = SOrdering
type Mempty
Instance details Defined in Data.Monoid.Singletons type Mempty = Mempty_6989586621680102640Sym0
type MaxBound
Instance details Defined in Data.Singletons.Base.Enum type MaxBound = MaxBound_6989586621679509893Sym0
type MinBound
Instance details Defined in Data.Singletons.Base.Enum type MinBound = MinBound_6989586621679509890Sym0
type Mconcat (arg :: [Ordering])
Instance details Defined in Data.Monoid.Singletons type Mconcat (arg :: [Ordering]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [Ordering] Ordering -> Type) arg
type Sconcat (arg :: NonEmpty Ordering)
Instance details Defined in Data.Semigroup.Singletons.Internal type Sconcat (arg :: NonEmpty Ordering) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty Ordering) Ordering -> Type) arg
type FromEnum (a :: Ordering)
Instance details Defined in Data.Singletons.Base.Enum type FromEnum (a :: Ordering) = Apply FromEnum_6989586621679544325Sym0 a
type Pred (arg :: Ordering)
Instance details Defined in Data.Singletons.Base.Enum type Pred (arg :: Ordering) = Apply (Pred_6989586621679516494Sym0 :: TyFun Ordering Ordering -> Type) arg
type Succ (arg :: Ordering)
Instance details Defined in Data.Singletons.Base.Enum type Succ (arg :: Ordering) = Apply (Succ_6989586621679516481Sym0 :: TyFun Ordering Ordering -> Type) arg
type ToEnum a
Instance details Defined in Data.Singletons.Base.Enum type ToEnum a = Apply ToEnum_6989586621679544309Sym0 a
type Show_ (arg :: Ordering)
Instance details Defined in Text.Show.Singletons type Show_ (arg :: Ordering) = Apply (Show__6989586621680047550Sym0 :: TyFun Ordering Symbol -> Type) arg
type 'EQ <> (b :: Ordering)
Instance details Defined in Fcf.Class.Monoid type 'EQ <> (b :: Ordering) = b
type 'GT <> (_b :: Ordering)
Instance details Defined in Fcf.Class.Monoid type 'GT <> (_b :: Ordering) = 'GT
type 'LT <> (_b :: Ordering)
Instance details Defined in Fcf.Class.Monoid type 'LT <> (_b :: Ordering) = 'LT
type (a :: Ordering) <> 'EQ
Instance details Defined in Fcf.Class.Monoid type (a :: Ordering) <> 'EQ = a
type (arg1 :: Ordering) /= (arg2 :: Ordering)
Instance details Defined in Data.Eq.Singletons type (arg1 :: Ordering) /= (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun Ordering (Ordering ~> Bool) -> Type) arg1) arg2
type (a1 :: Ordering) == (a2 :: Ordering)
Instance details Defined in Data.Eq.Singletons type (a1 :: Ordering) == (a2 :: Ordering) = Apply (Apply TFHelper_6989586621679131028Sym0 a1) a2
type Mappend (arg1 :: Ordering) (arg2 :: Ordering)
Instance details Defined in Data.Monoid.Singletons type Mappend (arg1 :: Ordering) (arg2 :: Ordering) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun Ordering (Ordering ~> Ordering) -> Type) arg1) arg2
type (arg1 :: Ordering) < (arg2 :: Ordering)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Ordering) < (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun Ordering (Ordering ~> Bool) -> Type) arg1) arg2
type (arg1 :: Ordering) <= (arg2 :: Ordering)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Ordering) <= (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun Ordering (Ordering ~> Bool) -> Type) arg1) arg2
type (arg1 :: Ordering) > (arg2 :: Ordering)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Ordering) > (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun Ordering (Ordering ~> Bool) -> Type) arg1) arg2
type (arg1 :: Ordering) >= (arg2 :: Ordering)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Ordering) >= (arg2 :: Ordering) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun Ordering (Ordering ~> Bool) -> Type) arg1) arg2
type Compare (a1 :: Ordering) (a2 :: Ordering)
Instance details Defined in Data.Ord.Singletons type Compare (a1 :: Ordering) (a2 :: Ordering) = Apply (Apply Compare_6989586621679181849Sym0 a1) a2
type Max (arg1 :: Ordering) (arg2 :: Ordering)
Instance details Defined in Data.Ord.Singletons type Max (arg1 :: Ordering) (arg2 :: Ordering) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun Ordering (Ordering ~> Ordering) -> Type) arg1) arg2
type Min (arg1 :: Ordering) (arg2 :: Ordering)
Instance details Defined in Data.Ord.Singletons type Min (arg1 :: Ordering) (arg2 :: Ordering) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun Ordering (Ordering ~> Ordering) -> Type) arg1) arg2
type (a1 :: Ordering) <> (a2 :: Ordering)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a1 :: Ordering) <> (a2 :: Ordering) = Apply (Apply TFHelper_6989586621679584129Sym0 a1) a2
type EnumFromTo (arg1 :: Ordering) (arg2 :: Ordering)
Instance details Defined in Data.Singletons.Base.Enum type EnumFromTo (arg1 :: Ordering) (arg2 :: Ordering) = Apply (Apply (EnumFromTo_6989586621679516504Sym0 :: TyFun Ordering (Ordering ~> [Ordering]) -> Type) arg1) arg2
type ShowList (arg1 :: [Ordering]) arg2
Instance details Defined in Text.Show.Singletons type ShowList (arg1 :: [Ordering]) arg2 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Ordering] (Symbol ~> Symbol) -> Type) arg1) arg2
type Apply FromEnum_6989586621679544325Sym0 (a6989586621679544329 :: Ordering)
Instance details Defined in Data.Singletons.Base.Enum type Apply FromEnum_6989586621679544325Sym0 (a6989586621679544329 :: Ordering) = FromEnum_6989586621679544325 a6989586621679544329
type Apply ToEnum_6989586621679544309Sym0 (a6989586621679544313 :: Nat)
Instance details Defined in Data.Singletons.Base.Enum type Apply ToEnum_6989586621679544309Sym0 (a6989586621679544313 :: Nat) = ToEnum_6989586621679544309 a6989586621679544313
type EnumFromThenTo (arg1 :: Ordering) (arg2 :: Ordering) (arg3 :: Ordering)
Instance details Defined in Data.Singletons.Base.Enum type EnumFromThenTo (arg1 :: Ordering) (arg2 :: Ordering) (arg3 :: Ordering) = Apply (Apply (Apply (EnumFromThenTo_6989586621679516516Sym0 :: TyFun Ordering (Ordering ~> (Ordering ~> [Ordering])) -> Type) arg1) arg2) arg3
type ShowsPrec a1 (a2 :: Ordering) a3
Instance details Defined in Text.Show.Singletons type ShowsPrec a1 (a2 :: Ordering) a3 = Apply (Apply (Apply ShowsPrec_6989586621680071856Sym0 a1) a2) a3
type Apply (Compare_6989586621679613584Sym1 a6989586621679613589 :: TyFun All Ordering -> Type) (a6989586621679613590 :: All)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613584Sym1 a6989586621679613589 :: TyFun All Ordering -> Type) (a6989586621679613590 :: All) = Compare_6989586621679613584 a6989586621679613589 a6989586621679613590
type Apply (Compare_6989586621679613601Sym1 a6989586621679613606 :: TyFun Any Ordering -> Type) (a6989586621679613607 :: Any)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613601Sym1 a6989586621679613606 :: TyFun Any Ordering -> Type) (a6989586621679613607 :: Any) = Compare_6989586621679613601 a6989586621679613606 a6989586621679613607
type Apply (Compare_6989586621679181460Sym1 a6989586621679181465 :: TyFun Void Ordering -> Type) (a6989586621679181466 :: Void)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181460Sym1 a6989586621679181465 :: TyFun Void Ordering -> Type) (a6989586621679181466 :: Void) = Compare_6989586621679181460 a6989586621679181465 a6989586621679181466
type Apply (Compare_6989586621679181849Sym1 a6989586621679181854 :: TyFun Ordering Ordering -> Type) (a6989586621679181855 :: Ordering)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181849Sym1 a6989586621679181854 :: TyFun Ordering Ordering -> Type) (a6989586621679181855 :: Ordering) = Compare_6989586621679181849 a6989586621679181854 a6989586621679181855
type Apply (ThenCmpSym1 a6989586621679166082 :: TyFun Ordering Ordering -> Type) (a6989586621679166083 :: Ordering)
Instance details Defined in Data.Ord.Singletons type Apply (ThenCmpSym1 a6989586621679166082 :: TyFun Ordering Ordering -> Type) (a6989586621679166083 :: Ordering) = ThenCmp a6989586621679166082 a6989586621679166083
type Apply (TFHelper_6989586621679584129Sym1 a6989586621679584134 :: TyFun Ordering Ordering -> Type) (a6989586621679584135 :: Ordering)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679584129Sym1 a6989586621679584134 :: TyFun Ordering Ordering -> Type) (a6989586621679584135 :: Ordering) = TFHelper_6989586621679584129 a6989586621679584134 a6989586621679584135
type Apply (TFHelper_6989586621679131028Sym1 a6989586621679131033 :: TyFun Ordering Bool -> Type) (a6989586621679131034 :: Ordering)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679131028Sym1 a6989586621679131033 :: TyFun Ordering Bool -> Type) (a6989586621679131034 :: Ordering) = TFHelper_6989586621679131028 a6989586621679131033 a6989586621679131034
type Apply (Compare_6989586621679181858Sym1 a6989586621679181863 :: TyFun () Ordering -> Type) (a6989586621679181864 :: ())
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181858Sym1 a6989586621679181863 :: TyFun () Ordering -> Type) (a6989586621679181864 :: ()) = Compare_6989586621679181858 a6989586621679181863 a6989586621679181864
type Apply (Compare_6989586621679181840Sym1 a6989586621679181845 :: TyFun Bool Ordering -> Type) (a6989586621679181846 :: Bool)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181840Sym1 a6989586621679181845 :: TyFun Bool Ordering -> Type) (a6989586621679181846 :: Bool) = Compare_6989586621679181840 a6989586621679181845 a6989586621679181846
type Apply (CompareSym1 a6989586621679166098 :: TyFun a Ordering -> Type) (a6989586621679166099 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (CompareSym1 a6989586621679166098 :: TyFun a Ordering -> Type) (a6989586621679166099 :: a) = Compare a6989586621679166098 a6989586621679166099
type Apply (Compare_6989586621679166132Sym1 a6989586621679166137 :: TyFun a Ordering -> Type) (a6989586621679166138 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679166132Sym1 a6989586621679166137 :: TyFun a Ordering -> Type) (a6989586621679166138 :: a) = Compare_6989586621679166132 a6989586621679166137 a6989586621679166138
type Apply (Let6989586621679166162Scrutinee_6989586621679163725Sym1 x6989586621679166160 :: TyFun k1 Ordering -> Type) (y6989586621679166161 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166162Scrutinee_6989586621679163725Sym1 x6989586621679166160 :: TyFun k1 Ordering -> Type) (y6989586621679166161 :: k1) = Let6989586621679166162Scrutinee_6989586621679163725 x6989586621679166160 y6989586621679166161
type Apply (Let6989586621679166178Scrutinee_6989586621679163727Sym1 x6989586621679166176 :: TyFun k1 Ordering -> Type) (y6989586621679166177 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166178Scrutinee_6989586621679163727Sym1 x6989586621679166176 :: TyFun k1 Ordering -> Type) (y6989586621679166177 :: k1) = Let6989586621679166178Scrutinee_6989586621679163727 x6989586621679166176 y6989586621679166177
type Apply (Let6989586621679166194Scrutinee_6989586621679163729Sym1 x6989586621679166192 :: TyFun k1 Ordering -> Type) (y6989586621679166193 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166194Scrutinee_6989586621679163729Sym1 x6989586621679166192 :: TyFun k1 Ordering -> Type) (y6989586621679166193 :: k1) = Let6989586621679166194Scrutinee_6989586621679163729 x6989586621679166192 y6989586621679166193
type Apply (Let6989586621679166210Scrutinee_6989586621679163731Sym1 x6989586621679166208 :: TyFun k1 Ordering -> Type) (y6989586621679166209 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166210Scrutinee_6989586621679163731Sym1 x6989586621679166208 :: TyFun k1 Ordering -> Type) (y6989586621679166209 :: k1) = Let6989586621679166210Scrutinee_6989586621679163731 x6989586621679166208 y6989586621679166209
type Apply (ComparingSym2 a6989586621679166089 a6989586621679166090 :: TyFun b Ordering -> Type) (a6989586621679166091 :: b)
Instance details Defined in Data.Ord.Singletons type Apply (ComparingSym2 a6989586621679166089 a6989586621679166090 :: TyFun b Ordering -> Type) (a6989586621679166091 :: b) = Comparing a6989586621679166089 a6989586621679166090 a6989586621679166091
type Apply Compare_6989586621679613584Sym0 (a6989586621679613589 :: All)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply Compare_6989586621679613584Sym0 (a6989586621679613589 :: All) = Compare_6989586621679613584Sym1 a6989586621679613589
type Apply Compare_6989586621679613601Sym0 (a6989586621679613606 :: Any)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply Compare_6989586621679613601Sym0 (a6989586621679613606 :: Any) = Compare_6989586621679613601Sym1 a6989586621679613606
type Apply Compare_6989586621679181460Sym0 (a6989586621679181465 :: Void)
Instance details Defined in Data.Ord.Singletons type Apply Compare_6989586621679181460Sym0 (a6989586621679181465 :: Void) = Compare_6989586621679181460Sym1 a6989586621679181465
type Apply Compare_6989586621679181849Sym0 (a6989586621679181854 :: Ordering)
Instance details Defined in Data.Ord.Singletons type Apply Compare_6989586621679181849Sym0 (a6989586621679181854 :: Ordering) = Compare_6989586621679181849Sym1 a6989586621679181854
type Apply ThenCmpSym0 (a6989586621679166082 :: Ordering)
Instance details Defined in Data.Ord.Singletons type Apply ThenCmpSym0 (a6989586621679166082 :: Ordering) = ThenCmpSym1 a6989586621679166082
type Apply TFHelper_6989586621679584129Sym0 (a6989586621679584134 :: Ordering)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply TFHelper_6989586621679584129Sym0 (a6989586621679584134 :: Ordering) = TFHelper_6989586621679584129Sym1 a6989586621679584134
type Apply TFHelper_6989586621679131028Sym0 (a6989586621679131033 :: Ordering)
Instance details Defined in Data.Eq.Singletons type Apply TFHelper_6989586621679131028Sym0 (a6989586621679131033 :: Ordering) = TFHelper_6989586621679131028Sym1 a6989586621679131033
type Apply Compare_6989586621679181858Sym0 (a6989586621679181863 :: ())
Instance details Defined in Data.Ord.Singletons type Apply Compare_6989586621679181858Sym0 (a6989586621679181863 :: ()) = Compare_6989586621679181858Sym1 a6989586621679181863
type Apply Compare_6989586621679181840Sym0 (a6989586621679181845 :: Bool)
Instance details Defined in Data.Ord.Singletons type Apply Compare_6989586621679181840Sym0 (a6989586621679181845 :: Bool) = Compare_6989586621679181840Sym1 a6989586621679181845
type Apply ShowsPrec_6989586621680071856Sym0 (a6989586621680071868 :: Nat)
Instance details Defined in Text.Show.Singletons type Apply ShowsPrec_6989586621680071856Sym0 (a6989586621680071868 :: Nat) = ShowsPrec_6989586621680071856Sym1 a6989586621680071868
type Apply (ShowsPrec_6989586621680071856Sym1 a6989586621680071868 :: TyFun Ordering (Symbol ~> Symbol) -> Type) (a6989586621680071869 :: Ordering)
Instance details Defined in Text.Show.Singletons type Apply (ShowsPrec_6989586621680071856Sym1 a6989586621680071868 :: TyFun Ordering (Symbol ~> Symbol) -> Type) (a6989586621680071869 :: Ordering) = ShowsPrec_6989586621680071856Sym2 a6989586621680071868 a6989586621680071869
type Apply (CompareSym0 :: TyFun a (a ~> Ordering) -> Type) (a6989586621679166098 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (CompareSym0 :: TyFun a (a ~> Ordering) -> Type) (a6989586621679166098 :: a) = CompareSym1 a6989586621679166098
type Apply (Compare_6989586621679166132Sym0 :: TyFun a (a ~> Ordering) -> Type) (a6989586621679166137 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679166132Sym0 :: TyFun a (a ~> Ordering) -> Type) (a6989586621679166137 :: a) = Compare_6989586621679166132Sym1 a6989586621679166137
type Apply (Let6989586621679166162Scrutinee_6989586621679163725Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type) (x6989586621679166160 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166162Scrutinee_6989586621679163725Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type) (x6989586621679166160 :: k1) = Let6989586621679166162Scrutinee_6989586621679163725Sym1 x6989586621679166160
type Apply (Let6989586621679166178Scrutinee_6989586621679163727Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type) (x6989586621679166176 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166178Scrutinee_6989586621679163727Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type) (x6989586621679166176 :: k1) = Let6989586621679166178Scrutinee_6989586621679163727Sym1 x6989586621679166176
type Apply (Let6989586621679166194Scrutinee_6989586621679163729Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type) (x6989586621679166192 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166194Scrutinee_6989586621679163729Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type) (x6989586621679166192 :: k1) = Let6989586621679166194Scrutinee_6989586621679163729Sym1 x6989586621679166192
type Apply (Let6989586621679166210Scrutinee_6989586621679163731Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type) (x6989586621679166208 :: k1)
Instance details Defined in Data.Ord.Singletons type Apply (Let6989586621679166210Scrutinee_6989586621679163731Sym0 :: TyFun k1 (TyFun k1 Ordering -> Type) -> Type) (x6989586621679166208 :: k1) = Let6989586621679166210Scrutinee_6989586621679163731Sym1 x6989586621679166208
type Apply (ComparingSym1 a6989586621679166089 :: TyFun b (b ~> Ordering) -> Type) (a6989586621679166090 :: b)
Instance details Defined in Data.Ord.Singletons type Apply (ComparingSym1 a6989586621679166089 :: TyFun b (b ~> Ordering) -> Type) (a6989586621679166090 :: b) = ComparingSym2 a6989586621679166089 a6989586621679166090
type Apply (Compare_6989586621679181827Sym1 a6989586621679181832 :: TyFun (Identity a) Ordering -> Type) (a6989586621679181833 :: Identity a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181827Sym1 a6989586621679181832 :: TyFun (Identity a) Ordering -> Type) (a6989586621679181833 :: Identity a) = Compare_6989586621679181827 a6989586621679181832 a6989586621679181833
type Apply (Compare_6989586621680111321Sym1 a6989586621680111326 :: TyFun (First a) Ordering -> Type) (a6989586621680111327 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (Compare_6989586621680111321Sym1 a6989586621680111326 :: TyFun (First a) Ordering -> Type) (a6989586621680111327 :: First a) = Compare_6989586621680111321 a6989586621680111326 a6989586621680111327
type Apply (Compare_6989586621680111341Sym1 a6989586621680111346 :: TyFun (Last a) Ordering -> Type) (a6989586621680111347 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (Compare_6989586621680111341Sym1 a6989586621680111346 :: TyFun (Last a) Ordering -> Type) (a6989586621680111347 :: Last a) = Compare_6989586621680111341 a6989586621680111346 a6989586621680111347
type Apply (Compare_6989586621679179242Sym1 a6989586621679179247 :: TyFun (Down a) Ordering -> Type) (a6989586621679179248 :: Down a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679179242Sym1 a6989586621679179247 :: TyFun (Down a) Ordering -> Type) (a6989586621679179248 :: Down a) = Compare_6989586621679179242 a6989586621679179247 a6989586621679179248
type Apply (Compare_6989586621679613701Sym1 a6989586621679613706 :: TyFun (First a) Ordering -> Type) (a6989586621679613707 :: First a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613701Sym1 a6989586621679613706 :: TyFun (First a) Ordering -> Type) (a6989586621679613707 :: First a) = Compare_6989586621679613701 a6989586621679613706 a6989586621679613707
type Apply (Compare_6989586621679613721Sym1 a6989586621679613726 :: TyFun (Last a) Ordering -> Type) (a6989586621679613727 :: Last a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613721Sym1 a6989586621679613726 :: TyFun (Last a) Ordering -> Type) (a6989586621679613727 :: Last a) = Compare_6989586621679613721 a6989586621679613726 a6989586621679613727
type Apply (Compare_6989586621679613681Sym1 a6989586621679613686 :: TyFun (Max a) Ordering -> Type) (a6989586621679613687 :: Max a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613681Sym1 a6989586621679613686 :: TyFun (Max a) Ordering -> Type) (a6989586621679613687 :: Max a) = Compare_6989586621679613681 a6989586621679613686 a6989586621679613687
type Apply (Compare_6989586621679613661Sym1 a6989586621679613666 :: TyFun (Min a) Ordering -> Type) (a6989586621679613667 :: Min a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613661Sym1 a6989586621679613666 :: TyFun (Min a) Ordering -> Type) (a6989586621679613667 :: Min a) = Compare_6989586621679613661 a6989586621679613666 a6989586621679613667
type Apply (Compare_6989586621679613741Sym1 a6989586621679613746 :: TyFun (WrappedMonoid m) Ordering -> Type) (a6989586621679613747 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613741Sym1 a6989586621679613746 :: TyFun (WrappedMonoid m) Ordering -> Type) (a6989586621679613747 :: WrappedMonoid m) = Compare_6989586621679613741 a6989586621679613746 a6989586621679613747
type Apply (Compare_6989586621679613565Sym1 a6989586621679613570 :: TyFun (Dual a) Ordering -> Type) (a6989586621679613571 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613565Sym1 a6989586621679613570 :: TyFun (Dual a) Ordering -> Type) (a6989586621679613571 :: Dual a) = Compare_6989586621679613565 a6989586621679613570 a6989586621679613571
type Apply (Compare_6989586621679613641Sym1 a6989586621679613646 :: TyFun (Product a) Ordering -> Type) (a6989586621679613647 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613641Sym1 a6989586621679613646 :: TyFun (Product a) Ordering -> Type) (a6989586621679613647 :: Product a) = Compare_6989586621679613641 a6989586621679613646 a6989586621679613647
type Apply (Compare_6989586621679613621Sym1 a6989586621679613626 :: TyFun (Sum a) Ordering -> Type) (a6989586621679613627 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613621Sym1 a6989586621679613626 :: TyFun (Sum a) Ordering -> Type) (a6989586621679613627 :: Sum a) = Compare_6989586621679613621 a6989586621679613626 a6989586621679613627
type Apply (Compare_6989586621679181443Sym1 a6989586621679181448 :: TyFun (NonEmpty a) Ordering -> Type) (a6989586621679181449 :: NonEmpty a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181443Sym1 a6989586621679181448 :: TyFun (NonEmpty a) Ordering -> Type) (a6989586621679181449 :: NonEmpty a) = Compare_6989586621679181443 a6989586621679181448 a6989586621679181449
type Apply (Compare_6989586621679180719Sym1 a6989586621679180724 :: TyFun (Maybe a) Ordering -> Type) (a6989586621679180725 :: Maybe a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679180719Sym1 a6989586621679180724 :: TyFun (Maybe a) Ordering -> Type) (a6989586621679180725 :: Maybe a) = Compare_6989586621679180719 a6989586621679180724 a6989586621679180725
type Apply (Compare_6989586621679181370Sym1 a6989586621679181375 :: TyFun [a] Ordering -> Type) (a6989586621679181376 :: [a])
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181370Sym1 a6989586621679181375 :: TyFun [a] Ordering -> Type) (a6989586621679181376 :: [a]) = Compare_6989586621679181370 a6989586621679181375 a6989586621679181376
type Apply (Compare_6989586621679181827Sym0 :: TyFun (Identity a) (Identity a ~> Ordering) -> Type) (a6989586621679181832 :: Identity a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181827Sym0 :: TyFun (Identity a) (Identity a ~> Ordering) -> Type) (a6989586621679181832 :: Identity a) = Compare_6989586621679181827Sym1 a6989586621679181832
type Apply (Compare_6989586621680111321Sym0 :: TyFun (First a) (First a ~> Ordering) -> Type) (a6989586621680111326 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (Compare_6989586621680111321Sym0 :: TyFun (First a) (First a ~> Ordering) -> Type) (a6989586621680111326 :: First a) = Compare_6989586621680111321Sym1 a6989586621680111326
type Apply (Compare_6989586621680111341Sym0 :: TyFun (Last a) (Last a ~> Ordering) -> Type) (a6989586621680111346 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (Compare_6989586621680111341Sym0 :: TyFun (Last a) (Last a ~> Ordering) -> Type) (a6989586621680111346 :: Last a) = Compare_6989586621680111341Sym1 a6989586621680111346
type Apply (Compare_6989586621679179242Sym0 :: TyFun (Down a) (Down a ~> Ordering) -> Type) (a6989586621679179247 :: Down a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679179242Sym0 :: TyFun (Down a) (Down a ~> Ordering) -> Type) (a6989586621679179247 :: Down a) = Compare_6989586621679179242Sym1 a6989586621679179247
type Apply (Compare_6989586621679613701Sym0 :: TyFun (First a) (First a ~> Ordering) -> Type) (a6989586621679613706 :: First a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613701Sym0 :: TyFun (First a) (First a ~> Ordering) -> Type) (a6989586621679613706 :: First a) = Compare_6989586621679613701Sym1 a6989586621679613706
type Apply (Compare_6989586621679613721Sym0 :: TyFun (Last a) (Last a ~> Ordering) -> Type) (a6989586621679613726 :: Last a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613721Sym0 :: TyFun (Last a) (Last a ~> Ordering) -> Type) (a6989586621679613726 :: Last a) = Compare_6989586621679613721Sym1 a6989586621679613726
type Apply (Compare_6989586621679613681Sym0 :: TyFun (Max a) (Max a ~> Ordering) -> Type) (a6989586621679613686 :: Max a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613681Sym0 :: TyFun (Max a) (Max a ~> Ordering) -> Type) (a6989586621679613686 :: Max a) = Compare_6989586621679613681Sym1 a6989586621679613686
type Apply (Compare_6989586621679613661Sym0 :: TyFun (Min a) (Min a ~> Ordering) -> Type) (a6989586621679613666 :: Min a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613661Sym0 :: TyFun (Min a) (Min a ~> Ordering) -> Type) (a6989586621679613666 :: Min a) = Compare_6989586621679613661Sym1 a6989586621679613666
type Apply (Compare_6989586621679613741Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Ordering) -> Type) (a6989586621679613746 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613741Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Ordering) -> Type) (a6989586621679613746 :: WrappedMonoid m) = Compare_6989586621679613741Sym1 a6989586621679613746
type Apply (Compare_6989586621679613565Sym0 :: TyFun (Dual a) (Dual a ~> Ordering) -> Type) (a6989586621679613570 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613565Sym0 :: TyFun (Dual a) (Dual a ~> Ordering) -> Type) (a6989586621679613570 :: Dual a) = Compare_6989586621679613565Sym1 a6989586621679613570
type Apply (Compare_6989586621679613641Sym0 :: TyFun (Product a) (Product a ~> Ordering) -> Type) (a6989586621679613646 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613641Sym0 :: TyFun (Product a) (Product a ~> Ordering) -> Type) (a6989586621679613646 :: Product a) = Compare_6989586621679613641Sym1 a6989586621679613646
type Apply (Compare_6989586621679613621Sym0 :: TyFun (Sum a) (Sum a ~> Ordering) -> Type) (a6989586621679613626 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613621Sym0 :: TyFun (Sum a) (Sum a ~> Ordering) -> Type) (a6989586621679613626 :: Sum a) = Compare_6989586621679613621Sym1 a6989586621679613626
type Apply (Compare_6989586621679181443Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Ordering) -> Type) (a6989586621679181448 :: NonEmpty a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181443Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Ordering) -> Type) (a6989586621679181448 :: NonEmpty a) = Compare_6989586621679181443Sym1 a6989586621679181448
type Apply (Compare_6989586621679180719Sym0 :: TyFun (Maybe a) (Maybe a ~> Ordering) -> Type) (a6989586621679180724 :: Maybe a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679180719Sym0 :: TyFun (Maybe a) (Maybe a ~> Ordering) -> Type) (a6989586621679180724 :: Maybe a) = Compare_6989586621679180719Sym1 a6989586621679180724
type Apply (Compare_6989586621679181370Sym0 :: TyFun [a] ([a] ~> Ordering) -> Type) (a6989586621679181375 :: [a])
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181370Sym0 :: TyFun [a] ([a] ~> Ordering) -> Type) (a6989586621679181375 :: [a]) = Compare_6989586621679181370Sym1 a6989586621679181375
type Apply (Compare_6989586621679181415Sym1 a6989586621679181420 :: TyFun (Either a b) Ordering -> Type) (a6989586621679181421 :: Either a b)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181415Sym1 a6989586621679181420 :: TyFun (Either a b) Ordering -> Type) (a6989586621679181421 :: Either a b) = Compare_6989586621679181415 a6989586621679181420 a6989586621679181421
type Apply (Compare_6989586621680163447Sym1 a6989586621680163452 :: TyFun (Proxy s) Ordering -> Type) (a6989586621680163453 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (Compare_6989586621680163447Sym1 a6989586621680163452 :: TyFun (Proxy s) Ordering -> Type) (a6989586621680163453 :: Proxy s) = Compare_6989586621680163447 a6989586621680163452 a6989586621680163453
type Apply (Compare_6989586621680605396Sym1 a6989586621680605401 :: TyFun (Arg a b) Ordering -> Type) (a6989586621680605402 :: Arg a b)
Instance details Defined in Data.Semigroup.Singletons type Apply (Compare_6989586621680605396Sym1 a6989586621680605401 :: TyFun (Arg a b) Ordering -> Type) (a6989586621680605402 :: Arg a b) = Compare_6989586621680605396 a6989586621680605401 a6989586621680605402
type Apply (Compare_6989586621679181483Sym1 a6989586621679181488 :: TyFun (a, b) Ordering -> Type) (a6989586621679181489 :: (a, b))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181483Sym1 a6989586621679181488 :: TyFun (a, b) Ordering -> Type) (a6989586621679181489 :: (a, b)) = Compare_6989586621679181483 a6989586621679181488 a6989586621679181489
type Apply (SortBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> [a]) -> Type) (a6989586621679731564 :: a ~> (a ~> Ordering))
Instance details Defined in Data.List.Singletons.Internal type Apply (SortBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> [a]) -> Type) (a6989586621679731564 :: a ~> (a ~> Ordering)) = SortBySym1 a6989586621679731564
type Apply (ListsortBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> [a]) -> Type) (a6989586621680002151 :: a ~> (a ~> Ordering))
Instance details Defined in Data.List.Singletons.Internal.Disambiguation type Apply (ListsortBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> [a]) -> Type) (a6989586621680002151 :: a ~> (a ~> Ordering)) = ListsortBySym1 a6989586621680002151
type Apply (MaximumBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> a) -> Type) (a6989586621679731522 :: a ~> (a ~> Ordering))
Instance details Defined in Data.List.Singletons.Internal type Apply (MaximumBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> a) -> Type) (a6989586621679731522 :: a ~> (a ~> Ordering)) = MaximumBySym1 a6989586621679731522
type Apply (MinimumBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> a) -> Type) (a6989586621679731501 :: a ~> (a ~> Ordering))
Instance details Defined in Data.List.Singletons.Internal type Apply (MinimumBySym0 :: TyFun (a ~> (a ~> Ordering)) ([a] ~> a) -> Type) (a6989586621679731501 :: a ~> (a ~> Ordering)) = MinimumBySym1 a6989586621679731501
type Apply (InsertBySym0 :: TyFun (a ~> (a ~> Ordering)) (a ~> ([a] ~> [a])) -> Type) (a6989586621679731544 :: a ~> (a ~> Ordering))
Instance details Defined in Data.List.Singletons.Internal type Apply (InsertBySym0 :: TyFun (a ~> (a ~> Ordering)) (a ~> ([a] ~> [a])) -> Type) (a6989586621679731544 :: a ~> (a ~> Ordering)) = InsertBySym1 a6989586621679731544
type Apply (Compare_6989586621679181415Sym0 :: TyFun (Either a b) (Either a b ~> Ordering) -> Type) (a6989586621679181420 :: Either a b)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181415Sym0 :: TyFun (Either a b) (Either a b ~> Ordering) -> Type) (a6989586621679181420 :: Either a b) = Compare_6989586621679181415Sym1 a6989586621679181420
type Apply (Compare_6989586621680163447Sym0 :: TyFun (Proxy s) (Proxy s ~> Ordering) -> Type) (a6989586621680163452 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (Compare_6989586621680163447Sym0 :: TyFun (Proxy s) (Proxy s ~> Ordering) -> Type) (a6989586621680163452 :: Proxy s) = Compare_6989586621680163447Sym1 a6989586621680163452
type Apply (Compare_6989586621680605396Sym0 :: TyFun (Arg a b) (Arg a b ~> Ordering) -> Type) (a6989586621680605401 :: Arg a b)
Instance details Defined in Data.Semigroup.Singletons type Apply (Compare_6989586621680605396Sym0 :: TyFun (Arg a b) (Arg a b ~> Ordering) -> Type) (a6989586621680605401 :: Arg a b) = Compare_6989586621680605396Sym1 a6989586621680605401
type Apply (MaximumBySym0 :: TyFun (a ~> (a ~> Ordering)) (t a ~> a) -> Type) (a6989586621680193326 :: a ~> (a ~> Ordering))
Instance details Defined in Data.Foldable.Singletons type Apply (MaximumBySym0 :: TyFun (a ~> (a ~> Ordering)) (t a ~> a) -> Type) (a6989586621680193326 :: a ~> (a ~> Ordering)) = MaximumBySym1 a6989586621680193326 :: TyFun (t a) a -> Type
type Apply (MinimumBySym0 :: TyFun (a ~> (a ~> Ordering)) (t a ~> a) -> Type) (a6989586621680193306 :: a ~> (a ~> Ordering))
Instance details Defined in Data.Foldable.Singletons type Apply (MinimumBySym0 :: TyFun (a ~> (a ~> Ordering)) (t a ~> a) -> Type) (a6989586621680193306 :: a ~> (a ~> Ordering)) = MinimumBySym1 a6989586621680193306 :: TyFun (t a) a -> Type
type Apply (ComparingSym0 :: TyFun (b ~> a) (b ~> (b ~> Ordering)) -> Type) (a6989586621679166089 :: b ~> a)
Instance details Defined in Data.Ord.Singletons type Apply (ComparingSym0 :: TyFun (b ~> a) (b ~> (b ~> Ordering)) -> Type) (a6989586621679166089 :: b ~> a) = ComparingSym1 a6989586621679166089
type Apply (Let6989586621680193310Min'Sym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) (cmp6989586621680193308 :: k1 ~> (k1 ~> Ordering))
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193310Min'Sym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) (cmp6989586621680193308 :: k1 ~> (k1 ~> Ordering)) = Let6989586621680193310Min'Sym1 cmp6989586621680193308 :: TyFun k2 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type
type Apply (Let6989586621680193330Max'Sym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) (cmp6989586621680193328 :: k1 ~> (k1 ~> Ordering))
Instance details Defined in Data.Foldable.Singletons type Apply (Let6989586621680193330Max'Sym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) (cmp6989586621680193328 :: k1 ~> (k1 ~> Ordering)) = Let6989586621680193330Max'Sym1 cmp6989586621680193328 :: TyFun k2 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type
type Apply (Compare_6989586621679181483Sym0 :: TyFun (a, b) ((a, b) ~> Ordering) -> Type) (a6989586621679181488 :: (a, b))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181483Sym0 :: TyFun (a, b) ((a, b) ~> Ordering) -> Type) (a6989586621679181488 :: (a, b)) = Compare_6989586621679181483Sym1 a6989586621679181488
type Apply (Let6989586621679731508MinBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) -> Type) (cmp6989586621679731503 :: k1 ~> (k1 ~> Ordering))
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731508MinBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) -> Type) (cmp6989586621679731503 :: k1 ~> (k1 ~> Ordering)) = Let6989586621679731508MinBySym1 cmp6989586621679731503 :: TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type
type Apply (Let6989586621679731529MaxBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) -> Type) (cmp6989586621679731524 :: k1 ~> (k1 ~> Ordering))
Instance details Defined in Data.List.Singletons.Internal type Apply (Let6989586621679731529MaxBySym0 :: TyFun (k1 ~> (k1 ~> Ordering)) (TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type) -> Type) (cmp6989586621679731524 :: k1 ~> (k1 ~> Ordering)) = Let6989586621679731529MaxBySym1 cmp6989586621679731524 :: TyFun k2 (TyFun k3 (TyFun k1 (TyFun k1 k1 -> Type) -> Type) -> Type) -> Type
type Apply (Compare_6989586621680428560Sym1 a6989586621680428565 :: TyFun (Const a b) Ordering -> Type) (a6989586621680428566 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Compare_6989586621680428560Sym1 a6989586621680428565 :: TyFun (Const a b) Ordering -> Type) (a6989586621680428566 :: Const a b) = Compare_6989586621680428560 a6989586621680428565 a6989586621680428566
type Apply (Compare_6989586621679181521Sym1 a6989586621679181526 :: TyFun (a, b, c) Ordering -> Type) (a6989586621679181527 :: (a, b, c))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181521Sym1 a6989586621679181526 :: TyFun (a, b, c) Ordering -> Type) (a6989586621679181527 :: (a, b, c)) = Compare_6989586621679181521 a6989586621679181526 a6989586621679181527
type Apply (Compare_6989586621680428560Sym0 :: TyFun (Const a b) (Const a b ~> Ordering) -> Type) (a6989586621680428565 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Compare_6989586621680428560Sym0 :: TyFun (Const a b) (Const a b ~> Ordering) -> Type) (a6989586621680428565 :: Const a b) = Compare_6989586621680428560Sym1 a6989586621680428565
type Apply (Compare_6989586621679181521Sym0 :: TyFun (a, b, c) ((a, b, c) ~> Ordering) -> Type) (a6989586621679181526 :: (a, b, c))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181521Sym0 :: TyFun (a, b, c) ((a, b, c) ~> Ordering) -> Type) (a6989586621679181526 :: (a, b, c)) = Compare_6989586621679181521Sym1 a6989586621679181526
type Apply (Compare_6989586621679181570Sym1 a6989586621679181575 :: TyFun (a, b, c, d) Ordering -> Type) (a6989586621679181576 :: (a, b, c, d))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181570Sym1 a6989586621679181575 :: TyFun (a, b, c, d) Ordering -> Type) (a6989586621679181576 :: (a, b, c, d)) = Compare_6989586621679181570 a6989586621679181575 a6989586621679181576
type Apply (Compare_6989586621679181570Sym0 :: TyFun (a, b, c, d) ((a, b, c, d) ~> Ordering) -> Type) (a6989586621679181575 :: (a, b, c, d))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181570Sym0 :: TyFun (a, b, c, d) ((a, b, c, d) ~> Ordering) -> Type) (a6989586621679181575 :: (a, b, c, d)) = Compare_6989586621679181570Sym1 a6989586621679181575
type Apply (Compare_6989586621679181630Sym1 a6989586621679181635 :: TyFun (a, b, c, d, e) Ordering -> Type) (a6989586621679181636 :: (a, b, c, d, e))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181630Sym1 a6989586621679181635 :: TyFun (a, b, c, d, e) Ordering -> Type) (a6989586621679181636 :: (a, b, c, d, e)) = Compare_6989586621679181630 a6989586621679181635 a6989586621679181636
type Apply (Compare_6989586621679181630Sym0 :: TyFun (a, b, c, d, e) ((a, b, c, d, e) ~> Ordering) -> Type) (a6989586621679181635 :: (a, b, c, d, e))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181630Sym0 :: TyFun (a, b, c, d, e) ((a, b, c, d, e) ~> Ordering) -> Type) (a6989586621679181635 :: (a, b, c, d, e)) = Compare_6989586621679181630Sym1 a6989586621679181635
type Apply (Compare_6989586621679181701Sym1 a6989586621679181706 :: TyFun (a, b, c, d, e, f) Ordering -> Type) (a6989586621679181707 :: (a, b, c, d, e, f))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181701Sym1 a6989586621679181706 :: TyFun (a, b, c, d, e, f) Ordering -> Type) (a6989586621679181707 :: (a, b, c, d, e, f)) = Compare_6989586621679181701 a6989586621679181706 a6989586621679181707
type Apply (Compare_6989586621679181701Sym0 :: TyFun (a, b, c, d, e, f) ((a, b, c, d, e, f) ~> Ordering) -> Type) (a6989586621679181706 :: (a, b, c, d, e, f))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181701Sym0 :: TyFun (a, b, c, d, e, f) ((a, b, c, d, e, f) ~> Ordering) -> Type) (a6989586621679181706 :: (a, b, c, d, e, f)) = Compare_6989586621679181701Sym1 a6989586621679181706
type Apply (Compare_6989586621679181783Sym1 a6989586621679181788 :: TyFun (a, b, c, d, e, f, g) Ordering -> Type) (a6989586621679181789 :: (a, b, c, d, e, f, g))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181783Sym1 a6989586621679181788 :: TyFun (a, b, c, d, e, f, g) Ordering -> Type) (a6989586621679181789 :: (a, b, c, d, e, f, g)) = Compare_6989586621679181783 a6989586621679181788 a6989586621679181789
type Apply (Compare_6989586621679181783Sym0 :: TyFun (a, b, c, d, e, f, g) ((a, b, c, d, e, f, g) ~> Ordering) -> Type) (a6989586621679181788 :: (a, b, c, d, e, f, g))
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181783Sym0 :: TyFun (a, b, c, d, e, f, g) ((a, b, c, d, e, f, g) ~> Ordering) -> Type) (a6989586621679181788 :: (a, b, c, d, e, f, g)) = Compare_6989586621679181783Sym1 a6989586621679181788

data Ratio a #

Rational numbers, with numerator and denominator of some Integral type.

Note that Ratio's instances inherit the deficiencies from the type parameter's. For example, Ratio Natural's Num instance has similar problems to Natural's.

Constructors

!a :% !a

Instances

Instances details

NFData1 Ratio	Available on `base >=4.9` Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Ratio a -> () #
Integral a => Lift (Ratio a :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Ratio a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Ratio a -> Code m (Ratio a) #
Structured a => Structured (Ratio a)
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy (Ratio a) -> Structure # structureHash' :: Tagged (Ratio a) MD5
(Storable a, Integral a) => Storable (Ratio a)	Since: base-4.8.0.0
Instance details Defined in Foreign.Storable Methods sizeOf :: Ratio a -> Int # alignment :: Ratio a -> Int # peekElemOff :: Ptr (Ratio a) -> Int -> IO (Ratio a) # pokeElemOff :: Ptr (Ratio a) -> Int -> Ratio a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Ratio a) # pokeByteOff :: Ptr b -> Int -> Ratio a -> IO () # peek :: Ptr (Ratio a) -> IO (Ratio a) # poke :: Ptr (Ratio a) -> Ratio a -> IO () #
Integral a => Enum (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods succ :: Ratio a -> Ratio a # pred :: Ratio a -> Ratio a # toEnum :: Int -> Ratio a # fromEnum :: Ratio a -> Int # enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] #
Integral a => Num (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (+) :: Ratio a -> Ratio a -> Ratio a # (-) :: Ratio a -> Ratio a -> Ratio a # (*) :: Ratio a -> Ratio a -> Ratio a # negate :: Ratio a -> Ratio a # abs :: Ratio a -> Ratio a # signum :: Ratio a -> Ratio a # fromInteger :: Integer -> Ratio a #
(Integral a, Read a) => Read (Ratio a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (Ratio a) # readList :: ReadS [Ratio a] # readPrec :: ReadPrec (Ratio a) # readListPrec :: ReadPrec [Ratio a] #
Integral a => Fractional (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods (/) :: Ratio a -> Ratio a -> Ratio a # recip :: Ratio a -> Ratio a # fromRational :: Rational -> Ratio a #
Integral a => Real (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Ratio a -> Rational #
Integral a => RealFrac (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods properFraction :: Integral b => Ratio a -> (b, Ratio a) # truncate :: Integral b => Ratio a -> b # round :: Integral b => Ratio a -> b # ceiling :: Integral b => Ratio a -> b # floor :: Integral b => Ratio a -> b #
Show a => Show (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods showsPrec :: Int -> Ratio a -> ShowS # show :: Ratio a -> String # showList :: [Ratio a] -> ShowS #
Integral a => Default (Ratio a)
Instance details Defined in Data.Default.Class Methods def :: Ratio a #
NFData a => NFData (Ratio a)
Instance details Defined in Control.DeepSeq Methods rnf :: Ratio a -> () #
Buildable a => Buildable (Ratio a)
Instance details Defined in Formatting.Buildable Methods build :: Ratio a -> Builder #
Eq a => Eq (Ratio a)	Since: base-2.1
Instance details Defined in GHC.Real Methods (==) :: Ratio a -> Ratio a -> Bool # (/=) :: Ratio a -> Ratio a -> Bool #
Integral a => Ord (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods compare :: Ratio a -> Ratio a -> Ordering # (<) :: Ratio a -> Ratio a -> Bool # (<=) :: Ratio a -> Ratio a -> Bool # (>) :: Ratio a -> Ratio a -> Bool # (>=) :: Ratio a -> Ratio a -> Bool # max :: Ratio a -> Ratio a -> Ratio a # min :: Ratio a -> Ratio a -> Ratio a #
Hashable a => Hashable (Ratio a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ratio a -> Int # hash :: Ratio a -> Int #
Integral a => Ring (Ratio a)
Instance details Defined in Data.Semiring Methods negate :: Ratio a -> Ratio a #
Integral a => Semiring (Ratio a)
Instance details Defined in Data.Semiring Methods plus :: Ratio a -> Ratio a -> Ratio a # zero :: Ratio a # times :: Ratio a -> Ratio a -> Ratio a # one :: Ratio a # fromNatural :: Natural -> Ratio a #
(Integral a) :=> (Enum (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Enum (Ratio a) #
(Integral a) :=> (Num (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Num (Ratio a) #
(Integral a) :=> (Fractional (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Fractional (Ratio a) #
(Integral a) :=> (Real (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Real (Ratio a) #
(Integral a) :=> (RealFrac (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- RealFrac (Ratio a) #
(Integral a) :=> (Ord (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Ord (Ratio a) #
(Eq a) :=> (Eq (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: Eq a :- Eq (Ratio a) #
(Integral a, Read a) :=> (Read (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: (Integral a, Read a) :- Read (Ratio a) #
(Integral a, Show a) :=> (Show (Ratio a))
Instance details Defined in Data.Constraint Methods ins :: (Integral a, Show a) :- Show (Ratio a) #

type Rational = Ratio Integer #

Arbitrary-precision rational numbers, represented as a ratio of two Integer values. A rational number may be constructed using the % operator.

data IO a #

A value of type IO a is a computation which, when performed, does some I/O before returning a value of type a.

There is really only one way to "perform" an I/O action: bind it to Main.main in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the IO monad and called at some point, directly or indirectly, from Main.main.

IO is a monad, so IO actions can be combined using either the do-notation or the >> and >>= operations from the Monad class.

Instances

Instances details

MonadFail IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> IO a #
MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
Alternative IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods empty :: IO a # (<\|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
Applicative IO	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> IO a # (<>) :: IO (a -> b) -> IO a -> IO b # liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c # (>) :: IO a -> IO b -> IO b # (<*) :: IO a -> IO b -> IO a #
Functor IO	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Monad IO	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a #
MonadPlus IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
PrimMonad IO
Instance details Defined in Basement.Monad Associated Types type PrimState IO # type PrimVar IO :: Type -> Type # Methods primitive :: (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a # primThrow :: Exception e => e -> IO a # unPrimMonad :: IO a -> State# (PrimState IO) -> (# State# (PrimState IO), a #) # primVarNew :: a -> IO (PrimVar IO a) # primVarRead :: PrimVar IO a -> IO a # primVarWrite :: PrimVar IO a -> a -> IO () #
MonadRandom IO
Instance details Defined in Crypto.Random.Types Methods getRandomBytes :: ByteArray byteArray => Int -> IO byteArray #
MonadCatch IO
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => IO a -> (e -> IO a) -> IO a #
MonadMask IO
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b # uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b # generalBracket :: IO a -> (a -> ExitCase b -> IO c) -> (a -> IO b) -> IO (b, c) #
MonadThrow IO
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> IO a #
PrimBase IO
Instance details Defined in Control.Monad.Primitive Methods internal :: IO a -> State# (PrimState IO) -> (# State# (PrimState IO), a #) #
PrimMonad IO
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState IO # Methods primitive :: (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a #
Quasi IO
Instance details Defined in Language.Haskell.TH.Syntax Methods qNewName :: String -> IO Name # qReport :: Bool -> String -> IO () # qRecover :: IO a -> IO a -> IO a # qLookupName :: Bool -> String -> IO (Maybe Name) # qReify :: Name -> IO Info # qReifyFixity :: Name -> IO (Maybe Fixity) # qReifyType :: Name -> IO Type # qReifyInstances :: Name -> [Type] -> IO [Dec] # qReifyRoles :: Name -> IO [Role] # qReifyAnnotations :: Data a => AnnLookup -> IO [a] # qReifyModule :: Module -> IO ModuleInfo # qReifyConStrictness :: Name -> IO [DecidedStrictness] # qLocation :: IO Loc # qRunIO :: IO a -> IO a # qAddDependentFile :: FilePath -> IO () # qAddTempFile :: String -> IO FilePath # qAddTopDecls :: [Dec] -> IO () # qAddForeignFilePath :: ForeignSrcLang -> String -> IO () # qAddModFinalizer :: Q () -> IO () # qAddCorePlugin :: String -> IO () # qGetQ :: Typeable a => IO (Maybe a) # qPutQ :: Typeable a => a -> IO () # qIsExtEnabled :: Extension -> IO Bool # qExtsEnabled :: IO [Extension] #
Quote IO
Instance details Defined in Language.Haskell.TH.Syntax Methods newName :: String -> IO Name #
MonadError IOException IO
Instance details Defined in Control.Monad.Error.Class Methods throwError :: IOException -> IO a # catchError :: IO a -> (IOException -> IO a) -> IO a #
() :=> (Applicative IO)
Instance details Defined in Data.Constraint Methods ins :: () :- Applicative IO #
() :=> (Functor IO)
Instance details Defined in Data.Constraint Methods ins :: () :- Functor IO #
() :=> (Monad IO)
Instance details Defined in Data.Constraint Methods ins :: () :- Monad IO #
Monoid a => Monoid (IO a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Semigroup a => Semigroup (IO a)	Since: base-4.10.0.0
Instance details Defined in GHC.Base Methods (<>) :: IO a -> IO a -> IO a # sconcat :: NonEmpty (IO a) -> IO a # stimes :: Integral b => b -> IO a -> IO a #
Default a => Default (IO a)
Instance details Defined in Data.Default.Class Methods def :: IO a #
a ~ () => FromBuilder (IO a)
Instance details Defined in Fmt.Internal.Core Methods fromBuilder :: Builder -> IO a #
Boolean bool => Boolean (IO bool)
Instance details Defined in Morley.Prelude.Boolean Methods (&&) :: IO bool -> IO bool -> IO bool # (\|\|) :: IO bool -> IO bool -> IO bool # not :: IO bool -> IO bool #
BooleanMonoid bool => BooleanMonoid (IO bool)
Instance details Defined in Morley.Prelude.Boolean Methods false :: IO bool # true :: IO bool #
Ring a => Ring (IO a)
Instance details Defined in Data.Semiring Methods negate :: IO a -> IO a #
Semiring a => Semiring (IO a)
Instance details Defined in Data.Semiring Methods plus :: IO a -> IO a -> IO a # zero :: IO a # times :: IO a -> IO a -> IO a # one :: IO a # fromNatural :: Natural -> IO a #
IsoHKD IO (a :: Type)
Instance details Defined in Data.Vinyl.XRec Associated Types type HKD IO a # Methods unHKD :: HKD IO a -> IO a # toHKD :: IO a -> HKD IO a #
(Monoid a) :=> (Monoid (IO a))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Monoid (IO a) #
(Semigroup a) :=> (Semigroup (IO a))
Instance details Defined in Data.Constraint Methods ins :: Semigroup a :- Semigroup (IO a) #
type PrimState IO
Instance details Defined in Basement.Monad type PrimState IO = RealWorld
type PrimVar IO
Instance details Defined in Basement.Monad type PrimVar IO = IORef
type PrimState IO
Instance details Defined in Control.Monad.Primitive type PrimState IO = RealWorld
type HKD IO (a :: Type)
Instance details Defined in Data.Vinyl.XRec type HKD IO (a :: Type) = IO a

data Word #

A Word is an unsigned integral type, with the same size as Int.

Instances

Instances details

Structured Word
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Word -> Structure # structureHash' :: Tagged Word MD5
Bits Word	Since: base-2.1
Instance details Defined in Data.Bits Methods (.&.) :: Word -> Word -> Word # (.\|.) :: Word -> Word -> Word # xor :: Word -> Word -> Word # complement :: Word -> Word # shift :: Word -> Int -> Word # rotate :: Word -> Int -> Word # zeroBits :: Word # bit :: Int -> Word # setBit :: Word -> Int -> Word # clearBit :: Word -> Int -> Word # complementBit :: Word -> Int -> Word # testBit :: Word -> Int -> Bool # bitSizeMaybe :: Word -> Maybe Int # bitSize :: Word -> Int # isSigned :: Word -> Bool # shiftL :: Word -> Int -> Word # unsafeShiftL :: Word -> Int -> Word # shiftR :: Word -> Int -> Word # unsafeShiftR :: Word -> Int -> Word # rotateL :: Word -> Int -> Word # rotateR :: Word -> Int -> Word # popCount :: Word -> Int #
FiniteBits Word	Since: base-4.6.0.0
Instance details Defined in Data.Bits Methods finiteBitSize :: Word -> Int # countLeadingZeros :: Word -> Int # countTrailingZeros :: Word -> Int #
Storable Word	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word -> Int # alignment :: Word -> Int # peekElemOff :: Ptr Word -> Int -> IO Word # pokeElemOff :: Ptr Word -> Int -> Word -> IO () # peekByteOff :: Ptr b -> Int -> IO Word # pokeByteOff :: Ptr b -> Int -> Word -> IO () # peek :: Ptr Word -> IO Word # poke :: Ptr Word -> Word -> IO () #
Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word # maxBound :: Word #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Word -> Word # pred :: Word -> Word # toEnum :: Int -> Word # fromEnum :: Word -> Int # enumFrom :: Word -> [Word] # enumFromThen :: Word -> Word -> [Word] # enumFromTo :: Word -> Word -> [Word] # enumFromThenTo :: Word -> Word -> Word -> [Word] #
Num Word	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Word -> Word -> Word # (-) :: Word -> Word -> Word # (*) :: Word -> Word -> Word # negate :: Word -> Word # abs :: Word -> Word # signum :: Word -> Word # fromInteger :: Integer -> Word #
Read Word	Since: base-4.5.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word # readList :: ReadS [Word] # readPrec :: ReadPrec Word # readListPrec :: ReadPrec [Word] #
Integral Word	Since: base-2.1
Instance details Defined in GHC.Real Methods quot :: Word -> Word -> Word # rem :: Word -> Word -> Word # div :: Word -> Word -> Word # mod :: Word -> Word -> Word # quotRem :: Word -> Word -> (Word, Word) # divMod :: Word -> Word -> (Word, Word) # toInteger :: Word -> Integer #
Real Word	Since: base-2.1
Instance details Defined in GHC.Real Methods toRational :: Word -> Rational #
Show Word	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
BitOps Word
Instance details Defined in Basement.Bits Methods (.&.) :: Word -> Word -> Word # (.\|.) :: Word -> Word -> Word # (.^.) :: Word -> Word -> Word # (.<<.) :: Word -> CountOf Bool -> Word # (.>>.) :: Word -> CountOf Bool -> Word # bit :: Offset Bool -> Word # isBitSet :: Word -> Offset Bool -> Bool # setBit :: Word -> Offset Bool -> Word # clearBit :: Word -> Offset Bool -> Word #
FiniteBitsOps Word
Instance details Defined in Basement.Bits Methods numberOfBits :: Word -> CountOf Bool # rotateL :: Word -> CountOf Bool -> Word # rotateR :: Word -> CountOf Bool -> Word # popCount :: Word -> CountOf Bool # bitFlip :: Word -> Word # countLeadingZeros :: Word -> CountOf Bool # countTrailingZeros :: Word -> CountOf Bool #
Subtractive Word
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Word # Methods (-) :: Word -> Word -> Difference Word #
PrimMemoryComparable Word
Instance details Defined in Basement.PrimType
PrimType Word
Instance details Defined in Basement.PrimType Associated Types type PrimSize Word :: Nat # Methods primSizeInBytes :: Proxy Word -> CountOf Word8 # primShiftToBytes :: Proxy Word -> Int # primBaUIndex :: ByteArray# -> Offset Word -> Word # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> prim Word # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> Word -> prim () # primAddrIndex :: Addr# -> Offset Word -> Word # primAddrRead :: PrimMonad prim => Addr# -> Offset Word -> prim Word # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word -> Word -> prim () #
Default Word
Instance details Defined in Data.Default.Class Methods def :: Word #
NFData Word
Instance details Defined in Control.DeepSeq Methods rnf :: Word -> () #
Buildable Word
Instance details Defined in Formatting.Buildable Methods build :: Word -> Builder #
Eq Word
Instance details Defined in GHC.Classes Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Ord Word
Instance details Defined in GHC.Classes Methods compare :: Word -> Word -> Ordering # (<) :: Word -> Word -> Bool # (<=) :: Word -> Word -> Bool # (>) :: Word -> Word -> Bool # (>=) :: Word -> Word -> Bool # max :: Word -> Word -> Word # min :: Word -> Word -> Word #
Hashable Word
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word -> Int # hash :: Word -> Int #
Uniform Word
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word #
UniformRange Word
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word, Word) -> g -> m Word #
Ring Word
Instance details Defined in Data.Semiring Methods negate :: Word -> Word #
Semiring Word
Instance details Defined in Data.Semiring Methods plus :: Word -> Word -> Word # zero :: Word # times :: Word -> Word -> Word # one :: Word # fromNatural :: Natural -> Word #
Unbox Word
Instance details Defined in Data.Vector.Unboxed.Base
Lift Word
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word -> Code m Word #
Vector Vector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word) # basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word) # basicLength :: Vector Word -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word # basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m () # elemseq :: Vector Word -> Word -> b -> b #
MVector MVector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word # basicOverlaps :: MVector s Word -> MVector s Word -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word) #
() :=> (Bits Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Bits Word #
() :=> (Bounded Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Bounded Word #
() :=> (Enum Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Enum Word #
() :=> (Num Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Num Word #
() :=> (Read Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Read Word #
() :=> (Integral Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Integral Word #
() :=> (Real Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Real Word #
() :=> (Show Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Show Word #
() :=> (Eq Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Eq Word #
() :=> (Ord Word)
Instance details Defined in Data.Constraint Methods ins :: () :- Ord Word #
Generic1 (URec Word :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Word) :: k -> Type # Methods from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a # to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a #
Foldable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m # foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m # foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b # foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b # foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] # null :: UWord a -> Bool # length :: UWord a -> Int # elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # sum :: Num a => UWord a -> a # product :: Num a => UWord a -> a #
Traversable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) # sequenceA :: Applicative f => UWord (f a) -> f (UWord a) # mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b) # sequence :: Monad m => UWord (m a) -> m (UWord a) #
Functor (URec Word :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Generic (URec Word p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
Show (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
Eq (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Ord (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Word p -> URec Word p -> Ordering # (<) :: URec Word p -> URec Word p -> Bool # (<=) :: URec Word p -> URec Word p -> Bool # (>) :: URec Word p -> URec Word p -> Bool # (>=) :: URec Word p -> URec Word p -> Bool # max :: URec Word p -> URec Word p -> URec Word p # min :: URec Word p -> URec Word p -> URec Word p #
type NatNumMaxBound Word
Instance details Defined in Basement.Nat type NatNumMaxBound Word = NatNumMaxBound Word64
type Difference Word
Instance details Defined in Basement.Numerical.Subtractive type Difference Word = Word
type PrimSize Word
Instance details Defined in Basement.PrimType type PrimSize Word = 8
type IntBaseType Word
Instance details Defined in Data.IntCast type IntBaseType Word = 'FixedWordTag 64
type PrettyShow Word
Instance details Defined in Morley.Prelude.Show type PrettyShow Word = ()
newtype Vector Word
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word = V_Word (Vector Word)
data URec Word (p :: k)	Used for marking occurrences of `Word#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Word (p :: k) = UWord { uWord# :: Word# }
newtype MVector s Word
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word = MV_Word (MVector s Word)
type Rep1 (URec Word :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Word :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: k -> Type)))
type Rep (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Word p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: Type -> Type)))

data Word8 #

8-bit unsigned integer type

Instances

Instances details

Structured Word8
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Word8 -> Structure # structureHash' :: Tagged Word8 MD5
FiniteBitsBase Word8
Instance details Defined in Data.Word.Odd Methods subWordClz :: Int -> Word8 -> Int # subWordCtz :: Int -> Word8 -> Int #
Bits Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word8 -> Word8 -> Word8 # (.\|.) :: Word8 -> Word8 -> Word8 # xor :: Word8 -> Word8 -> Word8 # complement :: Word8 -> Word8 # shift :: Word8 -> Int -> Word8 # rotate :: Word8 -> Int -> Word8 # zeroBits :: Word8 # bit :: Int -> Word8 # setBit :: Word8 -> Int -> Word8 # clearBit :: Word8 -> Int -> Word8 # complementBit :: Word8 -> Int -> Word8 # testBit :: Word8 -> Int -> Bool # bitSizeMaybe :: Word8 -> Maybe Int # bitSize :: Word8 -> Int # isSigned :: Word8 -> Bool # shiftL :: Word8 -> Int -> Word8 # unsafeShiftL :: Word8 -> Int -> Word8 # shiftR :: Word8 -> Int -> Word8 # unsafeShiftR :: Word8 -> Int -> Word8 # rotateL :: Word8 -> Int -> Word8 # rotateR :: Word8 -> Int -> Word8 # popCount :: Word8 -> Int #
FiniteBits Word8	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word8 -> Int # countLeadingZeros :: Word8 -> Int # countTrailingZeros :: Word8 -> Int #
Storable Word8	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word8 -> Int # alignment :: Word8 -> Int # peekElemOff :: Ptr Word8 -> Int -> IO Word8 # pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word8 # pokeByteOff :: Ptr b -> Int -> Word8 -> IO () # peek :: Ptr Word8 -> IO Word8 # poke :: Ptr Word8 -> Word8 -> IO () #
Bounded Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word8 # maxBound :: Word8 #
Enum Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Ix Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word8, Word8) -> [Word8] # index :: (Word8, Word8) -> Word8 -> Int # unsafeIndex :: (Word8, Word8) -> Word8 -> Int # inRange :: (Word8, Word8) -> Word8 -> Bool # rangeSize :: (Word8, Word8) -> Int # unsafeRangeSize :: (Word8, Word8) -> Int #
Num Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word8 -> Word8 -> Word8 # (-) :: Word8 -> Word8 -> Word8 # (*) :: Word8 -> Word8 -> Word8 # negate :: Word8 -> Word8 # abs :: Word8 -> Word8 # signum :: Word8 -> Word8 # fromInteger :: Integer -> Word8 #
Read Word8	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word8 # readList :: ReadS [Word8] # readPrec :: ReadPrec Word8 # readListPrec :: ReadPrec [Word8] #
Integral Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word8 -> Word8 -> Word8 # rem :: Word8 -> Word8 -> Word8 # div :: Word8 -> Word8 -> Word8 # mod :: Word8 -> Word8 -> Word8 # quotRem :: Word8 -> Word8 -> (Word8, Word8) # divMod :: Word8 -> Word8 -> (Word8, Word8) # toInteger :: Word8 -> Integer #
Real Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word8 -> Rational #
Show Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
BitOps Word8
Instance details Defined in Basement.Bits Methods (.&.) :: Word8 -> Word8 -> Word8 # (.\|.) :: Word8 -> Word8 -> Word8 # (.^.) :: Word8 -> Word8 -> Word8 # (.<<.) :: Word8 -> CountOf Bool -> Word8 # (.>>.) :: Word8 -> CountOf Bool -> Word8 # bit :: Offset Bool -> Word8 # isBitSet :: Word8 -> Offset Bool -> Bool # setBit :: Word8 -> Offset Bool -> Word8 # clearBit :: Word8 -> Offset Bool -> Word8 #
FiniteBitsOps Word8
Instance details Defined in Basement.Bits Methods numberOfBits :: Word8 -> CountOf Bool # rotateL :: Word8 -> CountOf Bool -> Word8 # rotateR :: Word8 -> CountOf Bool -> Word8 # popCount :: Word8 -> CountOf Bool # bitFlip :: Word8 -> Word8 # countLeadingZeros :: Word8 -> CountOf Bool # countTrailingZeros :: Word8 -> CountOf Bool #
Subtractive Word8
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Word8 # Methods (-) :: Word8 -> Word8 -> Difference Word8 #
PrimMemoryComparable Word8
Instance details Defined in Basement.PrimType
PrimType Word8
Instance details Defined in Basement.PrimType Associated Types type PrimSize Word8 :: Nat # Methods primSizeInBytes :: Proxy Word8 -> CountOf Word8 # primShiftToBytes :: Proxy Word8 -> Int # primBaUIndex :: ByteArray# -> Offset Word8 -> Word8 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> prim Word8 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word8 -> Word8 -> prim () # primAddrIndex :: Addr# -> Offset Word8 -> Word8 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word8 -> prim Word8 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word8 -> Word8 -> prim () #
Default Word8
Instance details Defined in Data.Default.Class Methods def :: Word8 #
NFData Word8
Instance details Defined in Control.DeepSeq Methods rnf :: Word8 -> () #
Buildable Word8
Instance details Defined in Formatting.Buildable Methods build :: Word8 -> Builder #
Eq Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Ord Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word8 -> Word8 -> Ordering # (<) :: Word8 -> Word8 -> Bool # (<=) :: Word8 -> Word8 -> Bool # (>) :: Word8 -> Word8 -> Bool # (>=) :: Word8 -> Word8 -> Bool # max :: Word8 -> Word8 -> Word8 # min :: Word8 -> Word8 -> Word8 #
Hashable Word8
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word8 -> Int # hash :: Word8 -> Int #
Uniform Word8
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word8 #
UniformRange Word8
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word8, Word8) -> g -> m Word8 #
Ring Word8
Instance details Defined in Data.Semiring Methods negate :: Word8 -> Word8 #
Semiring Word8
Instance details Defined in Data.Semiring Methods plus :: Word8 -> Word8 -> Word8 # zero :: Word8 # times :: Word8 -> Word8 -> Word8 # one :: Word8 # fromNatural :: Natural -> Word8 #
ByteSource Word8
Instance details Defined in Data.UUID.Types.Internal.Builder Methods (/-/) :: ByteSink Word8 g -> Word8 -> g
Unbox Word8
Instance details Defined in Data.Vector.Unboxed.Base
Lift Word8
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word8 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word8 -> Code m Word8 #
Vector Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8) # basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8) # basicLength :: Vector Word8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8 # basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m () # elemseq :: Vector Word8 -> Word8 -> b -> b #
MVector MVector Word8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word8 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8 # basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word8) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8) #
type NatNumMaxBound Word8
Instance details Defined in Basement.Nat type NatNumMaxBound Word8 = 255
type Difference Word8
Instance details Defined in Basement.Numerical.Subtractive type Difference Word8 = Word8
type PrimSize Word8
Instance details Defined in Basement.PrimType type PrimSize Word8 = 1
type IntBaseType Word8
Instance details Defined in Data.IntCast type IntBaseType Word8 = 'FixedWordTag 8
type PrettyShow Word8
Instance details Defined in Morley.Prelude.Show type PrettyShow Word8 = ()
newtype Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word8 = V_Word8 (Vector Word8)
type ByteSink Word8 g
Instance details Defined in Data.UUID.Types.Internal.Builder type ByteSink Word8 g = Takes1Byte g
newtype MVector s Word8
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word8 = MV_Word8 (MVector s Word8)

data Word16 #

16-bit unsigned integer type

Instances

Instances details

Structured Word16
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Word16 -> Structure # structureHash' :: Tagged Word16 MD5
FiniteBitsBase Word16
Instance details Defined in Data.Word.Odd Methods subWordClz :: Int -> Word16 -> Int # subWordCtz :: Int -> Word16 -> Int #
Bits Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word16 -> Word16 -> Word16 # (.\|.) :: Word16 -> Word16 -> Word16 # xor :: Word16 -> Word16 -> Word16 # complement :: Word16 -> Word16 # shift :: Word16 -> Int -> Word16 # rotate :: Word16 -> Int -> Word16 # zeroBits :: Word16 # bit :: Int -> Word16 # setBit :: Word16 -> Int -> Word16 # clearBit :: Word16 -> Int -> Word16 # complementBit :: Word16 -> Int -> Word16 # testBit :: Word16 -> Int -> Bool # bitSizeMaybe :: Word16 -> Maybe Int # bitSize :: Word16 -> Int # isSigned :: Word16 -> Bool # shiftL :: Word16 -> Int -> Word16 # unsafeShiftL :: Word16 -> Int -> Word16 # shiftR :: Word16 -> Int -> Word16 # unsafeShiftR :: Word16 -> Int -> Word16 # rotateL :: Word16 -> Int -> Word16 # rotateR :: Word16 -> Int -> Word16 # popCount :: Word16 -> Int #
FiniteBits Word16	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word16 -> Int # countLeadingZeros :: Word16 -> Int # countTrailingZeros :: Word16 -> Int #
Storable Word16	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word16 -> Int # alignment :: Word16 -> Int # peekElemOff :: Ptr Word16 -> Int -> IO Word16 # pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word16 # pokeByteOff :: Ptr b -> Int -> Word16 -> IO () # peek :: Ptr Word16 -> IO Word16 # poke :: Ptr Word16 -> Word16 -> IO () #
Bounded Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word16 # maxBound :: Word16 #
Enum Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Ix Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word16, Word16) -> [Word16] # index :: (Word16, Word16) -> Word16 -> Int # unsafeIndex :: (Word16, Word16) -> Word16 -> Int # inRange :: (Word16, Word16) -> Word16 -> Bool # rangeSize :: (Word16, Word16) -> Int # unsafeRangeSize :: (Word16, Word16) -> Int #
Num Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word16 -> Word16 -> Word16 # (-) :: Word16 -> Word16 -> Word16 # (*) :: Word16 -> Word16 -> Word16 # negate :: Word16 -> Word16 # abs :: Word16 -> Word16 # signum :: Word16 -> Word16 # fromInteger :: Integer -> Word16 #
Read Word16	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word16 # readList :: ReadS [Word16] # readPrec :: ReadPrec Word16 # readListPrec :: ReadPrec [Word16] #
Integral Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word16 -> Word16 -> Word16 # rem :: Word16 -> Word16 -> Word16 # div :: Word16 -> Word16 -> Word16 # mod :: Word16 -> Word16 -> Word16 # quotRem :: Word16 -> Word16 -> (Word16, Word16) # divMod :: Word16 -> Word16 -> (Word16, Word16) # toInteger :: Word16 -> Integer #
Real Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word16 -> Rational #
Show Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
BitOps Word16
Instance details Defined in Basement.Bits Methods (.&.) :: Word16 -> Word16 -> Word16 # (.\|.) :: Word16 -> Word16 -> Word16 # (.^.) :: Word16 -> Word16 -> Word16 # (.<<.) :: Word16 -> CountOf Bool -> Word16 # (.>>.) :: Word16 -> CountOf Bool -> Word16 # bit :: Offset Bool -> Word16 # isBitSet :: Word16 -> Offset Bool -> Bool # setBit :: Word16 -> Offset Bool -> Word16 # clearBit :: Word16 -> Offset Bool -> Word16 #
FiniteBitsOps Word16
Instance details Defined in Basement.Bits Methods numberOfBits :: Word16 -> CountOf Bool # rotateL :: Word16 -> CountOf Bool -> Word16 # rotateR :: Word16 -> CountOf Bool -> Word16 # popCount :: Word16 -> CountOf Bool # bitFlip :: Word16 -> Word16 # countLeadingZeros :: Word16 -> CountOf Bool # countTrailingZeros :: Word16 -> CountOf Bool #
Subtractive Word16
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Word16 # Methods (-) :: Word16 -> Word16 -> Difference Word16 #
PrimMemoryComparable Word16
Instance details Defined in Basement.PrimType
PrimType Word16
Instance details Defined in Basement.PrimType Associated Types type PrimSize Word16 :: Nat # Methods primSizeInBytes :: Proxy Word16 -> CountOf Word8 # primShiftToBytes :: Proxy Word16 -> Int # primBaUIndex :: ByteArray# -> Offset Word16 -> Word16 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> prim Word16 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word16 -> Word16 -> prim () # primAddrIndex :: Addr# -> Offset Word16 -> Word16 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word16 -> prim Word16 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word16 -> Word16 -> prim () #
Default Word16
Instance details Defined in Data.Default.Class Methods def :: Word16 #
NFData Word16
Instance details Defined in Control.DeepSeq Methods rnf :: Word16 -> () #
Buildable Word16
Instance details Defined in Formatting.Buildable Methods build :: Word16 -> Builder #
Eq Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Ord Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word16 -> Word16 -> Ordering # (<) :: Word16 -> Word16 -> Bool # (<=) :: Word16 -> Word16 -> Bool # (>) :: Word16 -> Word16 -> Bool # (>=) :: Word16 -> Word16 -> Bool # max :: Word16 -> Word16 -> Word16 # min :: Word16 -> Word16 -> Word16 #
Hashable Word16
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word16 -> Int # hash :: Word16 -> Int #
Uniform Word16
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word16 #
UniformRange Word16
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word16, Word16) -> g -> m Word16 #
Ring Word16
Instance details Defined in Data.Semiring Methods negate :: Word16 -> Word16 #
Semiring Word16
Instance details Defined in Data.Semiring Methods plus :: Word16 -> Word16 -> Word16 # zero :: Word16 # times :: Word16 -> Word16 -> Word16 # one :: Word16 # fromNatural :: Natural -> Word16 #
ByteSource Word16
Instance details Defined in Data.UUID.Types.Internal.Builder Methods (/-/) :: ByteSink Word16 g -> Word16 -> g
Unbox Word16
Instance details Defined in Data.Vector.Unboxed.Base
Lift Word16
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word16 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word16 -> Code m Word16 #
Vector Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> m (Vector Word16) # basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m (Mutable Vector (PrimState m) Word16) # basicLength :: Vector Word16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16 # basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> Vector Word16 -> m () # elemseq :: Vector Word16 -> Word16 -> b -> b #
MVector MVector Word16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word16 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16 # basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word16) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word16 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m (MVector (PrimState m) Word16) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m Word16 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> Word16 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word16 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word16 -> Word16 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m (MVector (PrimState m) Word16) #
type NatNumMaxBound Word16
Instance details Defined in Basement.Nat type NatNumMaxBound Word16 = 65535
type Difference Word16
Instance details Defined in Basement.Numerical.Subtractive type Difference Word16 = Word16
type PrimSize Word16
Instance details Defined in Basement.PrimType type PrimSize Word16 = 2
type IntBaseType Word16
Instance details Defined in Data.IntCast type IntBaseType Word16 = 'FixedWordTag 16
type PrettyShow Word16
Instance details Defined in Morley.Prelude.Show type PrettyShow Word16 = ()
newtype Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word16 = V_Word16 (Vector Word16)
type ByteSink Word16 g
Instance details Defined in Data.UUID.Types.Internal.Builder type ByteSink Word16 g = Takes2Bytes g
newtype MVector s Word16
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word16 = MV_Word16 (MVector s Word16)

data Word32 #

32-bit unsigned integer type

Instances

Instances details

Structured Word32
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Word32 -> Structure # structureHash' :: Tagged Word32 MD5
FiniteBitsBase Word32
Instance details Defined in Data.Word.Odd Methods subWordClz :: Int -> Word32 -> Int # subWordCtz :: Int -> Word32 -> Int #
Bits Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word32 -> Word32 -> Word32 # (.\|.) :: Word32 -> Word32 -> Word32 # xor :: Word32 -> Word32 -> Word32 # complement :: Word32 -> Word32 # shift :: Word32 -> Int -> Word32 # rotate :: Word32 -> Int -> Word32 # zeroBits :: Word32 # bit :: Int -> Word32 # setBit :: Word32 -> Int -> Word32 # clearBit :: Word32 -> Int -> Word32 # complementBit :: Word32 -> Int -> Word32 # testBit :: Word32 -> Int -> Bool # bitSizeMaybe :: Word32 -> Maybe Int # bitSize :: Word32 -> Int # isSigned :: Word32 -> Bool # shiftL :: Word32 -> Int -> Word32 # unsafeShiftL :: Word32 -> Int -> Word32 # shiftR :: Word32 -> Int -> Word32 # unsafeShiftR :: Word32 -> Int -> Word32 # rotateL :: Word32 -> Int -> Word32 # rotateR :: Word32 -> Int -> Word32 # popCount :: Word32 -> Int #
FiniteBits Word32	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word32 -> Int # countLeadingZeros :: Word32 -> Int # countTrailingZeros :: Word32 -> Int #
Storable Word32	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word32 -> Int # alignment :: Word32 -> Int # peekElemOff :: Ptr Word32 -> Int -> IO Word32 # pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word32 # pokeByteOff :: Ptr b -> Int -> Word32 -> IO () # peek :: Ptr Word32 -> IO Word32 # poke :: Ptr Word32 -> Word32 -> IO () #
Bounded Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word32 # maxBound :: Word32 #
Enum Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Ix Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word32, Word32) -> [Word32] # index :: (Word32, Word32) -> Word32 -> Int # unsafeIndex :: (Word32, Word32) -> Word32 -> Int # inRange :: (Word32, Word32) -> Word32 -> Bool # rangeSize :: (Word32, Word32) -> Int # unsafeRangeSize :: (Word32, Word32) -> Int #
Num Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word32 -> Word32 -> Word32 # (-) :: Word32 -> Word32 -> Word32 # (*) :: Word32 -> Word32 -> Word32 # negate :: Word32 -> Word32 # abs :: Word32 -> Word32 # signum :: Word32 -> Word32 # fromInteger :: Integer -> Word32 #
Read Word32	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word32 # readList :: ReadS [Word32] # readPrec :: ReadPrec Word32 # readListPrec :: ReadPrec [Word32] #
Integral Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word32 -> Word32 -> Word32 # rem :: Word32 -> Word32 -> Word32 # div :: Word32 -> Word32 -> Word32 # mod :: Word32 -> Word32 -> Word32 # quotRem :: Word32 -> Word32 -> (Word32, Word32) # divMod :: Word32 -> Word32 -> (Word32, Word32) # toInteger :: Word32 -> Integer #
Real Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word32 -> Rational #
Show Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
BitOps Word32
Instance details Defined in Basement.Bits Methods (.&.) :: Word32 -> Word32 -> Word32 # (.\|.) :: Word32 -> Word32 -> Word32 # (.^.) :: Word32 -> Word32 -> Word32 # (.<<.) :: Word32 -> CountOf Bool -> Word32 # (.>>.) :: Word32 -> CountOf Bool -> Word32 # bit :: Offset Bool -> Word32 # isBitSet :: Word32 -> Offset Bool -> Bool # setBit :: Word32 -> Offset Bool -> Word32 # clearBit :: Word32 -> Offset Bool -> Word32 #
FiniteBitsOps Word32
Instance details Defined in Basement.Bits Methods numberOfBits :: Word32 -> CountOf Bool # rotateL :: Word32 -> CountOf Bool -> Word32 # rotateR :: Word32 -> CountOf Bool -> Word32 # popCount :: Word32 -> CountOf Bool # bitFlip :: Word32 -> Word32 # countLeadingZeros :: Word32 -> CountOf Bool # countTrailingZeros :: Word32 -> CountOf Bool #
Subtractive Word32
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Word32 # Methods (-) :: Word32 -> Word32 -> Difference Word32 #
PrimMemoryComparable Word32
Instance details Defined in Basement.PrimType
PrimType Word32
Instance details Defined in Basement.PrimType Associated Types type PrimSize Word32 :: Nat # Methods primSizeInBytes :: Proxy Word32 -> CountOf Word8 # primShiftToBytes :: Proxy Word32 -> Int # primBaUIndex :: ByteArray# -> Offset Word32 -> Word32 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> prim Word32 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word32 -> Word32 -> prim () # primAddrIndex :: Addr# -> Offset Word32 -> Word32 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word32 -> prim Word32 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word32 -> Word32 -> prim () #
Default Word32
Instance details Defined in Data.Default.Class Methods def :: Word32 #
NFData Word32
Instance details Defined in Control.DeepSeq Methods rnf :: Word32 -> () #
Buildable Word32
Instance details Defined in Formatting.Buildable Methods build :: Word32 -> Builder #
Eq Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Ord Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word32 -> Word32 -> Ordering # (<) :: Word32 -> Word32 -> Bool # (<=) :: Word32 -> Word32 -> Bool # (>) :: Word32 -> Word32 -> Bool # (>=) :: Word32 -> Word32 -> Bool # max :: Word32 -> Word32 -> Word32 # min :: Word32 -> Word32 -> Word32 #
Hashable Word32
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word32 -> Int # hash :: Word32 -> Int #
Uniform Word32
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word32 #
UniformRange Word32
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word32, Word32) -> g -> m Word32 #
Ring Word32
Instance details Defined in Data.Semiring Methods negate :: Word32 -> Word32 #
Semiring Word32
Instance details Defined in Data.Semiring Methods plus :: Word32 -> Word32 -> Word32 # zero :: Word32 # times :: Word32 -> Word32 -> Word32 # one :: Word32 # fromNatural :: Natural -> Word32 #
ByteSource Word32
Instance details Defined in Data.UUID.Types.Internal.Builder Methods (/-/) :: ByteSink Word32 g -> Word32 -> g
Unbox Word32
Instance details Defined in Data.Vector.Unboxed.Base
Lift Word32
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word32 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word32 -> Code m Word32 #
Vector Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> m (Vector Word32) # basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m (Mutable Vector (PrimState m) Word32) # basicLength :: Vector Word32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32 # basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> Vector Word32 -> m () # elemseq :: Vector Word32 -> Word32 -> b -> b #
MVector MVector Word32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word32 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32 # basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word32) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word32 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m (MVector (PrimState m) Word32) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m Word32 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> Word32 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word32 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word32 -> Word32 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m (MVector (PrimState m) Word32) #
type NatNumMaxBound Word32
Instance details Defined in Basement.Nat type NatNumMaxBound Word32 = 4294967295
type Difference Word32
Instance details Defined in Basement.Numerical.Subtractive type Difference Word32 = Word32
type PrimSize Word32
Instance details Defined in Basement.PrimType type PrimSize Word32 = 4
type IntBaseType Word32
Instance details Defined in Data.IntCast type IntBaseType Word32 = 'FixedWordTag 32
type PrettyShow Word32
Instance details Defined in Morley.Prelude.Show type PrettyShow Word32 = ()
newtype Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word32 = V_Word32 (Vector Word32)
type ByteSink Word32 g
Instance details Defined in Data.UUID.Types.Internal.Builder type ByteSink Word32 g = Takes4Bytes g
newtype MVector s Word32
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word32 = MV_Word32 (MVector s Word32)

data Word64 #

64-bit unsigned integer type

Instances

Instances details

Structured Word64
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Word64 -> Structure # structureHash' :: Tagged Word64 MD5
FiniteBitsBase Word64
Instance details Defined in Data.Word.Odd Methods subWordClz :: Int -> Word64 -> Int # subWordCtz :: Int -> Word64 -> Int #
Bits Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (.&.) :: Word64 -> Word64 -> Word64 # (.\|.) :: Word64 -> Word64 -> Word64 # xor :: Word64 -> Word64 -> Word64 # complement :: Word64 -> Word64 # shift :: Word64 -> Int -> Word64 # rotate :: Word64 -> Int -> Word64 # zeroBits :: Word64 # bit :: Int -> Word64 # setBit :: Word64 -> Int -> Word64 # clearBit :: Word64 -> Int -> Word64 # complementBit :: Word64 -> Int -> Word64 # testBit :: Word64 -> Int -> Bool # bitSizeMaybe :: Word64 -> Maybe Int # bitSize :: Word64 -> Int # isSigned :: Word64 -> Bool # shiftL :: Word64 -> Int -> Word64 # unsafeShiftL :: Word64 -> Int -> Word64 # shiftR :: Word64 -> Int -> Word64 # unsafeShiftR :: Word64 -> Int -> Word64 # rotateL :: Word64 -> Int -> Word64 # rotateR :: Word64 -> Int -> Word64 # popCount :: Word64 -> Int #
FiniteBits Word64	Since: base-4.6.0.0
Instance details Defined in GHC.Word Methods finiteBitSize :: Word64 -> Int # countLeadingZeros :: Word64 -> Int # countTrailingZeros :: Word64 -> Int #
Storable Word64	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Word64 -> Int # alignment :: Word64 -> Int # peekElemOff :: Ptr Word64 -> Int -> IO Word64 # pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word64 # pokeByteOff :: Ptr b -> Int -> Word64 -> IO () # peek :: Ptr Word64 -> IO Word64 # poke :: Ptr Word64 -> Word64 -> IO () #
Bounded Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word64 # maxBound :: Word64 #
Enum Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Ix Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods range :: (Word64, Word64) -> [Word64] # index :: (Word64, Word64) -> Word64 -> Int # unsafeIndex :: (Word64, Word64) -> Word64 -> Int # inRange :: (Word64, Word64) -> Word64 -> Bool # rangeSize :: (Word64, Word64) -> Int # unsafeRangeSize :: (Word64, Word64) -> Int #
Num Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Read Word64	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word64 # readList :: ReadS [Word64] # readPrec :: ReadPrec Word64 # readListPrec :: ReadPrec [Word64] #
Integral Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods quot :: Word64 -> Word64 -> Word64 # rem :: Word64 -> Word64 -> Word64 # div :: Word64 -> Word64 -> Word64 # mod :: Word64 -> Word64 -> Word64 # quotRem :: Word64 -> Word64 -> (Word64, Word64) # divMod :: Word64 -> Word64 -> (Word64, Word64) # toInteger :: Word64 -> Integer #
Real Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods toRational :: Word64 -> Rational #
Show Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
BitOps Word64
Instance details Defined in Basement.Bits Methods (.&.) :: Word64 -> Word64 -> Word64 # (.\|.) :: Word64 -> Word64 -> Word64 # (.^.) :: Word64 -> Word64 -> Word64 # (.<<.) :: Word64 -> CountOf Bool -> Word64 # (.>>.) :: Word64 -> CountOf Bool -> Word64 # bit :: Offset Bool -> Word64 # isBitSet :: Word64 -> Offset Bool -> Bool # setBit :: Word64 -> Offset Bool -> Word64 # clearBit :: Word64 -> Offset Bool -> Word64 #
FiniteBitsOps Word64
Instance details Defined in Basement.Bits Methods numberOfBits :: Word64 -> CountOf Bool # rotateL :: Word64 -> CountOf Bool -> Word64 # rotateR :: Word64 -> CountOf Bool -> Word64 # popCount :: Word64 -> CountOf Bool # bitFlip :: Word64 -> Word64 # countLeadingZeros :: Word64 -> CountOf Bool # countTrailingZeros :: Word64 -> CountOf Bool #
Subtractive Word64
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Word64 # Methods (-) :: Word64 -> Word64 -> Difference Word64 #
PrimMemoryComparable Word64
Instance details Defined in Basement.PrimType
PrimType Word64
Instance details Defined in Basement.PrimType Associated Types type PrimSize Word64 :: Nat # Methods primSizeInBytes :: Proxy Word64 -> CountOf Word8 # primShiftToBytes :: Proxy Word64 -> Int # primBaUIndex :: ByteArray# -> Offset Word64 -> Word64 # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> prim Word64 # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word64 -> Word64 -> prim () # primAddrIndex :: Addr# -> Offset Word64 -> Word64 # primAddrRead :: PrimMonad prim => Addr# -> Offset Word64 -> prim Word64 # primAddrWrite :: PrimMonad prim => Addr# -> Offset Word64 -> Word64 -> prim () #
Default Word64
Instance details Defined in Data.Default.Class Methods def :: Word64 #
NFData Word64
Instance details Defined in Control.DeepSeq Methods rnf :: Word64 -> () #
Buildable Word64
Instance details Defined in Formatting.Buildable Methods build :: Word64 -> Builder #
Eq Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Ord Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods compare :: Word64 -> Word64 -> Ordering # (<) :: Word64 -> Word64 -> Bool # (<=) :: Word64 -> Word64 -> Bool # (>) :: Word64 -> Word64 -> Bool # (>=) :: Word64 -> Word64 -> Bool # max :: Word64 -> Word64 -> Word64 # min :: Word64 -> Word64 -> Word64 #
Hashable Word64
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word64 -> Int # hash :: Word64 -> Int #
Uniform Word64
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word64 #
UniformRange Word64
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word64, Word64) -> g -> m Word64 #
Ring Word64
Instance details Defined in Data.Semiring Methods negate :: Word64 -> Word64 #
Semiring Word64
Instance details Defined in Data.Semiring Methods plus :: Word64 -> Word64 -> Word64 # zero :: Word64 # times :: Word64 -> Word64 -> Word64 # one :: Word64 # fromNatural :: Natural -> Word64 #
ByteSource Word64
Instance details Defined in Data.UUID.Types.Internal.Builder Methods (/-/) :: ByteSink Word64 g -> Word64 -> g
Unbox Word64
Instance details Defined in Data.Vector.Unboxed.Base
Lift Word64
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word64 -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word64 -> Code m Word64 #
Vector Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> m (Vector Word64) # basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m (Mutable Vector (PrimState m) Word64) # basicLength :: Vector Word64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64 # basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> Vector Word64 -> m () # elemseq :: Vector Word64 -> Word64 -> b -> b #
MVector MVector Word64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word64 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64 # basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word64) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word64 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m (MVector (PrimState m) Word64) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m Word64 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> Word64 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word64 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word64 -> Word64 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m (MVector (PrimState m) Word64) #
type NatNumMaxBound Word64
Instance details Defined in Basement.Nat type NatNumMaxBound Word64 = 18446744073709551615
type Difference Word64
Instance details Defined in Basement.Numerical.Subtractive type Difference Word64 = Word64
type PrimSize Word64
Instance details Defined in Basement.PrimType type PrimSize Word64 = 8
type IntBaseType Word62
Instance details Defined in Morley.Prelude.Word type IntBaseType Word62 = 'FixedWordTag 62
type IntBaseType Word63
Instance details Defined in Morley.Prelude.Word type IntBaseType Word63 = 'FixedWordTag 63
type IntBaseType Word64
Instance details Defined in Data.IntCast type IntBaseType Word64 = 'FixedWordTag 64
type PrettyShow Word62
Instance details Defined in Morley.Prelude.Show type PrettyShow Word62 = ()
type PrettyShow Word63
Instance details Defined in Morley.Prelude.Show type PrettyShow Word63 = ()
type PrettyShow Word64
Instance details Defined in Morley.Prelude.Show type PrettyShow Word64 = ()
newtype Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word64 = V_Word64 (Vector Word64)
type ByteSink Word64 g
Instance details Defined in Data.UUID.Types.Internal.Builder type ByteSink Word64 g = Takes8Bytes g
newtype MVector s Word64
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word64 = MV_Word64 (MVector s Word64)

data Ptr a #

A value of type Ptr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a.

The type a will often be an instance of class Storable which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct.

Instances

Instances details

NFData1 Ptr	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Ptr a -> () #
Generic1 (URec (Ptr ()) :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec (Ptr ())) :: k -> Type # Methods from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a # to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a #
Foldable (UAddr :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m # foldMap :: Monoid m => (a -> m) -> UAddr a -> m # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m # foldr :: (a -> b -> b) -> b -> UAddr a -> b # foldr' :: (a -> b -> b) -> b -> UAddr a -> b # foldl :: (b -> a -> b) -> b -> UAddr a -> b # foldl' :: (b -> a -> b) -> b -> UAddr a -> b # foldr1 :: (a -> a -> a) -> UAddr a -> a # foldl1 :: (a -> a -> a) -> UAddr a -> a # toList :: UAddr a -> [a] # null :: UAddr a -> Bool # length :: UAddr a -> Int # elem :: Eq a => a -> UAddr a -> Bool # maximum :: Ord a => UAddr a -> a # minimum :: Ord a => UAddr a -> a # sum :: Num a => UAddr a -> a # product :: Num a => UAddr a -> a #
Traversable (UAddr :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b) # sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a) # mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b) # sequence :: Monad m => UAddr (m a) -> m (UAddr a) #
Storable (Ptr a)	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Ptr a -> Int # alignment :: Ptr a -> Int # peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a) # pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Ptr a) # pokeByteOff :: Ptr b -> Int -> Ptr a -> IO () # peek :: Ptr (Ptr a) -> IO (Ptr a) # poke :: Ptr (Ptr a) -> Ptr a -> IO () #
Show (Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> Ptr a -> ShowS # show :: Ptr a -> String # showList :: [Ptr a] -> ShowS #
NFData (Ptr a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Ptr a -> () #
Buildable (Ptr a)
Instance details Defined in Formatting.Buildable Methods build :: Ptr a -> Builder #
Eq (Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods (==) :: Ptr a -> Ptr a -> Bool # (/=) :: Ptr a -> Ptr a -> Bool #
Ord (Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods compare :: Ptr a -> Ptr a -> Ordering # (<) :: Ptr a -> Ptr a -> Bool # (<=) :: Ptr a -> Ptr a -> Bool # (>) :: Ptr a -> Ptr a -> Bool # (>=) :: Ptr a -> Ptr a -> Bool # max :: Ptr a -> Ptr a -> Ptr a # min :: Ptr a -> Ptr a -> Ptr a #
Hashable (Ptr a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ptr a -> Int # hash :: Ptr a -> Int #
Functor (URec (Ptr ()) :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a #
Generic (URec (Ptr ()) p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p #
Eq (URec (Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #
Ord (URec (Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p #
data URec (Ptr ()) (p :: k)	Used for marking occurrences of `Addr#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec (Ptr ()) (p :: k) = UAddr { uAddr# :: Addr# }
type Rep1 (URec (Ptr ()) :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec (Ptr ()) :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: k -> Type)))
type Rep (URec (Ptr ()) p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec (Ptr ()) p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: Type -> Type)))

data FunPtr a #

A value of type FunPtr a is a pointer to a function callable from foreign code. The type a will normally be a foreign type, a function type with zero or more arguments where

the argument types are marshallable foreign types, i.e. Char, Int, Double, Float, Bool, Int8, Int16, Int32, Int64, Word8, Word16, Word32, Word64, Ptr a, FunPtr a, StablePtr a or a renaming of any of these using newtype.
the return type is either a marshallable foreign type or has the form IO t where t is a marshallable foreign type or ().

A value of type FunPtr a may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like

foreign import ccall "stdlib.h &free"
  p_free :: FunPtr (Ptr a -> IO ())

or a pointer to a Haskell function created using a wrapper stub declared to produce a FunPtr of the correct type. For example:

type Compare = Int -> Int -> Bool
foreign import ccall "wrapper"
  mkCompare :: Compare -> IO (FunPtr Compare)

Calls to wrapper stubs like mkCompare allocate storage, which should be released with freeHaskellFunPtr when no longer required.

To convert FunPtr values to corresponding Haskell functions, one can define a dynamic stub for the specific foreign type, e.g.

type IntFunction = CInt -> IO ()
foreign import ccall "dynamic"
  mkFun :: FunPtr IntFunction -> IntFunction

Instances

Instances details

NFData1 FunPtr	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> FunPtr a -> () #
Storable (FunPtr a)	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: FunPtr a -> Int # alignment :: FunPtr a -> Int # peekElemOff :: Ptr (FunPtr a) -> Int -> IO (FunPtr a) # pokeElemOff :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO () # peekByteOff :: Ptr b -> Int -> IO (FunPtr a) # pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO () # peek :: Ptr (FunPtr a) -> IO (FunPtr a) # poke :: Ptr (FunPtr a) -> FunPtr a -> IO () #
Show (FunPtr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> FunPtr a -> ShowS # show :: FunPtr a -> String # showList :: [FunPtr a] -> ShowS #
NFData (FunPtr a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: FunPtr a -> () #
Eq (FunPtr a)
Instance details Defined in GHC.Ptr Methods (==) :: FunPtr a -> FunPtr a -> Bool # (/=) :: FunPtr a -> FunPtr a -> Bool #
Ord (FunPtr a)
Instance details Defined in GHC.Ptr Methods compare :: FunPtr a -> FunPtr a -> Ordering # (<) :: FunPtr a -> FunPtr a -> Bool # (<=) :: FunPtr a -> FunPtr a -> Bool # (>) :: FunPtr a -> FunPtr a -> Bool # (>=) :: FunPtr a -> FunPtr a -> Bool # max :: FunPtr a -> FunPtr a -> FunPtr a # min :: FunPtr a -> FunPtr a -> FunPtr a #
Hashable (FunPtr a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> FunPtr a -> Int # hash :: FunPtr a -> Int #

data Either a b #

The Either type represents values with two possibilities: a value of type Either a b is either Left a or Right b.

The Either type is sometimes used to represent a value which is either correct or an error; by convention, the Left constructor is used to hold an error value and the Right constructor is used to hold a correct value (mnemonic: "right" also means "correct").

Examples

Expand

The type Either String Int is the type of values which can be either a String or an Int. The Left constructor can be used only on Strings, and the Right constructor can be used only on Ints:

>>> let s = Left "foo" :: Either String Int
>>> s
Left "foo"
>>> let n = Right 3 :: Either String Int
>>> n
Right 3
>>> :type s
s :: Either String Int
>>> :type n
n :: Either String Int

The fmap from our Functor instance will ignore Left values, but will apply the supplied function to values contained in a Right:

>>> let s = Left "foo" :: Either String Int
>>> let n = Right 3 :: Either String Int
>>> fmap (*2) s
Left "foo"
>>> fmap (*2) n
Right 6

The Monad instance for Either allows us to chain together multiple actions which may fail, and fail overall if any of the individual steps failed. First we'll write a function that can either parse an Int from a Char, or fail.

>>> import Data.Char ( digitToInt, isDigit )
>>> :{
    let parseEither :: Char -> Either String Int
        parseEither c
          | isDigit c = Right (digitToInt c)
          | otherwise = Left "parse error"
>>> :}

The following should work, since both '1' and '2' can be parsed as Ints.

>>> :{
    let parseMultiple :: Either String Int
        parseMultiple = do
          x <- parseEither '1'
          y <- parseEither '2'
          return (x + y)
>>> :}

>>> parseMultiple
Right 3

But the following should fail overall, since the first operation where we attempt to parse 'm' as an Int will fail:

>>> :{
    let parseMultiple :: Either String Int
        parseMultiple = do
          x <- parseEither 'm'
          y <- parseEither '2'
          return (x + y)
>>> :}

>>> parseMultiple
Left "parse error"

Constructors

Left a
Right b

Instances

Instances details

Bifunctor Either	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d # first :: (a -> b) -> Either a c -> Either b c # second :: (b -> c) -> Either a b -> Either a c #
NFData2 Either	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> Either a b -> () #
Hashable2 Either
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Either a b -> Int #
() :=> (Applicative (Either a))
Instance details Defined in Data.Constraint Methods ins :: () :- Applicative (Either a) #
() :=> (Functor (Either a))
Instance details Defined in Data.Constraint Methods ins :: () :- Functor (Either a) #
() :=> (Monad (Either a))
Instance details Defined in Data.Constraint Methods ins :: () :- Monad (Either a) #
MonadError e (Either e)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> Either e a # catchError :: Either e a -> (e -> Either e a) -> Either e a #
(Lift a, Lift b) => Lift (Either a b :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Either a b -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Either a b -> Code m (Either a b) #
Foldable (Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m # foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # toList :: Either a a0 -> [a0] # null :: Either a a0 -> Bool # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # sum :: Num a0 => Either a a0 -> a0 # product :: Num a0 => Either a a0 -> a0 #
Traversable (Either a)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a0 -> f b) -> Either a a0 -> f (Either a b) # sequenceA :: Applicative f => Either a (f a0) -> f (Either a a0) # mapM :: Monad m => (a0 -> m b) -> Either a a0 -> m (Either a b) # sequence :: Monad m => Either a (m a0) -> m (Either a a0) #
Applicative (Either e)	Since: base-3.0
Instance details Defined in Data.Either Methods pure :: a -> Either e a # (<>) :: Either e (a -> b) -> Either e a -> Either e b # liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c # (>) :: Either e a -> Either e b -> Either e b # (<*) :: Either e a -> Either e b -> Either e a #
Functor (Either a)	Since: base-3.0
Instance details Defined in Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Monad (Either e)	Since: base-4.4.0.0
Instance details Defined in Data.Either Methods (>>=) :: Either e a -> (a -> Either e b) -> Either e b # (>>) :: Either e a -> Either e b -> Either e b # return :: a -> Either e a #
MonadFailure (Either a)
Instance details Defined in Basement.Monad Associated Types type Failure (Either a) # Methods mFail :: Failure (Either a) -> Either a () #
NFData a => NFData1 (Either a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a0 -> ()) -> Either a a0 -> () #
e ~ SomeException => MonadCatch (Either e)	Since: exceptions-0.8.3
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e0 => Either e a -> (e0 -> Either e a) -> Either e a #
e ~ SomeException => MonadMask (Either e)	Since: exceptions-0.8.3
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b # uninterruptibleMask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b # generalBracket :: Either e a -> (a -> ExitCase b -> Either e c) -> (a -> Either e b) -> Either e (b, c) #
e ~ SomeException => MonadThrow (Either e)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e0 => e0 -> Either e a #
Hashable a => Hashable1 (Either a)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a0 -> Int) -> Int -> Either a a0 -> Int #
PApplicative (Either e)
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type Pure arg :: f a # type arg <> arg1 :: f b # type LiftA2 arg arg1 arg2 :: f c # type arg > arg1 :: f b # type arg <* arg1 :: f a #
PFunctor (Either a)
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type Fmap arg arg1 :: f b # type arg <$ arg1 :: f a #
PMonad (Either e)
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type arg >>= arg1 :: m b # type arg >> arg1 :: m b # type Return arg :: m a #
SApplicative (Either e)
Instance details Defined in Control.Monad.Singletons.Internal Methods sPure :: forall a (t :: a). Sing t -> Sing (Apply PureSym0 t) # (%<>) :: forall a b (t1 :: Either e (a ~> b)) (t2 :: Either e a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sLiftA2 :: forall a b c (t1 :: a ~> (b ~> c)) (t2 :: Either e a) (t3 :: Either e b). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply LiftA2Sym0 t1) t2) t3) # (%>) :: forall a b (t1 :: Either e a) (t2 :: Either e b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%<) :: forall a b (t1 :: Either e a) (t2 :: Either e b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) #
SFunctor (Either a)
Instance details Defined in Control.Monad.Singletons.Internal Methods sFmap :: forall a0 b (t1 :: a0 ~> b) (t2 :: Either a a0). Sing t1 -> Sing t2 -> Sing (Apply (Apply FmapSym0 t1) t2) # (%<$) :: forall a0 b (t1 :: a0) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<$@#@$) t1) t2) #
SMonad (Either e)
Instance details Defined in Control.Monad.Singletons.Internal Methods (%>>=) :: forall a b (t1 :: Either e a) (t2 :: a ~> Either e b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>>=@#@$) t1) t2) # (%>>) :: forall a b (t1 :: Either e a) (t2 :: Either e b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>>@#@$) t1) t2) # sReturn :: forall a (t :: a). Sing t -> Sing (Apply ReturnSym0 t) #
PFoldable (Either a)
Instance details Defined in Data.Foldable.Singletons Associated Types type Fold arg :: m # type FoldMap arg arg1 :: m # type Foldr arg arg1 arg2 :: b # type Foldr' arg arg1 arg2 :: b # type Foldl arg arg1 arg2 :: b # type Foldl' arg arg1 arg2 :: b # type Foldr1 arg arg1 :: a # type Foldl1 arg arg1 :: a # type ToList arg :: [a] # type Null arg :: Bool # type Length arg :: Nat # type Elem arg arg1 :: Bool # type Maximum arg :: a # type Minimum arg :: a # type Sum arg :: a # type Product arg :: a #
SFoldable (Either a)
Instance details Defined in Data.Foldable.Singletons Methods sFold :: forall m (t1 :: Either a m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a0 m (t1 :: a0 ~> m) (t2 :: Either a a0). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a0 b (t1 :: a0 ~> (b ~> b)) (t2 :: b) (t3 :: Either a a0). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a0 b (t1 :: a0 ~> (b ~> b)) (t2 :: b) (t3 :: Either a a0). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a0 (t1 :: b ~> (a0 ~> b)) (t2 :: b) (t3 :: Either a a0). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a0 (t1 :: b ~> (a0 ~> b)) (t2 :: b) (t3 :: Either a a0). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a0 (t1 :: a0 ~> (a0 ~> a0)) (t2 :: Either a a0). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a0 (t1 :: a0 ~> (a0 ~> a0)) (t2 :: Either a a0). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a0 (t1 :: Either a a0). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a0 (t1 :: Either a a0). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a0 (t1 :: Either a a0). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a0 (t1 :: a0) (t2 :: Either a a0). SEq a0 => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a0 (t1 :: Either a a0). SOrd a0 => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a0 (t1 :: Either a a0). SOrd a0 => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a0 (t1 :: Either a a0). SNum a0 => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a0 (t1 :: Either a a0). SNum a0 => Sing t1 -> Sing (Apply ProductSym0 t1) #
PTraversable (Either a)
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable (Either a)
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a0 (f :: Type -> Type) b (t1 :: a0 ~> f b) (t2 :: Either a a0). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a0 (t1 :: Either a (f a0)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a0 (m :: Type -> Type) b (t1 :: a0 ~> m b) (t2 :: Either a a0). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a0 (t1 :: Either a (m a0)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) #
KnownValue a => LorentzFunctor (Either a) a b
Instance details Defined in Lorentz.Instr Methods lmap :: forall (s :: [Type]). KnownValue b => ('[a] :-> '[b]) -> (Either a a ': s) :-> (Either a b ': s) #
Generic1 (Either a :: Type -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (Either a) :: k -> Type # Methods from1 :: forall (a0 :: k). Either a a0 -> Rep1 (Either a) a0 # to1 :: forall (a0 :: k). Rep1 (Either a) a0 -> Either a a0 #
IsoHKD (Either a :: Type -> Type) (b :: Type)
Instance details Defined in Data.Vinyl.XRec Associated Types type HKD (Either a) b # Methods unHKD :: HKD (Either a) b -> Either a b # toHKD :: Either a b -> HKD (Either a) b #
(CanCastTo l1 l2, CanCastTo r1 r2) => CanCastTo (Either l1 r1 :: Type) (Either l2 r2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Either l1 r1) -> Proxy (Either l2 r2) -> () #
(Structured a, Structured b) => Structured (Either a b)
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy (Either a b) -> Structure # structureHash' :: Tagged (Either a b) MD5
Semigroup (Either a b)	Since: base-4.9.0.0
Instance details Defined in Data.Either Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b0 => b0 -> Either a b -> Either a b #
Generic (Either a b)
Instance details Defined in GHC.Generics Associated Types type Rep (Either a b) :: Type -> Type # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
(Read a, Read b) => Read (Either a b)	Since: base-3.0
Instance details Defined in Data.Either Methods readsPrec :: Int -> ReadS (Either a b) # readList :: ReadS [Either a b] # readPrec :: ReadPrec (Either a b) # readListPrec :: ReadPrec [Either a b] #
(Show a, Show b) => Show (Either a b)	Since: base-3.0
Instance details Defined in Data.Either Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
(NFData a, NFData b) => NFData (Either a b)
Instance details Defined in Control.DeepSeq Methods rnf :: Either a b -> () #
(Eq a, Eq b) => Eq (Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
(Ord a, Ord b) => Ord (Either a b)	Since: base-2.1
Instance details Defined in Data.Either Methods compare :: Either a b -> Either a b -> Ordering # (<) :: Either a b -> Either a b -> Bool # (<=) :: Either a b -> Either a b -> Bool # (>) :: Either a b -> Either a b -> Bool # (>=) :: Either a b -> Either a b -> Bool # max :: Either a b -> Either a b -> Either a b # min :: Either a b -> Either a b -> Either a b #
(Hashable a, Hashable b) => Hashable (Either a b)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Either a b -> Int # hash :: Either a b -> Int #
(HasAnnotation a, HasAnnotation b) => HasAnnotation (Either a b)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Either a b)) # annOptions :: Maybe AnnOptions #
(HasRPCRepr l, HasRPCRepr r) => HasRPCRepr (Either l r)
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (Either l r) #
PolyTypeHasDocC '[l, r] => TypeHasDoc (Either l r)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Either l r) :: FieldDescriptions # Methods typeDocName :: Proxy (Either l r) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Either l r) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Either l r) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Either l r) # typeDocMichelsonRep :: TypeDocMichelsonRep (Either l r) #
(IsoValue l, IsoValue r) => IsoValue (Either l r)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Either l r) :: T # Methods toVal :: Either l r -> Value (ToT (Either l r)) # fromVal :: Value (ToT (Either l r)) -> Either l r #
PEq (Either a b)
Instance details Defined in Data.Eq.Singletons Associated Types type arg == arg1 :: Bool # type arg /= arg1 :: Bool #
(SEq a, SEq b) => SEq (Either a b)
Instance details Defined in Data.Eq.Singletons Methods (%==) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (==@#@$) t1) t2) # (%/=) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (/=@#@$) t1) t2) #
POrd (Either a b)
Instance details Defined in Data.Ord.Singletons Associated Types type Compare arg arg1 :: Ordering # type arg < arg1 :: Bool # type arg <= arg1 :: Bool # type arg > arg1 :: Bool # type arg >= arg1 :: Bool # type Max arg arg1 :: a # type Min arg arg1 :: a #
(SOrd a, SOrd b) => SOrd (Either a b)
Instance details Defined in Data.Ord.Singletons Methods sCompare :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2) # (%<) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) # (%<=) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2) # (%>) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%>=) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2) # sMax :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2) # sMin :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2) #
PSemigroup (Either a b)
Instance details Defined in Data.Semigroup.Singletons.Internal Associated Types type arg <> arg1 :: a # type Sconcat arg :: a #
SSemigroup (Either a b)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods (%<>) :: forall (t1 :: Either a b) (t2 :: Either a b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sSconcat :: forall (t :: NonEmpty (Either a b)). Sing t -> Sing (Apply SconcatSym0 t) #
PShow (Either a b)
Instance details Defined in Text.Show.Singletons Associated Types type ShowsPrec arg arg1 arg2 :: Symbol # type Show_ arg :: Symbol # type ShowList arg arg1 :: Symbol #
(SShow a, SShow b) => SShow (Either a b)
Instance details Defined in Text.Show.Singletons Methods sShowsPrec :: forall (t1 :: Nat) (t2 :: Either a b) (t3 :: Symbol). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3) # sShow_ :: forall (t :: Either a b). Sing t -> Sing (Apply Show_Sym0 t) # sShowList :: forall (t1 :: [Either a b]) (t2 :: Symbol). Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2) #
(TypeError (DisallowInstance "Either") :: Constraint) => Container (Either a b)
Instance details Defined in Universum.Container.Class Associated Types type Element (Either a b) # Methods toList :: Either a b -> [Element (Either a b)] # null :: Either a b -> Bool # foldr :: (Element (Either a b) -> b0 -> b0) -> b0 -> Either a b -> b0 # foldl :: (b0 -> Element (Either a b) -> b0) -> b0 -> Either a b -> b0 # foldl' :: (b0 -> Element (Either a b) -> b0) -> b0 -> Either a b -> b0 # length :: Either a b -> Int # elem :: Element (Either a b) -> Either a b -> Bool # foldMap :: Monoid m => (Element (Either a b) -> m) -> Either a b -> m # fold :: Either a b -> Element (Either a b) # foldr' :: (Element (Either a b) -> b0 -> b0) -> b0 -> Either a b -> b0 # notElem :: Element (Either a b) -> Either a b -> Bool # all :: (Element (Either a b) -> Bool) -> Either a b -> Bool # any :: (Element (Either a b) -> Bool) -> Either a b -> Bool # and :: Either a b -> Bool # or :: Either a b -> Bool # find :: (Element (Either a b) -> Bool) -> Either a b -> Maybe (Element (Either a b)) # safeHead :: Either a b -> Maybe (Element (Either a b)) # safeMaximum :: Either a b -> Maybe (Element (Either a b)) # safeMinimum :: Either a b -> Maybe (Element (Either a b)) # safeFoldr1 :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Maybe (Element (Either a b)) # safeFoldl1 :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Maybe (Element (Either a b)) #
(Read a, Read b) :=> (Read (Either a b))
Instance details Defined in Data.Constraint Methods ins :: (Read a, Read b) :- Read (Either a b) #
(Show a, Show b) :=> (Show (Either a b))
Instance details Defined in Data.Constraint Methods ins :: (Show a, Show b) :- Show (Either a b) #
(Eq a, Eq b) :=> (Eq (Either a b))
Instance details Defined in Data.Constraint Methods ins :: (Eq a, Eq b) :- Eq (Either a b) #
(Ord a, Ord b) :=> (Ord (Either a b))
Instance details Defined in Data.Constraint Methods ins :: (Ord a, Ord b) :- Ord (Either a b) #
(SDecide a, SDecide b) => TestCoercion (SEither :: Either a b -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods testCoercion :: forall (a0 :: k) (b0 :: k). SEither a0 -> SEither b0 -> Maybe (Coercion a0 b0) #
(SDecide a, SDecide b) => TestEquality (SEither :: Either a b -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods testEquality :: forall (a0 :: k) (b0 :: k). SEither a0 -> SEither b0 -> Maybe (a0 :~: b0) #
SingI (IsLeftSym0 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing IsLeftSym0 #
SingI (IsRightSym0 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing IsRightSym0 #
SingI (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing PartitionEithersSym0 #
SingI (LeftsSym0 :: TyFun [Either a b] [a] -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing LeftsSym0 #
SingI (RightsSym0 :: TyFun [Either a b] [b] -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing RightsSym0 #
SingI (LeftSym0 :: TyFun a (Either a b) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing LeftSym0 #
SingI (RightSym0 :: TyFun b (Either a b) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing RightSym0 #
SuppressUnusedWarnings (TFHelper_6989586621679584152Sym0 :: TyFun (Either a b) (Either a b ~> Either a b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181415Sym0 :: TyFun (Either a b) (Either a b ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130594Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsLeftSym0 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Either.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IsRightSym0 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Either.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680194155Sym0 :: TyFun (Either a1 a2) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Length_6989586621680194149Sym0 :: TyFun (Either a1 a2) Nat -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680071774Sym0 :: TyFun Nat (Either a b ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> Type)
Instance details Defined in Data.Either.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LeftsSym0 :: TyFun [Either a b] [a] -> Type)
Instance details Defined in Data.Either.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (RightsSym0 :: TyFun [Either a b] [b] -> Type)
Instance details Defined in Data.Either.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LeftSym0 :: TyFun a (Either a b) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621679357611Sym0 :: TyFun a (Either e a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (RightSym0 :: TyFun b (Either a b) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679584161ASym0 :: TyFun k1 (Either a k1) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
(a ~ a', b ~ b') => Each (Either a a') (Either b b') a b	Since: microlens-0.4.11
Instance details Defined in Lens.Micro.Internal Methods each :: Traversal (Either a a') (Either b b') a b #
SingI (Either_Sym0 :: TyFun (a ~> c) ((b ~> c) ~> (Either a b ~> c)) -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing Either_Sym0 #
SuppressUnusedWarnings (TFHelper_6989586621679584152Sym1 a6989586621679584157 :: TyFun (Either a b) (Either a b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181415Sym1 a6989586621679181420 :: TyFun (Either a b) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680071774Sym1 a6989586621680071784 :: TyFun (Either a b) (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130594Sym1 a6989586621679130599 :: TyFun (Either a b) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357621Sym0 :: TyFun (Either e (a ~> b)) (Either e a ~> Either e b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357705Sym0 :: TyFun (Either e a) ((a ~> Either e b) ~> Either e b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Either_Sym0 :: TyFun (a ~> c) ((b ~> c) ~> (Either a b ~> c)) -> Type)
Instance details Defined in Data.Either.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194135Sym0 :: TyFun (a1 ~> (b ~> b)) (b ~> (Either a2 a1 ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679357422Sym0 :: TyFun (a1 ~> b) (Either a2 a1 ~> Either a2 b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194123Sym0 :: TyFun (a1 ~> m) (Either a2 a1 ~> m) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357439Sym0 :: TyFun a1 (Either a2 b ~> Either a2 a1) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SingI d => SingI (Either_Sym1 d :: TyFun (b ~> c) (Either a b ~> c) -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing (Either_Sym1 d) #
SuppressUnusedWarnings (Fmap_6989586621679357422Sym1 a6989586621679357427 :: TyFun (Either a2 a1) (Either a2 b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194123Sym1 a6989586621680194128 :: TyFun (Either a2 a1) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357439Sym1 a6989586621679357444 :: TyFun (Either a2 b) (Either a2 a1) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357621Sym1 a6989586621679357626 :: TyFun (Either e a) (Either e b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357705Sym1 a6989586621679357710 :: TyFun (a ~> Either e b) (Either e b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478703Sym0 :: TyFun (a1 ~> f b) (Either a2 a1 ~> f (Either a2 b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Either_Sym1 a6989586621679275170 :: TyFun (b ~> c) (Either a b ~> c) -> Type)
Instance details Defined in Data.Either.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194135Sym1 a6989586621680194141 :: TyFun b (Either a2 a1 ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
(SingI d1, SingI d2) => SingI (Either_Sym2 d1 d2 :: TyFun (Either a b) c -> Type)
Instance details Defined in Data.Either.Singletons Methods sing :: Sing (Either_Sym2 d1 d2) #
SuppressUnusedWarnings (Either_Sym2 a6989586621679275170 a6989586621679275171 :: TyFun (Either a b) c -> Type)
Instance details Defined in Data.Either.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194135Sym2 a6989586621680194141 a6989586621680194142 :: TyFun (Either a2 a1) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478703Sym1 a6989586621680478708 :: TyFun (Either a2 a1) (f (Either a2 b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
(Functor f, Functor g) => Functor (Lift Either f g)
Instance details Defined in Data.Vinyl.Functor Methods fmap :: (a -> b) -> Lift Either f g a -> Lift Either f g b # (<$) :: a -> Lift Either f g b -> Lift Either f g a #
type MapM (arg1 :: a1 ~> m b) (arg2 :: Either a2 a1)
Instance details Defined in Data.Traversable.Singletons type MapM (arg1 :: a1 ~> m b) (arg2 :: Either a2 a1) = Apply (Apply (MapM_6989586621680471103Sym0 :: TyFun (a1 ~> m b) (Either a2 a1 ~> m (Either a2 b)) -> Type) arg1) arg2
type Traverse (a3 :: a1 ~> f b) (a4 :: Either a2 a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a3 :: a1 ~> f b) (a4 :: Either a2 a1) = Apply (Apply (Traverse_6989586621680478703Sym0 :: TyFun (a1 ~> f b) (Either a2 a1 ~> f (Either a2 b)) -> Type) a3) a4
type LiftA2 (arg1 :: a ~> (b ~> c)) (arg2 :: Either e a) (arg3 :: Either e b)
Instance details Defined in Control.Monad.Singletons.Internal type LiftA2 (arg1 :: a ~> (b ~> c)) (arg2 :: Either e a) (arg3 :: Either e b) = Apply (Apply (Apply (LiftA2_6989586621679287093Sym0 :: TyFun (a ~> (b ~> c)) (Either e a ~> (Either e b ~> Either e c)) -> Type) arg1) arg2) arg3
type Fmap (a3 :: a1 ~> b) (a4 :: Either a2 a1)
Instance details Defined in Control.Monad.Singletons.Internal type Fmap (a3 :: a1 ~> b) (a4 :: Either a2 a1) = Apply (Apply (Fmap_6989586621679357422Sym0 :: TyFun (a1 ~> b) (Either a2 a1 ~> Either a2 b) -> Type) a3) a4
type FoldMap (a3 :: a1 ~> k2) (a4 :: Either a2 a1)
Instance details Defined in Data.Foldable.Singletons type FoldMap (a3 :: a1 ~> k2) (a4 :: Either a2 a1) = Apply (Apply (FoldMap_6989586621680194123Sym0 :: TyFun (a1 ~> k2) (Either a2 a1 ~> k2) -> Type) a3) a4
type Foldl (arg1 :: b ~> (a1 ~> b)) (arg2 :: b) (arg3 :: Either a2 a1)
Instance details Defined in Data.Foldable.Singletons type Foldl (arg1 :: b ~> (a1 ~> b)) (arg2 :: b) (arg3 :: Either a2 a1) = Apply (Apply (Apply (Foldl_6989586621680193627Sym0 :: TyFun (b ~> (a1 ~> b)) (b ~> (Either a2 a1 ~> b)) -> Type) arg1) arg2) arg3
type Foldl' (arg1 :: b ~> (a1 ~> b)) (arg2 :: b) (arg3 :: Either a2 a1)
Instance details Defined in Data.Foldable.Singletons type Foldl' (arg1 :: b ~> (a1 ~> b)) (arg2 :: b) (arg3 :: Either a2 a1) = Apply (Apply (Apply (Foldl'_6989586621680193642Sym0 :: TyFun (b ~> (a1 ~> b)) (b ~> (Either a2 a1 ~> b)) -> Type) arg1) arg2) arg3
type Foldr (a3 :: a1 ~> (k2 ~> k2)) (a4 :: k2) (a5 :: Either a2 a1)
Instance details Defined in Data.Foldable.Singletons type Foldr (a3 :: a1 ~> (k2 ~> k2)) (a4 :: k2) (a5 :: Either a2 a1) = Apply (Apply (Apply (Foldr_6989586621680194135Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Either a2 a1 ~> k2)) -> Type) a3) a4) a5
type Foldr' (arg1 :: a1 ~> (b ~> b)) (arg2 :: b) (arg3 :: Either a2 a1)
Instance details Defined in Data.Foldable.Singletons type Foldr' (arg1 :: a1 ~> (b ~> b)) (arg2 :: b) (arg3 :: Either a2 a1) = Apply (Apply (Apply (Foldr'_6989586621680193604Sym0 :: TyFun (a1 ~> (b ~> b)) (b ~> (Either a2 a1 ~> b)) -> Type) arg1) arg2) arg3
type Pure (a :: k1)
Instance details Defined in Control.Monad.Singletons.Internal type Pure (a :: k1) = Apply (Pure_6989586621679357611Sym0 :: TyFun k1 (Either e k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Control.Monad.Singletons.Internal type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (Either e a) -> Type) arg
type Elem (arg1 :: a1) (arg2 :: Either a2 a1)
Instance details Defined in Data.Foldable.Singletons type Elem (arg1 :: a1) (arg2 :: Either a2 a1) = Apply (Apply (Elem_6989586621680193750Sym0 :: TyFun a1 (Either a2 a1 ~> Bool) -> Type) arg1) arg2
type Foldl1 (arg1 :: a1 ~> (a1 ~> a1)) (arg2 :: Either a2 a1)
Instance details Defined in Data.Foldable.Singletons type Foldl1 (arg1 :: a1 ~> (a1 ~> a1)) (arg2 :: Either a2 a1) = Apply (Apply (Foldl1_6989586621680193685Sym0 :: TyFun (a1 ~> (a1 ~> a1)) (Either a2 a1 ~> a1) -> Type) arg1) arg2
type Foldr1 (arg1 :: a1 ~> (a1 ~> a1)) (arg2 :: Either a2 a1)
Instance details Defined in Data.Foldable.Singletons type Foldr1 (arg1 :: a1 ~> (a1 ~> a1)) (arg2 :: Either a2 a1) = Apply (Apply (Foldr1_6989586621680193664Sym0 :: TyFun (a1 ~> (a1 ~> a1)) (Either a2 a1 ~> a1) -> Type) arg1) arg2
type (a2 :: k1) <$ (a3 :: Either a1 b)
Instance details Defined in Control.Monad.Singletons.Internal type (a2 :: k1) <$ (a3 :: Either a1 b) = Apply (Apply (TFHelper_6989586621679357439Sym0 :: TyFun k1 (Either a1 b ~> Either a1 k1) -> Type) a2) a3
type Apply (ShowsPrec_6989586621680071774Sym0 :: TyFun Nat (Either a b ~> (Symbol ~> Symbol)) -> Type) (a6989586621680071784 :: Nat)
Instance details Defined in Text.Show.Singletons type Apply (ShowsPrec_6989586621680071774Sym0 :: TyFun Nat (Either a b ~> (Symbol ~> Symbol)) -> Type) (a6989586621680071784 :: Nat) = ShowsPrec_6989586621680071774Sym1 a6989586621680071784 :: TyFun (Either a b) (Symbol ~> Symbol) -> Type
type Apply (LeftSym0 :: TyFun a (Either a b) -> Type) (a6989586621679028344 :: a)
Instance details Defined in Data.Singletons.Base.Instances type Apply (LeftSym0 :: TyFun a (Either a b) -> Type) (a6989586621679028344 :: a) = 'Left a6989586621679028344 :: Either a b
type Apply (Pure_6989586621679357611Sym0 :: TyFun a (Either e a) -> Type) (a6989586621679357617 :: a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Pure_6989586621679357611Sym0 :: TyFun a (Either e a) -> Type) (a6989586621679357617 :: a) = Pure_6989586621679357611 a6989586621679357617 :: Either e a
type Apply (RightSym0 :: TyFun b (Either a b) -> Type) (a6989586621679028346 :: b)
Instance details Defined in Data.Singletons.Base.Instances type Apply (RightSym0 :: TyFun b (Either a b) -> Type) (a6989586621679028346 :: b) = 'Right a6989586621679028346 :: Either a b
type Apply (Let6989586621679584161ASym0 :: TyFun k1 (Either a k1) -> Type) (wild_69895866216795838256989586621679584160 :: k1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Let6989586621679584161ASym0 :: TyFun k1 (Either a k1) -> Type) (wild_69895866216795838256989586621679584160 :: k1) = Let6989586621679584161A wild_69895866216795838256989586621679584160 :: Either a k1
type Apply (TFHelper_6989586621679357439Sym0 :: TyFun a1 (Either a2 b ~> Either a2 a1) -> Type) (a6989586621679357444 :: a1)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357439Sym0 :: TyFun a1 (Either a2 b ~> Either a2 a1) -> Type) (a6989586621679357444 :: a1) = TFHelper_6989586621679357439Sym1 a6989586621679357444 :: TyFun (Either a2 b) (Either a2 a1) -> Type
type Apply (Foldr_6989586621680194135Sym1 a6989586621680194141 :: TyFun b (Either a2 a1 ~> b) -> Type) (a6989586621680194142 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194135Sym1 a6989586621680194141 :: TyFun b (Either a2 a1 ~> b) -> Type) (a6989586621680194142 :: b) = Foldr_6989586621680194135Sym2 a6989586621680194141 a6989586621680194142 :: TyFun (Either a2 a1) b -> Type
type Eval (FoldMap f ('Left _a :: Either a3 a1) :: a2 -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (FoldMap f ('Left _a :: Either a3 a1) :: a2 -> Type) = MEmpty :: a2
type Eval (FoldMap f ('Right x :: Either a3 a1) :: a2 -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (FoldMap f ('Right x :: Either a3 a1) :: a2 -> Type) = Eval (f x)
type Eval (Foldr f y ('Left _a :: Either a3 a1) :: a2 -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (Foldr f y ('Left _a :: Either a3 a1) :: a2 -> Type) = y
type Eval (Foldr f y ('Right x :: Either a3 a1) :: a2 -> Type)
Instance details Defined in Fcf.Class.Foldable type Eval (Foldr f y ('Right x :: Either a3 a1) :: a2 -> Type) = Eval (f x y)
type Failure (Either a)
Instance details Defined in Basement.Monad type Failure (Either a) = a
type Fold (arg :: Either a m)
Instance details Defined in Data.Foldable.Singletons type Fold (arg :: Either a m) = Apply (Fold_6989586621680193565Sym0 :: TyFun (Either a m) m -> Type) arg
type Length (a3 :: Either a1 a2)
Instance details Defined in Data.Foldable.Singletons type Length (a3 :: Either a1 a2) = Apply (Length_6989586621680194149Sym0 :: TyFun (Either a1 a2) Nat -> Type) a3
type Maximum (arg :: Either a1 a2)
Instance details Defined in Data.Foldable.Singletons type Maximum (arg :: Either a1 a2) = Apply (Maximum_6989586621680193764Sym0 :: TyFun (Either a1 a2) a2 -> Type) arg
type Minimum (arg :: Either a1 a2)
Instance details Defined in Data.Foldable.Singletons type Minimum (arg :: Either a1 a2) = Apply (Minimum_6989586621680193779Sym0 :: TyFun (Either a1 a2) a2 -> Type) arg
type Null (a3 :: Either a1 a2)
Instance details Defined in Data.Foldable.Singletons type Null (a3 :: Either a1 a2) = Apply (Null_6989586621680194155Sym0 :: TyFun (Either a1 a2) Bool -> Type) a3
type Product (arg :: Either a1 a2)
Instance details Defined in Data.Foldable.Singletons type Product (arg :: Either a1 a2) = Apply (Product_6989586621680193803Sym0 :: TyFun (Either a1 a2) a2 -> Type) arg
type Sum (arg :: Either a1 a2)
Instance details Defined in Data.Foldable.Singletons type Sum (arg :: Either a1 a2) = Apply (Sum_6989586621680193794Sym0 :: TyFun (Either a1 a2) a2 -> Type) arg
type ToList (arg :: Either a1 a2)
Instance details Defined in Data.Foldable.Singletons type ToList (arg :: Either a1 a2) = Apply (ToList_6989586621680193705Sym0 :: TyFun (Either a1 a2) [a2] -> Type) arg
type Sequence (arg :: Either a1 (m a2))
Instance details Defined in Data.Traversable.Singletons type Sequence (arg :: Either a1 (m a2)) = Apply (Sequence_6989586621680471117Sym0 :: TyFun (Either a1 (m a2)) (m (Either a1 a2)) -> Type) arg
type SequenceA (arg :: Either a1 (f a2))
Instance details Defined in Data.Traversable.Singletons type SequenceA (arg :: Either a1 (f a2)) = Apply (SequenceA_6989586621680471093Sym0 :: TyFun (Either a1 (f a2)) (f (Either a1 a2)) -> Type) arg
type (arg1 :: Either e a) *> (arg2 :: Either e b)
Instance details Defined in Control.Monad.Singletons.Internal type (arg1 :: Either e a) *> (arg2 :: Either e b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (Either e a) (Either e b ~> Either e b) -> Type) arg1) arg2
type (arg1 :: Either e a) <* (arg2 :: Either e b)
Instance details Defined in Control.Monad.Singletons.Internal type (arg1 :: Either e a) <* (arg2 :: Either e b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (Either e a) (Either e b ~> Either e a) -> Type) arg1) arg2
type (a2 :: Either e (a1 ~> b)) <*> (a3 :: Either e a1)
Instance details Defined in Control.Monad.Singletons.Internal type (a2 :: Either e (a1 ~> b)) <*> (a3 :: Either e a1) = Apply (Apply (TFHelper_6989586621679357621Sym0 :: TyFun (Either e (a1 ~> b)) (Either e a1 ~> Either e b) -> Type) a2) a3
type (arg1 :: Either e a) >> (arg2 :: Either e b)
Instance details Defined in Control.Monad.Singletons.Internal type (arg1 :: Either e a) >> (arg2 :: Either e b) = Apply (Apply (TFHelper_6989586621679287148Sym0 :: TyFun (Either e a) (Either e b ~> Either e b) -> Type) arg1) arg2
type (a2 :: Either e a1) >>= (a3 :: a1 ~> Either e b)
Instance details Defined in Control.Monad.Singletons.Internal type (a2 :: Either e a1) >>= (a3 :: a1 ~> Either e b) = Apply (Apply (TFHelper_6989586621679357705Sym0 :: TyFun (Either e a1) ((a1 ~> Either e b) ~> Either e b) -> Type) a2) a3
type Rep1 (Either a :: Type -> Type)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type HKD (Either a :: Type -> Type) (b :: Type)
Instance details Defined in Data.Vinyl.XRec type HKD (Either a :: Type -> Type) (b :: Type) = Either a b
type Apply (LeftsSym0 :: TyFun [Either a b] [a] -> Type) (a6989586621679277123 :: [Either a b])
Instance details Defined in Data.Either.Singletons type Apply (LeftsSym0 :: TyFun [Either a b] [a] -> Type) (a6989586621679277123 :: [Either a b]) = Lefts a6989586621679277123
type Apply (RightsSym0 :: TyFun [Either a b] [b] -> Type) (a6989586621679277117 :: [Either a b])
Instance details Defined in Data.Either.Singletons type Apply (RightsSym0 :: TyFun [Either a b] [b] -> Type) (a6989586621679277117 :: [Either a b]) = Rights a6989586621679277117
type Apply (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> Type) (a6989586621679277100 :: [Either a b])
Instance details Defined in Data.Either.Singletons type Apply (PartitionEithersSym0 :: TyFun [Either a b] ([a], [b]) -> Type) (a6989586621679277100 :: [Either a b]) = PartitionEithers a6989586621679277100
type Rep (Either a b)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep (Either a b) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b)))
type AsRPC (Either l r)
Instance details Defined in Morley.AsRPC type AsRPC (Either l r) = Either (AsRPC l) (AsRPC r)
type TypeDocFieldDescriptions (Either l r)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Either l r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (Either l r)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Either l r) = GValueType (Rep (Either l r))
type Demote (Either a b)
Instance details Defined in Data.Singletons.Base.Instances type Demote (Either a b) = Either (Demote a) (Demote b)
type Sing
Instance details Defined in Data.Singletons.Base.Instances type Sing = SEither :: Either a b -> Type
type Element (Either a b)
Instance details Defined in Universum.Container.Class type Element (Either a b) = ElementDefault (Either a b)
type Sconcat (arg :: NonEmpty (Either a b))
Instance details Defined in Data.Semigroup.Singletons.Internal type Sconcat (arg :: NonEmpty (Either a b)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (Either a b)) (Either a b) -> Type) arg
type Show_ (arg :: Either a b)
Instance details Defined in Text.Show.Singletons type Show_ (arg :: Either a b) = Apply (Show__6989586621680047550Sym0 :: TyFun (Either a b) Symbol -> Type) arg
type (arg1 :: Either a b) /= (arg2 :: Either a b)
Instance details Defined in Data.Eq.Singletons type (arg1 :: Either a b) /= (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type) arg1) arg2
type (a2 :: Either a1 b) == (a3 :: Either a1 b)
Instance details Defined in Data.Eq.Singletons type (a2 :: Either a1 b) == (a3 :: Either a1 b) = Apply (Apply (TFHelper_6989586621679130594Sym0 :: TyFun (Either a1 b) (Either a1 b ~> Bool) -> Type) a2) a3
type (arg1 :: Either a b) < (arg2 :: Either a b)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Either a b) < (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type) arg1) arg2
type (arg1 :: Either a b) <= (arg2 :: Either a b)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Either a b) <= (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type) arg1) arg2
type (arg1 :: Either a b) > (arg2 :: Either a b)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Either a b) > (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type) arg1) arg2
type (arg1 :: Either a b) >= (arg2 :: Either a b)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Either a b) >= (arg2 :: Either a b) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type) arg1) arg2
type Compare (a2 :: Either a1 b) (a3 :: Either a1 b)
Instance details Defined in Data.Ord.Singletons type Compare (a2 :: Either a1 b) (a3 :: Either a1 b) = Apply (Apply (Compare_6989586621679181415Sym0 :: TyFun (Either a1 b) (Either a1 b ~> Ordering) -> Type) a2) a3
type Max (arg1 :: Either a b) (arg2 :: Either a b)
Instance details Defined in Data.Ord.Singletons type Max (arg1 :: Either a b) (arg2 :: Either a b) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (Either a b) (Either a b ~> Either a b) -> Type) arg1) arg2
type Min (arg1 :: Either a b) (arg2 :: Either a b)
Instance details Defined in Data.Ord.Singletons type Min (arg1 :: Either a b) (arg2 :: Either a b) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (Either a b) (Either a b ~> Either a b) -> Type) arg1) arg2
type (a2 :: Either a1 b) <> (a3 :: Either a1 b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Either a1 b) <> (a3 :: Either a1 b) = Apply (Apply (TFHelper_6989586621679584152Sym0 :: TyFun (Either a1 b) (Either a1 b ~> Either a1 b) -> Type) a2) a3
type ShowList (arg1 :: [Either a b]) arg2
Instance details Defined in Text.Show.Singletons type ShowList (arg1 :: [Either a b]) arg2 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Either a b] (Symbol ~> Symbol) -> Type) arg1) arg2
type ShowsPrec a2 (a3 :: Either a1 b) a4
Instance details Defined in Text.Show.Singletons type ShowsPrec a2 (a3 :: Either a1 b) a4 = Apply (Apply (Apply (ShowsPrec_6989586621680071774Sym0 :: TyFun Nat (Either a1 b ~> (Symbol ~> Symbol)) -> Type) a2) a3) a4
type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621679277095 :: Either a b)
Instance details Defined in Data.Either.Singletons type Apply (IsLeftSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621679277095 :: Either a b) = IsLeft a6989586621679277095
type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621679277092 :: Either a b)
Instance details Defined in Data.Either.Singletons type Apply (IsRightSym0 :: TyFun (Either a b) Bool -> Type) (a6989586621679277092 :: Either a b) = IsRight a6989586621679277092
type Apply (Null_6989586621680194155Sym0 :: TyFun (Either a1 a2) Bool -> Type) (a6989586621680194161 :: Either a1 a2)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680194155Sym0 :: TyFun (Either a1 a2) Bool -> Type) (a6989586621680194161 :: Either a1 a2) = Null_6989586621680194155 a6989586621680194161
type Apply (Length_6989586621680194149Sym0 :: TyFun (Either a1 a2) Nat -> Type) (a6989586621680194153 :: Either a1 a2)
Instance details Defined in Data.Foldable.Singletons type Apply (Length_6989586621680194149Sym0 :: TyFun (Either a1 a2) Nat -> Type) (a6989586621680194153 :: Either a1 a2) = Length_6989586621680194149 a6989586621680194153
type Apply (Compare_6989586621679181415Sym1 a6989586621679181420 :: TyFun (Either a b) Ordering -> Type) (a6989586621679181421 :: Either a b)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181415Sym1 a6989586621679181420 :: TyFun (Either a b) Ordering -> Type) (a6989586621679181421 :: Either a b) = Compare_6989586621679181415 a6989586621679181420 a6989586621679181421
type Apply (TFHelper_6989586621679130594Sym1 a6989586621679130599 :: TyFun (Either a b) Bool -> Type) (a6989586621679130600 :: Either a b)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130594Sym1 a6989586621679130599 :: TyFun (Either a b) Bool -> Type) (a6989586621679130600 :: Either a b) = TFHelper_6989586621679130594 a6989586621679130599 a6989586621679130600
type Apply (FoldMap_6989586621680194123Sym1 a6989586621680194128 :: TyFun (Either a2 a1) m -> Type) (a6989586621680194129 :: Either a2 a1)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194123Sym1 a6989586621680194128 :: TyFun (Either a2 a1) m -> Type) (a6989586621680194129 :: Either a2 a1) = FoldMap_6989586621680194123 a6989586621680194128 a6989586621680194129
type Apply (Either_Sym2 a6989586621679275170 a6989586621679275171 :: TyFun (Either a b) c -> Type) (a6989586621679275172 :: Either a b)
Instance details Defined in Data.Either.Singletons type Apply (Either_Sym2 a6989586621679275170 a6989586621679275171 :: TyFun (Either a b) c -> Type) (a6989586621679275172 :: Either a b) = Either_ a6989586621679275170 a6989586621679275171 a6989586621679275172
type Apply (Foldr_6989586621680194135Sym2 a6989586621680194141 a6989586621680194142 :: TyFun (Either a2 a1) b -> Type) (a6989586621680194143 :: Either a2 a1)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194135Sym2 a6989586621680194141 a6989586621680194142 :: TyFun (Either a2 a1) b -> Type) (a6989586621680194143 :: Either a2 a1) = Foldr_6989586621680194135 a6989586621680194141 a6989586621680194142 a6989586621680194143
type Apply (Traverse_6989586621680478703Sym1 a6989586621680478708 :: TyFun (Either a2 a1) (f (Either a2 b)) -> Type) (a6989586621680478709 :: Either a2 a1)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478703Sym1 a6989586621680478708 :: TyFun (Either a2 a1) (f (Either a2 b)) -> Type) (a6989586621680478709 :: Either a2 a1) = Traverse_6989586621680478703 a6989586621680478708 a6989586621680478709
type Apply (TFHelper_6989586621679584152Sym0 :: TyFun (Either a b) (Either a b ~> Either a b) -> Type) (a6989586621679584157 :: Either a b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679584152Sym0 :: TyFun (Either a b) (Either a b ~> Either a b) -> Type) (a6989586621679584157 :: Either a b) = TFHelper_6989586621679584152Sym1 a6989586621679584157
type Apply (Compare_6989586621679181415Sym0 :: TyFun (Either a b) (Either a b ~> Ordering) -> Type) (a6989586621679181420 :: Either a b)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181415Sym0 :: TyFun (Either a b) (Either a b ~> Ordering) -> Type) (a6989586621679181420 :: Either a b) = Compare_6989586621679181415Sym1 a6989586621679181420
type Apply (TFHelper_6989586621679130594Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type) (a6989586621679130599 :: Either a b)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130594Sym0 :: TyFun (Either a b) (Either a b ~> Bool) -> Type) (a6989586621679130599 :: Either a b) = TFHelper_6989586621679130594Sym1 a6989586621679130599
type Apply (TFHelper_6989586621679584152Sym1 a6989586621679584157 :: TyFun (Either a b) (Either a b) -> Type) (a6989586621679584158 :: Either a b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679584152Sym1 a6989586621679584157 :: TyFun (Either a b) (Either a b) -> Type) (a6989586621679584158 :: Either a b) = TFHelper_6989586621679584152 a6989586621679584157 a6989586621679584158
type Apply (ShowsPrec_6989586621680071774Sym1 a6989586621680071784 :: TyFun (Either a b) (Symbol ~> Symbol) -> Type) (a6989586621680071785 :: Either a b)
Instance details Defined in Text.Show.Singletons type Apply (ShowsPrec_6989586621680071774Sym1 a6989586621680071784 :: TyFun (Either a b) (Symbol ~> Symbol) -> Type) (a6989586621680071785 :: Either a b) = ShowsPrec_6989586621680071774Sym2 a6989586621680071784 a6989586621680071785
type Apply (TFHelper_6989586621679357621Sym0 :: TyFun (Either e (a ~> b)) (Either e a ~> Either e b) -> Type) (a6989586621679357626 :: Either e (a ~> b))
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357621Sym0 :: TyFun (Either e (a ~> b)) (Either e a ~> Either e b) -> Type) (a6989586621679357626 :: Either e (a ~> b)) = TFHelper_6989586621679357621Sym1 a6989586621679357626
type Apply (TFHelper_6989586621679357705Sym0 :: TyFun (Either e a) ((a ~> Either e b) ~> Either e b) -> Type) (a6989586621679357710 :: Either e a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357705Sym0 :: TyFun (Either e a) ((a ~> Either e b) ~> Either e b) -> Type) (a6989586621679357710 :: Either e a) = TFHelper_6989586621679357705Sym1 a6989586621679357710 :: TyFun (a ~> Either e b) (Either e b) -> Type
type Apply (Either_Sym0 :: TyFun (a ~> c) ((b ~> c) ~> (Either a b ~> c)) -> Type) (a6989586621679275170 :: a ~> c)
Instance details Defined in Data.Either.Singletons type Apply (Either_Sym0 :: TyFun (a ~> c) ((b ~> c) ~> (Either a b ~> c)) -> Type) (a6989586621679275170 :: a ~> c) = Either_Sym1 a6989586621679275170 :: TyFun (b ~> c) (Either a b ~> c) -> Type
type Apply (Foldr_6989586621680194135Sym0 :: TyFun (a1 ~> (b ~> b)) (b ~> (Either a2 a1 ~> b)) -> Type) (a6989586621680194141 :: a1 ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194135Sym0 :: TyFun (a1 ~> (b ~> b)) (b ~> (Either a2 a1 ~> b)) -> Type) (a6989586621680194141 :: a1 ~> (b ~> b)) = Foldr_6989586621680194135Sym1 a6989586621680194141 :: TyFun b (Either a2 a1 ~> b) -> Type
type Apply (Fmap_6989586621679357422Sym0 :: TyFun (a1 ~> b) (Either a2 a1 ~> Either a2 b) -> Type) (a6989586621679357427 :: a1 ~> b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Fmap_6989586621679357422Sym0 :: TyFun (a1 ~> b) (Either a2 a1 ~> Either a2 b) -> Type) (a6989586621679357427 :: a1 ~> b) = Fmap_6989586621679357422Sym1 a6989586621679357427 :: TyFun (Either a2 a1) (Either a2 b) -> Type
type Apply (FoldMap_6989586621680194123Sym0 :: TyFun (a1 ~> m) (Either a2 a1 ~> m) -> Type) (a6989586621680194128 :: a1 ~> m)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194123Sym0 :: TyFun (a1 ~> m) (Either a2 a1 ~> m) -> Type) (a6989586621680194128 :: a1 ~> m) = FoldMap_6989586621680194123Sym1 a6989586621680194128 :: TyFun (Either a2 a1) m -> Type
type Apply (Fmap_6989586621679357422Sym1 a6989586621679357427 :: TyFun (Either a2 a1) (Either a2 b) -> Type) (a6989586621679357428 :: Either a2 a1)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Fmap_6989586621679357422Sym1 a6989586621679357427 :: TyFun (Either a2 a1) (Either a2 b) -> Type) (a6989586621679357428 :: Either a2 a1) = Fmap_6989586621679357422 a6989586621679357427 a6989586621679357428
type Apply (TFHelper_6989586621679357439Sym1 a6989586621679357444 :: TyFun (Either a2 b) (Either a2 a1) -> Type) (a6989586621679357445 :: Either a2 b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357439Sym1 a6989586621679357444 :: TyFun (Either a2 b) (Either a2 a1) -> Type) (a6989586621679357445 :: Either a2 b) = TFHelper_6989586621679357439 a6989586621679357444 a6989586621679357445
type Apply (TFHelper_6989586621679357621Sym1 a6989586621679357626 :: TyFun (Either e a) (Either e b) -> Type) (a6989586621679357627 :: Either e a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357621Sym1 a6989586621679357626 :: TyFun (Either e a) (Either e b) -> Type) (a6989586621679357627 :: Either e a) = TFHelper_6989586621679357621 a6989586621679357626 a6989586621679357627
type Apply (TFHelper_6989586621679357705Sym1 a6989586621679357710 :: TyFun (a ~> Either e b) (Either e b) -> Type) (a6989586621679357711 :: a ~> Either e b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357705Sym1 a6989586621679357710 :: TyFun (a ~> Either e b) (Either e b) -> Type) (a6989586621679357711 :: a ~> Either e b) = TFHelper_6989586621679357705 a6989586621679357710 a6989586621679357711
type Apply (Traverse_6989586621680478703Sym0 :: TyFun (a1 ~> f b) (Either a2 a1 ~> f (Either a2 b)) -> Type) (a6989586621680478708 :: a1 ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478703Sym0 :: TyFun (a1 ~> f b) (Either a2 a1 ~> f (Either a2 b)) -> Type) (a6989586621680478708 :: a1 ~> f b) = Traverse_6989586621680478703Sym1 a6989586621680478708 :: TyFun (Either a2 a1) (f (Either a2 b)) -> Type
type Apply (Either_Sym1 a6989586621679275170 :: TyFun (b ~> c) (Either a b ~> c) -> Type) (a6989586621679275171 :: b ~> c)
Instance details Defined in Data.Either.Singletons type Apply (Either_Sym1 a6989586621679275170 :: TyFun (b ~> c) (Either a b ~> c) -> Type) (a6989586621679275171 :: b ~> c) = Either_Sym2 a6989586621679275170 a6989586621679275171
type Eval (Map f ('Left x :: Either a2 a1) :: Either a2 b -> Type)
Instance details Defined in Fcf.Class.Functor type Eval (Map f ('Left x :: Either a2 a1) :: Either a2 b -> Type) = 'Left x :: Either a2 b
type Eval (Map f ('Right a3 :: Either a2 a1) :: Either a2 b -> Type)
Instance details Defined in Fcf.Class.Functor type Eval (Map f ('Right a3 :: Either a2 a1) :: Either a2 b -> Type) = 'Right (Eval (f a3)) :: Either a2 b
type Eval (Bimap f g ('Right y :: Either a b1) :: Either a' b2 -> Type)
Instance details Defined in Fcf.Class.Bifunctor type Eval (Bimap f g ('Right y :: Either a b1) :: Either a' b2 -> Type) = 'Right (Eval (g y)) :: Either a' b2
type Eval (Bimap f g ('Left x :: Either a1 b) :: Either a2 b' -> Type)
Instance details Defined in Fcf.Class.Bifunctor type Eval (Bimap f g ('Left x :: Either a1 b) :: Either a2 b' -> Type) = 'Left (Eval (f x)) :: Either a2 b'

type Type = Type #

The kind of types with lifted values. For example Int :: Type.

data Constraint #

The kind of constraints, like Show a

type family CmpNat (a :: Nat) (b :: Nat) :: Ordering where ... #

Comparison of type-level naturals, as a function.

Since: base-4.7.0.0

class a ~R# b => Coercible (a :: k) (b :: k) #

Coercible is a two-parameter class that has instances for types a and b if the compiler can infer that they have the same representation. This class does not have regular instances; instead they are created on-the-fly during type-checking. Trying to manually declare an instance of Coercible is an error.

Nevertheless one can pretend that the following three kinds of instances exist. First, as a trivial base-case:

instance Coercible a a

Furthermore, for every type constructor there is an instance that allows to coerce under the type constructor. For example, let D be a prototypical type constructor (data or newtype) with three type arguments, which have roles nominal, representational resp. phantom. Then there is an instance of the form

instance Coercible b b' => Coercible (D a b c) (D a b' c')

Note that the nominal type arguments are equal, the representational type arguments can differ, but need to have a Coercible instance themself, and the phantom type arguments can be changed arbitrarily.

The third kind of instance exists for every newtype NT = MkNT T and comes in two variants, namely

instance Coercible a T => Coercible a NT

instance Coercible T b => Coercible NT b

This instance is only usable if the constructor MkNT is in scope.

If, as a library author of a type constructor like Set a, you want to prevent a user of your module to write coerce :: Set T -> Set NT, you need to set the role of Set's type parameter to nominal, by writing

type role Set nominal

For more details about this feature, please refer to Safe Coercions by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.

Since: ghc-prim-4.7.0.0

Instances

Instances details

HasDict (Coercible a b) (Coercion a b)
Instance details Defined in Data.Constraint Methods evidence :: Coercion a b -> Dict (Coercible a b) #

data CallStack #

CallStacks are a lightweight method of obtaining a partial call-stack at any point in the program.

A function can request its call-site with the HasCallStack constraint. For example, we can define

putStrLnWithCallStack :: HasCallStack => String -> IO ()

as a variant of putStrLn that will get its call-site and print it, along with the string given as argument. We can access the call-stack inside putStrLnWithCallStack with callStack.

putStrLnWithCallStack :: HasCallStack => String -> IO ()
putStrLnWithCallStack msg = do
  putStrLn msg
  putStrLn (prettyCallStack callStack)

Thus, if we call putStrLnWithCallStack we will get a formatted call-stack alongside our string.

>>> putStrLnWithCallStack "hello"
hello
CallStack (from HasCallStack):
  putStrLnWithCallStack, called at <interactive>:2:1 in interactive:Ghci1

GHC solves HasCallStack constraints in three steps:

If there is a CallStack in scope -- i.e. the enclosing function has a HasCallStack constraint -- GHC will append the new call-site to the existing CallStack.
If there is no CallStack in scope -- e.g. in the GHCi session above -- and the enclosing definition does not have an explicit type signature, GHC will infer a HasCallStack constraint for the enclosing definition (subject to the monomorphism restriction).
If there is no CallStack in scope and the enclosing definition has an explicit type signature, GHC will solve the HasCallStack constraint for the singleton CallStack containing just the current call-site.

CallStacks do not interact with the RTS and do not require compilation with -prof. On the other hand, as they are built up explicitly via the HasCallStack constraints, they will generally not contain as much information as the simulated call-stacks maintained by the RTS.

A CallStack is a [(String, SrcLoc)]. The String is the name of function that was called, the SrcLoc is the call-site. The list is ordered with the most recently called function at the head.

NOTE: The intrepid user may notice that HasCallStack is just an alias for an implicit parameter ?callStack :: CallStack. This is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.8.1.0

Instances

Instances details

IsList CallStack	Be aware that 'fromList . toList = id' only for unfrozen `CallStack`s, since `toList` removes frozenness information. Since: base-4.9.0.0
Instance details Defined in GHC.Exts Associated Types type Item CallStack # Methods fromList :: [Item CallStack] -> CallStack # fromListN :: Int -> [Item CallStack] -> CallStack # toList :: CallStack -> [Item CallStack] #
Show CallStack	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> CallStack -> ShowS # show :: CallStack -> String # showList :: [CallStack] -> ShowS #
NFData CallStack	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: CallStack -> () #
type Item CallStack
Instance details Defined in GHC.Exts type Item CallStack = (String, SrcLoc)

data ByteString #

A space-efficient representation of a Word8 vector, supporting many efficient operations.

A ByteString contains 8-bit bytes, or by using the operations from Data.ByteString.Char8 it can be interpreted as containing 8-bit characters.

Instances

Instances details

Structured ByteString
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy ByteString -> Structure # structureHash' :: Tagged ByteString MD5
Chunk ByteString
Instance details Defined in Data.Attoparsec.Internal.Types Associated Types type ChunkElem ByteString # Methods nullChunk :: ByteString -> Bool # pappendChunk :: State ByteString -> ByteString -> State ByteString # atBufferEnd :: ByteString -> State ByteString -> Pos # bufferElemAt :: ByteString -> Pos -> State ByteString -> Maybe (ChunkElem ByteString, Int) # chunkElemToChar :: ByteString -> ChunkElem ByteString -> Char #
Data ByteString
Instance details Defined in Data.ByteString.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteString -> c ByteString # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteString # toConstr :: ByteString -> Constr # dataTypeOf :: ByteString -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteString) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteString) # gmapT :: (forall b. Data b => b -> b) -> ByteString -> ByteString # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQ :: (forall d. Data d => d -> u) -> ByteString -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteString -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString #
IsString ByteString	Beware: `fromString` truncates multi-byte characters to octets. e.g. "枯朶に烏のとまりけり秋の暮" becomes �6k�nh~�Q��n�
Instance details Defined in Data.ByteString.Internal Methods fromString :: String -> ByteString #
Monoid ByteString
Instance details Defined in Data.ByteString.Internal Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Semigroup ByteString
Instance details Defined in Data.ByteString.Internal Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
IsList ByteString	Since: bytestring-0.10.12.0
Instance details Defined in Data.ByteString.Internal Associated Types type Item ByteString # Methods fromList :: [Item ByteString] -> ByteString # fromListN :: Int -> [Item ByteString] -> ByteString # toList :: ByteString -> [Item ByteString] #
Read ByteString
Instance details Defined in Data.ByteString.Internal Methods readsPrec :: Int -> ReadS ByteString # readList :: ReadS [ByteString] # readPrec :: ReadPrec ByteString # readListPrec :: ReadPrec [ByteString] #
Show ByteString
Instance details Defined in Data.ByteString.Internal Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
NFData ByteString
Instance details Defined in Data.ByteString.Internal Methods rnf :: ByteString -> () #
FromBuilder ByteString
Instance details Defined in Fmt.Internal.Core Methods fromBuilder :: Builder -> ByteString #
Eq ByteString
Instance details Defined in Data.ByteString.Internal Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Ord ByteString
Instance details Defined in Data.ByteString.Internal Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString #
Hashable ByteString
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Ixed ByteString
Instance details Defined in Control.Lens.At Methods ix :: Index ByteString -> Traversal' ByteString (IxValue ByteString) #
HasAnnotation ByteString
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT ByteString) # annOptions :: Maybe AnnOptions #
BytesLike ByteString
Instance details Defined in Lorentz.Bytes Methods toBytes :: ByteString -> ByteString #
ConcatOpHs ByteString
Instance details Defined in Lorentz.Polymorphic
SizeOpHs ByteString
Instance details Defined in Lorentz.Polymorphic
SliceOpHs ByteString
Instance details Defined in Lorentz.Polymorphic
Stream ByteString
Instance details Defined in Text.Megaparsec.Stream Associated Types type Token ByteString # type Tokens ByteString # Methods tokenToChunk :: Proxy ByteString -> Token ByteString -> Tokens ByteString # tokensToChunk :: Proxy ByteString -> [Token ByteString] -> Tokens ByteString # chunkToTokens :: Proxy ByteString -> Tokens ByteString -> [Token ByteString] # chunkLength :: Proxy ByteString -> Tokens ByteString -> Int # chunkEmpty :: Proxy ByteString -> Tokens ByteString -> Bool # take1_ :: ByteString -> Maybe (Token ByteString, ByteString) # takeN_ :: Int -> ByteString -> Maybe (Tokens ByteString, ByteString) # takeWhile_ :: (Token ByteString -> Bool) -> ByteString -> (Tokens ByteString, ByteString) #
TraversableStream ByteString
Instance details Defined in Text.Megaparsec.Stream Methods reachOffset :: Int -> PosState ByteString -> (Maybe String, PosState ByteString) # reachOffsetNoLine :: Int -> PosState ByteString -> PosState ByteString #
VisualStream ByteString
Instance details Defined in Text.Megaparsec.Stream Methods showTokens :: Proxy ByteString -> NonEmpty (Token ByteString) -> String # tokensLength :: Proxy ByteString -> NonEmpty (Token ByteString) -> Int #
HasRPCRepr ByteString
Instance details Defined in Morley.AsRPC Associated Types type AsRPC ByteString #
TypeHasDoc ByteString
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions ByteString :: FieldDescriptions # Methods typeDocName :: Proxy ByteString -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy ByteString -> WithinParens -> Markdown # typeDocDependencies :: Proxy ByteString -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep ByteString # typeDocMichelsonRep :: TypeDocMichelsonRep ByteString #
IsoValue ByteString
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT ByteString :: T # Methods toVal :: ByteString -> Value (ToT ByteString) # fromVal :: Value (ToT ByteString) -> ByteString #
Container ByteString
Instance details Defined in Universum.Container.Class Associated Types type Element ByteString # Methods toList :: ByteString -> [Element ByteString] # null :: ByteString -> Bool # foldr :: (Element ByteString -> b -> b) -> b -> ByteString -> b # foldl :: (b -> Element ByteString -> b) -> b -> ByteString -> b # foldl' :: (b -> Element ByteString -> b) -> b -> ByteString -> b # length :: ByteString -> Int # elem :: Element ByteString -> ByteString -> Bool # foldMap :: Monoid m => (Element ByteString -> m) -> ByteString -> m # fold :: ByteString -> Element ByteString # foldr' :: (Element ByteString -> b -> b) -> b -> ByteString -> b # notElem :: Element ByteString -> ByteString -> Bool # all :: (Element ByteString -> Bool) -> ByteString -> Bool # any :: (Element ByteString -> Bool) -> ByteString -> Bool # and :: ByteString -> Bool # or :: ByteString -> Bool # find :: (Element ByteString -> Bool) -> ByteString -> Maybe (Element ByteString) # safeHead :: ByteString -> Maybe (Element ByteString) # safeMaximum :: ByteString -> Maybe (Element ByteString) # safeMinimum :: ByteString -> Maybe (Element ByteString) # safeFoldr1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Maybe (Element ByteString) # safeFoldl1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Maybe (Element ByteString) #
FromList ByteString
Instance details Defined in Universum.Container.Class Associated Types type ListElement ByteString # type FromListC ByteString # Methods fromList :: [ListElement ByteString] -> ByteString #
One ByteString
Instance details Defined in Universum.Container.Class Associated Types type OneItem ByteString # Methods one :: OneItem ByteString -> ByteString #
Print ByteString
Instance details Defined in Universum.Print.Internal Methods hPutStr :: Handle -> ByteString -> IO () # hPutStrLn :: Handle -> ByteString -> IO () #
UnaryArithOpHs Not ByteString
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Not ByteString # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (ByteString ': s) :-> (UnaryArithResHs Not ByteString ': s) #
ConvertUtf8 Text ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: Text -> ByteString # decodeUtf8 :: ByteString -> Text # decodeUtf8Strict :: ByteString -> Either UnicodeException Text #
ConvertUtf8 Text ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: Text -> ByteString # decodeUtf8 :: ByteString -> Text # decodeUtf8Strict :: ByteString -> Either UnicodeException Text #
ConvertUtf8 String ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: String -> ByteString # decodeUtf8 :: ByteString -> String # decodeUtf8Strict :: ByteString -> Either UnicodeException String #
r ~ ByteString => ArithOpHs And ByteString ByteString r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (ByteString ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs Lsl ByteString Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (Natural ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs Lsr ByteString Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (Natural ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs Or ByteString ByteString r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (ByteString ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs Xor ByteString ByteString r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (ByteString ': s)) :-> (r ': s) #
CanCastTo (Packed a :: Type) ByteString
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Packed a) -> Proxy ByteString -> () #
CanCastTo (TSignature a :: Type) ByteString
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (TSignature a) -> Proxy ByteString -> () #
CanCastTo (Hash alg a :: Type) ByteString
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Hash alg a) -> Proxy ByteString -> () #
type ChunkElem ByteString
Instance details Defined in Data.Attoparsec.Internal.Types type ChunkElem ByteString = Word8
type State ByteString
Instance details Defined in Data.Attoparsec.Internal.Types type State ByteString = Buffer
type Item ByteString
Instance details Defined in Data.ByteString.Internal type Item ByteString = Word8
type Index ByteString
Instance details Defined in Control.Lens.At type Index ByteString = Int
type IxValue ByteString
Instance details Defined in Control.Lens.At type IxValue ByteString = Word8
type Token ByteString
Instance details Defined in Text.Megaparsec.Stream type Token ByteString = Word8
type Tokens ByteString
Instance details Defined in Text.Megaparsec.Stream type Tokens ByteString = ByteString
type AsRPC ByteString
Instance details Defined in Morley.AsRPC type AsRPC ByteString = ByteString
type TypeDocFieldDescriptions ByteString
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions ByteString = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT ByteString
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT ByteString = 'TBytes
type PrettyShow ByteString
Instance details Defined in Morley.Prelude.Show type PrettyShow ByteString = TypeError ('Text "Show instance for ByteString is not pretty") :: Constraint
type Element ByteString
Instance details Defined in Universum.Container.Class type Element ByteString = Word8
type FromListC ByteString
Instance details Defined in Universum.Container.Class type FromListC ByteString = ()
type ListElement ByteString
Instance details Defined in Universum.Container.Class type ListElement ByteString = Word8
type OneItem ByteString
Instance details Defined in Universum.Container.Class type OneItem ByteString = Word8
type UnaryArithResHs Not ByteString
Instance details Defined in Lorentz.Arith type UnaryArithResHs Not ByteString = ByteString

byteSwap16 :: Word16 -> Word16 #

Reverse order of bytes in Word16.

Since: base-4.7.0.0

byteSwap32 :: Word32 -> Word32 #

Reverse order of bytes in Word32.

Since: base-4.7.0.0

byteSwap64 :: Word64 -> Word64 #

Reverse order of bytes in Word64.

Since: base-4.7.0.0

data MVar a #

An MVar (pronounced "em-var") is a synchronising variable, used for communication between concurrent threads. It can be thought of as a box, which may be empty or full.

Instances

Instances details

NFData1 MVar	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> MVar a -> () #
NFData (MVar a)	NOTE: Only strict in the reference and not the referenced value. Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: MVar a -> () #
Eq (MVar a)	Since: base-4.1.0.0
Instance details Defined in GHC.MVar Methods (==) :: MVar a -> MVar a -> Bool # (/=) :: MVar a -> MVar a -> Bool #

deepseq :: NFData a => a -> b -> b #

deepseq: fully evaluates the first argument, before returning the second.

The name deepseq is used to illustrate the relationship to seq: where seq is shallow in the sense that it only evaluates the top level of its argument, deepseq traverses the entire data structure evaluating it completely.

deepseq can be useful for forcing pending exceptions, eradicating space leaks, or forcing lazy I/O to happen. It is also useful in conjunction with parallel Strategies (see the parallel package).

There is no guarantee about the ordering of evaluation. The implementation may evaluate the components of the structure in any order or in parallel. To impose an actual order on evaluation, use pseq from Control.Parallel in the parallel package.

Since: deepseq-1.1.0.0

force :: NFData a => a -> a #

a variant of deepseq that is useful in some circumstances:

force x = x `deepseq` x

force x fully evaluates x, and then returns it. Note that force x only performs evaluation when the value of force x itself is demanded, so essentially it turns shallow evaluation into deep evaluation.

force can be conveniently used in combination with ViewPatterns:

{-# LANGUAGE BangPatterns, ViewPatterns #-}
import Control.DeepSeq

someFun :: ComplexData -> SomeResult
someFun (force -> !arg) = {- 'arg' will be fully evaluated -}

Another useful application is to combine force with evaluate in order to force deep evaluation relative to other IO operations:

import Control.Exception (evaluate)
import Control.DeepSeq

main = do
  result <- evaluate $ force $ pureComputation
  {- 'result' will be fully evaluated at this point -}
  return ()

Finally, here's an exception safe variant of the readFile' example:

readFile' :: FilePath -> IO String
readFile' fn = bracket (openFile fn ReadMode) hClose $ \h ->
                       evaluate . force =<< hGetContents h

Since: deepseq-1.2.0.0

class NFData a where #

A class of types that can be fully evaluated.

Since: deepseq-1.1.0.0

Minimal complete definition

Nothing

Methods

rnf :: a -> () #

rnf should reduce its argument to normal form (that is, fully evaluate all sub-components), and then return ().

`Generic` `NFData` deriving

Starting with GHC 7.2, you can automatically derive instances for types possessing a Generic instance.

Note: Generic1 can be auto-derived starting with GHC 7.4

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics (Generic, Generic1)
import Control.DeepSeq

data Foo a = Foo a String
             deriving (Eq, Generic, Generic1)

instance NFData a => NFData (Foo a)
instance NFData1 Foo

data Colour = Red | Green | Blue
              deriving Generic

instance NFData Colour

Starting with GHC 7.10, the example above can be written more concisely by enabling the new DeriveAnyClass extension:

{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

import GHC.Generics (Generic)
import Control.DeepSeq

data Foo a = Foo a String
             deriving (Eq, Generic, Generic1, NFData, NFData1)

data Colour = Red | Green | Blue
              deriving (Generic, NFData)

Compatibility with previous `deepseq` versions

Prior to version 1.4.0.0, the default implementation of the rnf method was defined as

rnf a = seq a ()

However, starting with deepseq-1.4.0.0, the default implementation is based on DefaultSignatures allowing for more accurate auto-derived NFData instances. If you need the previously used exact default rnf method implementation semantics, use

instance NFData Colour where rnf x = seq x ()

or alternatively

instance NFData Colour where rnf = rwhnf

or

{-# LANGUAGE BangPatterns #-}
instance NFData Colour where rnf !_ = ()

Instances

Instances details

NFData CabalSpecVersion
Instance details Defined in Distribution.CabalSpecVersion Methods rnf :: CabalSpecVersion -> () #
NFData PError
Instance details Defined in Distribution.Parsec.Error Methods rnf :: PError -> () #
NFData Position
Instance details Defined in Distribution.Parsec.Position Methods rnf :: Position -> () #
NFData PWarnType
Instance details Defined in Distribution.Parsec.Warning Methods rnf :: PWarnType -> () #
NFData PWarning
Instance details Defined in Distribution.Parsec.Warning Methods rnf :: PWarning -> () #
NFData Extension
Instance details Defined in Language.Haskell.Extension Methods rnf :: Extension -> () #
NFData KnownExtension
Instance details Defined in Language.Haskell.Extension Methods rnf :: KnownExtension -> () #
NFData Language
Instance details Defined in Language.Haskell.Extension Methods rnf :: Language -> () #
NFData JSONPathElement
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: JSONPathElement -> () #
NFData Value
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: Value -> () #
NFData All	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: All -> () #
NFData Any	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Any -> () #
NFData TypeRep	NOTE: Prior to `deepseq-1.4.4.0` this instance was only defined for `base-4.8.0.0` and later. Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: TypeRep -> () #
NFData Unique	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Unique -> () #
NFData Version	Since: deepseq-1.3.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Version -> () #
NFData Void	Defined as `rnf = absurd`. Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Void -> () #
NFData CBool	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: CBool -> () #
NFData CChar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CChar -> () #
NFData CClock	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CClock -> () #
NFData CDouble	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CDouble -> () #
NFData CFile	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CFile -> () #
NFData CFloat	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CFloat -> () #
NFData CFpos	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CFpos -> () #
NFData CInt	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CInt -> () #
NFData CIntMax	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CIntMax -> () #
NFData CIntPtr	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CIntPtr -> () #
NFData CJmpBuf	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CJmpBuf -> () #
NFData CLLong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CLLong -> () #
NFData CLong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CLong -> () #
NFData CPtrdiff	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CPtrdiff -> () #
NFData CSChar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CSChar -> () #
NFData CSUSeconds	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CSUSeconds -> () #
NFData CShort	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CShort -> () #
NFData CSigAtomic	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CSigAtomic -> () #
NFData CSize	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CSize -> () #
NFData CTime	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CTime -> () #
NFData CUChar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUChar -> () #
NFData CUInt	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUInt -> () #
NFData CUIntMax	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUIntMax -> () #
NFData CUIntPtr	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUIntPtr -> () #
NFData CULLong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CULLong -> () #
NFData CULong	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CULong -> () #
NFData CUSeconds	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUSeconds -> () #
NFData CUShort	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CUShort -> () #
NFData CWchar	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: CWchar -> () #
NFData ThreadId	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: ThreadId -> () #
NFData Fingerprint	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Fingerprint -> () #
NFData MaskingState	Since: deepseq-1.4.4.0
Instance details Defined in Control.DeepSeq Methods rnf :: MaskingState -> () #
NFData ExitCode	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: ExitCode -> () #
NFData Int16
Instance details Defined in Control.DeepSeq Methods rnf :: Int16 -> () #
NFData Int32
Instance details Defined in Control.DeepSeq Methods rnf :: Int32 -> () #
NFData Int64
Instance details Defined in Control.DeepSeq Methods rnf :: Int64 -> () #
NFData Int8
Instance details Defined in Control.DeepSeq Methods rnf :: Int8 -> () #
NFData CallStack	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: CallStack -> () #
NFData SrcLoc	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: SrcLoc -> () #
NFData Word16
Instance details Defined in Control.DeepSeq Methods rnf :: Word16 -> () #
NFData Word32
Instance details Defined in Control.DeepSeq Methods rnf :: Word32 -> () #
NFData Word64
Instance details Defined in Control.DeepSeq Methods rnf :: Word64 -> () #
NFData F2Poly
Instance details Defined in Data.Bit.F2Poly Methods rnf :: F2Poly -> () #
NFData Bit
Instance details Defined in Data.Bit.Internal Methods rnf :: Bit -> () #
NFData ByteString
Instance details Defined in Data.ByteString.Internal Methods rnf :: ByteString -> () #
NFData ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods rnf :: ByteString -> () #
NFData ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods rnf :: ShortByteString -> () #
NFData IntSet
Instance details Defined in Data.IntSet.Internal Methods rnf :: IntSet -> () #
NFData PublicKey
Instance details Defined in Crypto.PubKey.Ed25519 Methods rnf :: PublicKey -> () #
NFData SecretKey
Instance details Defined in Crypto.PubKey.Ed25519 Methods rnf :: SecretKey -> () #
NFData Signature
Instance details Defined in Crypto.PubKey.Ed25519 Methods rnf :: Signature -> () #
NFData Ordering
Instance details Defined in Control.DeepSeq Methods rnf :: Ordering -> () #
NFData TyCon	NOTE: Prior to `deepseq-1.4.4.0` this instance was only defined for `base-4.8.0.0` and later. Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: TyCon -> () #
NFData PairingCtx
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods rnf :: PairingCtx -> () #
NFData Scalar
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods rnf :: Scalar -> () #
NFData SecretKey
Instance details Defined in Crypto.BLST.Internal.Types Methods rnf :: SecretKey -> () #
NFData Never
Instance details Defined in Lorentz.Value Methods rnf :: Never -> () #
NFData InvalidPosException
Instance details Defined in Text.Megaparsec.Pos Methods rnf :: InvalidPosException -> () #
NFData Pos
Instance details Defined in Text.Megaparsec.Pos Methods rnf :: Pos -> () #
NFData SourcePos
Instance details Defined in Text.Megaparsec.Pos Methods rnf :: SourcePos -> () #
NFData SomeDocItem
Instance details Defined in Morley.Michelson.Doc Methods rnf :: SomeDocItem -> () #
NFData ErrorSrcPos
Instance details Defined in Morley.Michelson.ErrorPos Methods rnf :: ErrorSrcPos -> () #
NFData Pos
Instance details Defined in Morley.Michelson.ErrorPos Methods rnf :: Pos -> () #
NFData SrcPos
Instance details Defined in Morley.Michelson.ErrorPos Methods rnf :: SrcPos -> () #
NFData BadViewNameError
Instance details Defined in Morley.Michelson.Internal.ViewName Methods rnf :: BadViewNameError -> () #
NFData ViewName
Instance details Defined in Morley.Michelson.Internal.ViewName Methods rnf :: ViewName -> () #
NFData InterpreterState
Instance details Defined in Morley.Michelson.Interpret Methods rnf :: InterpreterState -> () #
NFData MorleyLogs
Instance details Defined in Morley.Michelson.Interpret Methods rnf :: MorleyLogs -> () #
NFData RemainingSteps
Instance details Defined in Morley.Michelson.Interpret Methods rnf :: RemainingSteps -> () #
NFData CadrStruct
Instance details Defined in Morley.Michelson.Macro Methods rnf :: CadrStruct -> () #
NFData Macro
Instance details Defined in Morley.Michelson.Macro Methods rnf :: Macro -> () #
NFData PairStruct
Instance details Defined in Morley.Michelson.Macro Methods rnf :: PairStruct -> () #
NFData ParsedOp
Instance details Defined in Morley.Michelson.Macro Methods rnf :: ParsedOp -> () #
NFData UnpairStruct
Instance details Defined in Morley.Michelson.Macro Methods rnf :: UnpairStruct -> () #
NFData CustomParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods rnf :: CustomParserException -> () #
NFData StringLiteralParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods rnf :: StringLiteralParserException -> () #
NFData BigMapCounter
Instance details Defined in Morley.Michelson.Runtime.GState Methods rnf :: BigMapCounter -> () #
NFData MText
Instance details Defined in Morley.Michelson.Text Methods rnf :: MText -> () #
NFData ExtError
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods rnf :: ExtError -> () #
NFData StackSize
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods rnf :: StackSize -> () #
NFData TcTypeError
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods rnf :: TcTypeError -> () #
NFData TopLevelType
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods rnf :: TopLevelType -> () #
NFData TypeContext
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods rnf :: TypeContext -> () #
NFData SomeHST
Instance details Defined in Morley.Michelson.TypeCheck.Types Methods rnf :: SomeHST -> () #
NFData MutezArithErrorType
Instance details Defined in Morley.Michelson.Typed.Arith Methods rnf :: MutezArithErrorType -> () #
NFData ShiftArithErrorType
Instance details Defined in Morley.Michelson.Typed.Arith Methods rnf :: ShiftArithErrorType -> () #
NFData ArmCoord
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: ArmCoord -> () #
NFData EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: EpAddress -> () #
NFData ParamEpError
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: ParamEpError -> () #
NFData ParseEpAddressError
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: ParseEpAddressError -> () #
NFData SomeContract
Instance details Defined in Morley.Michelson.Typed.Existential Methods rnf :: SomeContract -> () #
NFData CommentType
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: CommentType -> () #
NFData SomeMeta
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: SomeMeta -> () #
NFData OperationHash
Instance details Defined in Morley.Michelson.Typed.Operation Methods rnf :: OperationHash -> () #
NFData BadTypeForScope
Instance details Defined in Morley.Michelson.Typed.Scope Methods rnf :: BadTypeForScope -> () #
NFData T
Instance details Defined in Morley.Michelson.Typed.T Methods rnf :: T -> () #
NFData SetDelegate
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: SetDelegate -> () #
NFData AnyAnn
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods rnf :: AnyAnn -> () #
NFData VarAnns
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods rnf :: VarAnns -> () #
NFData EntriesOrder
Instance details Defined in Morley.Michelson.Untyped.Contract Methods rnf :: EntriesOrder -> () #
NFData Entry
Instance details Defined in Morley.Michelson.Untyped.Contract Methods rnf :: Entry -> () #
NFData EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods rnf :: EpName -> () #
NFData EpNameFromRefAnnError
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods rnf :: EpNameFromRefAnnError -> () #
NFData PrintComment
Instance details Defined in Morley.Michelson.Untyped.Ext Methods rnf :: PrintComment -> () #
NFData StackRef
Instance details Defined in Morley.Michelson.Untyped.Ext Methods rnf :: StackRef -> () #
NFData StackTypePattern
Instance details Defined in Morley.Michelson.Untyped.Ext Methods rnf :: StackTypePattern -> () #
NFData TyVar
Instance details Defined in Morley.Michelson.Untyped.Ext Methods rnf :: TyVar -> () #
NFData Var
Instance details Defined in Morley.Michelson.Untyped.Ext Methods rnf :: Var -> () #
NFData ExpandedOp
Instance details Defined in Morley.Michelson.Untyped.Instr Methods rnf :: ExpandedOp -> () #
NFData ParameterType
Instance details Defined in Morley.Michelson.Untyped.Type Methods rnf :: ParameterType -> () #
NFData T
Instance details Defined in Morley.Michelson.Untyped.Type Methods rnf :: T -> () #
NFData Ty
Instance details Defined in Morley.Michelson.Untyped.Type Methods rnf :: Ty -> () #
NFData InternalByteString
Instance details Defined in Morley.Michelson.Untyped.Value Methods rnf :: InternalByteString -> () #
NFData GlobalCounter
Instance details Defined in Morley.Tezos.Address Methods rnf :: GlobalCounter -> () #
NFData ParseAddressError
Instance details Defined in Morley.Tezos.Address Methods rnf :: ParseAddressError -> () #
NFData ParseAddressRawError
Instance details Defined in Morley.Tezos.Address Methods rnf :: ParseAddressRawError -> () #
NFData AddressKind
Instance details Defined in Morley.Tezos.Address.Kinds Methods rnf :: AddressKind -> () #
NFData ChainId
Instance details Defined in Morley.Tezos.Core Methods rnf :: ChainId -> () #
NFData Mutez
Instance details Defined in Morley.Tezos.Core Methods rnf :: Mutez -> () #
NFData Timestamp
Instance details Defined in Morley.Tezos.Core Methods rnf :: Timestamp -> () #
NFData KeyType
Instance details Defined in Morley.Tezos.Crypto Methods rnf :: KeyType -> () #
NFData PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods rnf :: PublicKey -> () #
NFData SecretKey
Instance details Defined in Morley.Tezos.Crypto Methods rnf :: SecretKey -> () #
NFData Signature
Instance details Defined in Morley.Tezos.Crypto Methods rnf :: Signature -> () #
NFData PublicKey
Instance details Defined in Morley.Tezos.Crypto.BLS Methods rnf :: PublicKey -> () #
NFData SecretKey
Instance details Defined in Morley.Tezos.Crypto.BLS Methods rnf :: SecretKey -> () #
NFData Signature
Instance details Defined in Morley.Tezos.Crypto.BLS Methods rnf :: Signature -> () #
NFData Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods rnf :: Bls12381Fr -> () #
NFData Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods rnf :: Bls12381G1 -> () #
NFData Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods rnf :: Bls12381G2 -> () #
NFData DeserializationError
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods rnf :: DeserializationError -> () #
NFData PublicKey
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Methods rnf :: PublicKey -> () #
NFData SecretKey
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Methods rnf :: SecretKey -> () #
NFData Signature
Instance details Defined in Morley.Tezos.Crypto.Ed25519 Methods rnf :: Signature -> () #
NFData PublicKey
Instance details Defined in Morley.Tezos.Crypto.P256 Methods rnf :: PublicKey -> () #
NFData SecretKey
Instance details Defined in Morley.Tezos.Crypto.P256 Methods rnf :: SecretKey -> () #
NFData Signature
Instance details Defined in Morley.Tezos.Crypto.P256 Methods rnf :: Signature -> () #
NFData PublicKey
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Methods rnf :: PublicKey -> () #
NFData SecretKey
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Methods rnf :: SecretKey -> () #
NFData Signature
Instance details Defined in Morley.Tezos.Crypto.Secp256k1 Methods rnf :: Signature -> () #
NFData Chest
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods rnf :: Chest -> () #
NFData ChestKey
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods rnf :: ChestKey -> () #
NFData Ciphertext
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods rnf :: Ciphertext -> () #
NFData Locked
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods rnf :: Locked -> () #
NFData Nonce
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods rnf :: Nonce -> () #
NFData Proof
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods rnf :: Proof -> () #
NFData PublicModulus
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods rnf :: PublicModulus -> () #
NFData Unlocked
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods rnf :: Unlocked -> () #
NFData CryptoParseError
Instance details Defined in Morley.Tezos.Crypto.Util Methods rnf :: CryptoParseError -> () #
NFData HexJSONByteString
Instance details Defined in Morley.Util.ByteString Methods rnf :: HexJSONByteString -> () #
NFData TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods rnf :: TextDetails -> () #
NFData Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods rnf :: Doc -> () #
NFData ByteArray
Instance details Defined in Data.Primitive.ByteArray Methods rnf :: ByteArray -> () #
NFData StdGen
Instance details Defined in System.Random.Internal Methods rnf :: StdGen -> () #
NFData Scientific
Instance details Defined in Data.Scientific Methods rnf :: Scientific -> () #
NFData UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods rnf :: UnicodeException -> () #
NFData ShortText
Instance details Defined in Data.Text.Short.Internal Methods rnf :: ShortText -> () #
NFData NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods rnf :: NominalDiffTime -> () #
NFData UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods rnf :: UTCTime -> () #
NFData LocalTime
Instance details Defined in Data.Time.LocalTime.Internal.LocalTime Methods rnf :: LocalTime -> () #
NFData ZonedTime
Instance details Defined in Data.Time.LocalTime.Internal.ZonedTime Methods rnf :: ZonedTime -> () #
NFData UUID
Instance details Defined in Data.UUID.Types.Internal Methods rnf :: UUID -> () #
NFData Word8
Instance details Defined in Control.DeepSeq Methods rnf :: Word8 -> () #
NFData Integer
Instance details Defined in Control.DeepSeq Methods rnf :: Integer -> () #
NFData Natural	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Natural -> () #
NFData ()
Instance details Defined in Control.DeepSeq Methods rnf :: () -> () #
NFData Bool
Instance details Defined in Control.DeepSeq Methods rnf :: Bool -> () #
NFData Char
Instance details Defined in Control.DeepSeq Methods rnf :: Char -> () #
NFData Double
Instance details Defined in Control.DeepSeq Methods rnf :: Double -> () #
NFData Float
Instance details Defined in Control.DeepSeq Methods rnf :: Float -> () #
NFData Int
Instance details Defined in Control.DeepSeq Methods rnf :: Int -> () #
NFData Word
Instance details Defined in Control.DeepSeq Methods rnf :: Word -> () #
NFData v => NFData (KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods rnf :: KeyMap v -> () #
NFData a => NFData (IResult a)
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: IResult a -> () #
NFData a => NFData (Result a)
Instance details Defined in Data.Aeson.Types.Internal Methods rnf :: Result a -> () #
NFData a => NFData (ZipList a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: ZipList a -> () #
NFData a => NFData (Complex a)
Instance details Defined in Control.DeepSeq Methods rnf :: Complex a -> () #
NFData a => NFData (Identity a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Identity a -> () #
NFData a => NFData (First a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: First a -> () #
NFData a => NFData (Last a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Last a -> () #
NFData a => NFData (Down a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Down a -> () #
NFData a => NFData (First a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: First a -> () #
NFData a => NFData (Last a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Last a -> () #
NFData a => NFData (Max a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Max a -> () #
NFData a => NFData (Min a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Min a -> () #
NFData a => NFData (Option a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Option a -> () #
NFData m => NFData (WrappedMonoid m)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: WrappedMonoid m -> () #
NFData a => NFData (Dual a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Dual a -> () #
NFData a => NFData (Product a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Product a -> () #
NFData a => NFData (Sum a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Sum a -> () #
NFData a => NFData (NonEmpty a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: NonEmpty a -> () #
NFData (IORef a)	NOTE: Only strict in the reference and not the referenced value. Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: IORef a -> () #
NFData (MVar a)	NOTE: Only strict in the reference and not the referenced value. Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: MVar a -> () #
NFData (FunPtr a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: FunPtr a -> () #
NFData (Ptr a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Ptr a -> () #
NFData a => NFData (Ratio a)
Instance details Defined in Control.DeepSeq Methods rnf :: Ratio a -> () #
NFData (StableName a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: StableName a -> () #
NFData (Dict c)
Instance details Defined in Data.Constraint Methods rnf :: Dict c -> () #
NFData a => NFData (SCC a)
Instance details Defined in Data.Graph Methods rnf :: SCC a -> () #
NFData a => NFData (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods rnf :: IntMap a -> () #
NFData a => NFData (Digit a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: Digit a -> () #
NFData a => NFData (Elem a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: Elem a -> () #
NFData a => NFData (FingerTree a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: FingerTree a -> () #
NFData a => NFData (Node a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: Node a -> () #
NFData a => NFData (Seq a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: Seq a -> () #
NFData a => NFData (Set a)
Instance details Defined in Data.Set.Internal Methods rnf :: Set a -> () #
NFData a => NFData (Tree a)
Instance details Defined in Data.Tree Methods rnf :: Tree a -> () #
NFData1 f => NFData (Fix f)
Instance details Defined in Data.Fix Methods rnf :: Fix f -> () #
NFData a => NFData (DNonEmpty a)
Instance details Defined in Data.DList.DNonEmpty.Internal Methods rnf :: DNonEmpty a -> () #
NFData a => NFData (DList a)
Instance details Defined in Data.DList.Internal Methods rnf :: DList a -> () #
NFData (Binary p)
Instance details Defined in Data.Field.Galois.Binary Methods rnf :: Binary p -> () #
NFData (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods rnf :: Prime p -> () #
NFData a => NFData (Hashed a)
Instance details Defined in Data.Hashable.Class Methods rnf :: Hashed a -> () #
NFData (Affine a)
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods rnf :: Affine a -> () #
NFData (Point a)
Instance details Defined in Crypto.BLST.Internal.Bindings.Types Methods rnf :: Point a -> () #
NFData (PublicKey c)
Instance details Defined in Crypto.BLST.Internal.Types Methods rnf :: PublicKey c -> () #
NFData a => NFData (ErrorFancy a)
Instance details Defined in Text.Megaparsec.Error Methods rnf :: ErrorFancy a -> () #
NFData t => NFData (ErrorItem t)
Instance details Defined in Text.Megaparsec.Error Methods rnf :: ErrorItem t -> () #
NFData s => NFData (PosState s)
Instance details Defined in Text.Megaparsec.State Methods rnf :: PosState s -> () #
NFData (Mod m)
Instance details Defined in Data.Mod Methods rnf :: Mod m -> () #
NFData a => NFData (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods rnf :: StringEncode a -> () #
NFData a => NFData (ViewsSetF a)
Instance details Defined in Morley.Michelson.Internal.ViewsSet Methods rnf :: ViewsSetF a -> () #
NFData ext => NFData (MichelsonFailed ext)
Instance details Defined in Morley.Michelson.Interpret Methods rnf :: MichelsonFailed ext -> () #
NFData ext => NFData (MichelsonFailureWithStack ext)
Instance details Defined in Morley.Michelson.Interpret Methods rnf :: MichelsonFailureWithStack ext -> () #
NFData res => NFData (ResultStateLogs res)
Instance details Defined in Morley.Michelson.Interpret Methods rnf :: ResultStateLogs res -> () #
(NFData op, NFData (TypeCheckedOp op)) => NFData (TcError' op)
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods rnf :: TcError' op -> () #
(NFData (TypeCheckedOp op), NFData op) => NFData (IllTypedInstr op)
Instance details Defined in Morley.Michelson.TypeCheck.TypeCheckedOp Methods rnf :: IllTypedInstr op -> () #
NFData op => NFData (TypeCheckedOp op)
Instance details Defined in Morley.Michelson.TypeCheck.TypeCheckedOp Methods rnf :: TypeCheckedOp op -> () #
NFData (HST ts)
Instance details Defined in Morley.Michelson.TypeCheck.Types Methods rnf :: HST ts -> () #
NFData (Anns xs)
Instance details Defined in Morley.Michelson.Typed.Annotation Methods rnf :: Anns xs -> () #
NFData (Notes t)
Instance details Defined in Morley.Michelson.Typed.Annotation Methods rnf :: Notes t -> () #
NFData (ParamNotes t)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: ParamNotes t -> () #
NFData (SomeEntrypointCallT arg)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: SomeEntrypointCallT arg -> () #
NFData (ExtInstr s)
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: ExtInstr s -> () #
NFData (PrintComment st)
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: PrintComment st -> () #
NFData (StackRef st)
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: StackRef st -> () #
NFData (TestAssert s)
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: TestAssert s -> () #
NFData (SingT a)
Instance details Defined in Morley.Michelson.Typed.Sing Methods rnf :: SingT a -> () #
NFData (Operation' instr)
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: Operation' instr -> () #
(forall (i :: [T]) (o :: [T]). NFData (instr i o)) => NFData (SomeViewsSet' instr)
Instance details Defined in Morley.Michelson.Typed.View Methods rnf :: SomeViewsSet' instr -> () #
NFData op => NFData (Contract' op)
Instance details Defined in Morley.Michelson.Untyped.Contract Methods rnf :: Contract' op -> () #
NFData op => NFData (ExtInstrAbstract op)
Instance details Defined in Morley.Michelson.Untyped.Ext Methods rnf :: ExtInstrAbstract op -> () #
NFData op => NFData (TestAssert op)
Instance details Defined in Morley.Michelson.Untyped.Ext Methods rnf :: TestAssert op -> () #
NFData op => NFData (InstrAbstract op)
Instance details Defined in Morley.Michelson.Untyped.Instr Methods rnf :: InstrAbstract op -> () #
NFData op => NFData (Elt op)
Instance details Defined in Morley.Michelson.Untyped.Value Methods rnf :: Elt op -> () #
NFData op => NFData (Value' op)
Instance details Defined in Morley.Michelson.Untyped.Value Methods rnf :: Value' op -> () #
NFData op => NFData (View' op)
Instance details Defined in Morley.Michelson.Untyped.View Methods rnf :: View' op -> () #
NFData instr => NFData (ViewsSet instr)
Instance details Defined in Morley.Michelson.Untyped.View Methods rnf :: ViewsSet instr -> () #
NFData (KindedAddress kind)
Instance details Defined in Morley.Tezos.Address Methods rnf :: KindedAddress kind -> () #
NFData (Alias kind)
Instance details Defined in Morley.Tezos.Address.Alias Methods rnf :: Alias kind -> () #
NFData (Hash kind)
Instance details Defined in Morley.Tezos.Crypto Methods rnf :: Hash kind -> () #
NFData (HashTag kind)
Instance details Defined in Morley.Tezos.Crypto Methods rnf :: HashTag kind -> () #
NFData a => NFData (MismatchError a)
Instance details Defined in Morley.Util.MismatchError Methods rnf :: MismatchError a -> () #
NFData (SingNat n)
Instance details Defined in Morley.Util.Peano Methods rnf :: SingNat n -> () #
NFData (PeanoNatural n)
Instance details Defined in Morley.Util.PeanoNatural Methods rnf :: PeanoNatural n -> () #
NFData a => NFData (AnnotDetails a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods rnf :: AnnotDetails a -> () #
NFData a => NFData (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods rnf :: Doc a -> () #
NFData a => NFData (Array a)
Instance details Defined in Data.Primitive.Array Methods rnf :: Array a -> () #
NFData (MutableByteArray s)
Instance details Defined in Data.Primitive.ByteArray Methods rnf :: MutableByteArray s -> () #
NFData (PrimArray a)
Instance details Defined in Data.Primitive.PrimArray Methods rnf :: PrimArray a -> () #
NFData a => NFData (SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods rnf :: SmallArray a -> () #
NFData g => NFData (StateGen g)
Instance details Defined in System.Random.Internal Methods rnf :: StateGen g -> () #
NFData g => NFData (AtomicGen g)
Instance details Defined in System.Random.Stateful Methods rnf :: AtomicGen g -> () #
NFData g => NFData (IOGen g)
Instance details Defined in System.Random.Stateful Methods rnf :: IOGen g -> () #
NFData g => NFData (STGen g)
Instance details Defined in System.Random.Stateful Methods rnf :: STGen g -> () #
NFData g => NFData (TGen g)
Instance details Defined in System.Random.Stateful Methods rnf :: TGen g -> () #
NFData a => NFData (Maybe a)
Instance details Defined in Data.Strict.Maybe Methods rnf :: Maybe a -> () #
NFData a => NFData (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods rnf :: HashSet a -> () #
NFData a => NFData (Vector a)
Instance details Defined in Data.Vector Methods rnf :: Vector a -> () #
NFData (Vector a)
Instance details Defined in Data.Vector.Primitive Methods rnf :: Vector a -> () #
NFData (Vector a)
Instance details Defined in Data.Vector.Storable Methods rnf :: Vector a -> () #
NFData (Vector a)
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: Vector a -> () #
NFData a => NFData (Maybe a)
Instance details Defined in Control.DeepSeq Methods rnf :: Maybe a -> () #
NFData a => NFData [a]
Instance details Defined in Control.DeepSeq Methods rnf :: [a] -> () #
(NFData i, NFData r) => NFData (IResult i r)
Instance details Defined in Data.Attoparsec.Internal.Types Methods rnf :: IResult i r -> () #
(NFData a, NFData b) => NFData (Either a b)
Instance details Defined in Control.DeepSeq Methods rnf :: Either a b -> () #
NFData (Fixed a)	Since: deepseq-1.3.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Fixed a -> () #
NFData (Proxy a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Proxy a -> () #
(NFData a, NFData b) => NFData (Arg a b)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Arg a b -> () #
(NFData a, NFData b) => NFData (Array a b)
Instance details Defined in Control.DeepSeq Methods rnf :: Array a b -> () #
NFData (STRef s a)	NOTE: Only strict in the reference and not the referenced value. Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: STRef s a -> () #
(NFData a, NFData b) => NFData (Bimap a b)
Instance details Defined in Data.Bimap Methods rnf :: Bimap a b -> () #
a => NFData (a :- b)
Instance details Defined in Data.Constraint Methods rnf :: (a :- b) -> () #
(NFData k, NFData a) => NFData (Map k a)
Instance details Defined in Data.Map.Internal Methods rnf :: Map k a -> () #
NFData k => NFData (Extension p k)
Instance details Defined in Data.Field.Galois.Extension Methods rnf :: Extension p k -> () #
NFData k => NFData (RootsOfUnity n k)
Instance details Defined in Data.Field.Galois.Unity Methods rnf :: RootsOfUnity n k -> () #
NFData (Signature c m)
Instance details Defined in Crypto.BLST.Internal.Types Methods rnf :: Signature c m -> () #
NFData (i :-> o)
Instance details Defined in Lorentz.Base Methods rnf :: (i :-> o) -> () #
NFData (ContractCode cp st)
Instance details Defined in Lorentz.Base Methods rnf :: ContractCode cp st -> () #
(NFData (Token s), NFData e) => NFData (ParseError s e)
Instance details Defined in Text.Megaparsec.Error Methods rnf :: ParseError s e -> () #
(NFData s, NFData (Token s), NFData e) => NFData (ParseErrorBundle s e)
Instance details Defined in Text.Megaparsec.Error Methods rnf :: ParseErrorBundle s e -> () #
(NFData s, NFData (ParseError s e)) => NFData (State s e)
Instance details Defined in Text.Megaparsec.State Methods rnf :: State s e -> () #
(NFData n, NFData m) => NFData (ArithError n m)
Instance details Defined in Morley.Michelson.Typed.Arith Methods rnf :: ArithError n m -> () #
NFData (EntrypointCallT param arg)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: EntrypointCallT param arg -> () #
NFData (EpLiftSequence arg param)
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: EpLiftSequence arg param -> () #
NFData (Instr inp out)
Instance details Defined in Morley.Michelson.Typed.Instr Methods rnf :: Instr inp out -> () #
NFData (Emit instr t)
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: Emit instr t -> () #
NFData (TransferTokens instr p)
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: TransferTokens instr p -> () #
NFData (Value' instr t)
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: Value' instr t -> () #
(forall (arg :: T) (ret :: T). NFData (ViewCode' instr arg st ret)) => NFData (SomeView' instr st)
Instance details Defined in Morley.Michelson.Typed.View Methods rnf :: SomeView' instr st -> () #
(forall (i :: [T]) (o :: [T]). NFData (instr i o)) => NFData (ViewsSet' instr st)
Instance details Defined in Morley.Michelson.Typed.View Methods rnf :: ViewsSet' instr st -> () #
NFData (Annotation tag)
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods rnf :: Annotation tag -> () #
NFData (v a) => NFData (Poly v a)
Instance details Defined in Data.Poly.Internal.Dense Methods rnf :: Poly v a -> () #
NFData (MutablePrimArray s a)
Instance details Defined in Data.Primitive.PrimArray Methods rnf :: MutablePrimArray s a -> () #
(NFData a, NFData b) => NFData (Either a b)
Instance details Defined in Data.Strict.Either Methods rnf :: Either a b -> () #
(NFData a, NFData b) => NFData (These a b)
Instance details Defined in Data.Strict.These Methods rnf :: These a b -> () #
(NFData a, NFData b) => NFData (Pair a b)
Instance details Defined in Data.Strict.Tuple Methods rnf :: Pair a b -> () #
(NFData a, NFData b) => NFData (These a b)	Since: these-0.7.1
Instance details Defined in Data.These Methods rnf :: These a b -> () #
(NFData k, NFData v) => NFData (HashMap k v)
Instance details Defined in Data.HashMap.Internal Methods rnf :: HashMap k v -> () #
(NFData k, NFData v) => NFData (Leaf k v)
Instance details Defined in Data.HashMap.Internal Methods rnf :: Leaf k v -> () #
NFData (MVector s a)
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: MVector s a -> () #
NFData (a -> b)	This instance is for convenience and consistency with `seq`. This assumes that WHNF is equivalent to NF for functions. Since: deepseq-1.3.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: (a -> b) -> () #
(NFData a, NFData b) => NFData (a, b)
Instance details Defined in Control.DeepSeq Methods rnf :: (a, b) -> () #
NFData a => NFData (Const a b)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Const a b -> () #
NFData (a :~: b)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: (a :~: b) -> () #
NFData (Contract cp st vd)
Instance details Defined in Lorentz.Base Methods rnf :: Contract cp st vd -> () #
(forall (i :: [T]) (o :: [T]). NFData (instr i o)) => NFData (Contract' instr cp st)
Instance details Defined in Morley.Michelson.Typed.Contract Methods rnf :: Contract' instr cp st -> () #
NFData (instr (ContractInp cp st) (ContractOut st)) => NFData (ContractCode' instr cp st)
Instance details Defined in Morley.Michelson.Typed.Contract Methods rnf :: ContractCode' instr cp st -> () #
(forall (i :: [T]) (o :: [T]). NFData (instr i o)) => NFData (CreateContract instr cp st)
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: CreateContract instr cp st -> () #
NFData (LambdaCode' instr inp out)
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: LambdaCode' instr inp out -> () #
(forall (a :: k). c a => NFData (f a)) => NFData (Constrained c f)
Instance details Defined in Morley.Util.Constrained Methods rnf :: Constrained c f -> () #
NFData b => NFData (Tagged s b)
Instance details Defined in Data.Tagged Methods rnf :: Tagged s b -> () #
(NFData1 f, NFData1 g, NFData a) => NFData (These1 f g a)	This instance is available only with `deepseq >= 1.4.3.0`
Instance details Defined in Data.Functor.These Methods rnf :: These1 f g a -> () #
ReifyConstraint NFData f xs => NFData (Rec f xs)
Instance details Defined in Data.Vinyl.Core Methods rnf :: Rec f xs -> () #
(NFData a1, NFData a2, NFData a3) => NFData (a1, a2, a3)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3) -> () #
(NFData1 f, NFData1 g, NFData a) => NFData (Product f g a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: Product f g a -> () #
(NFData1 f, NFData1 g, NFData a) => NFData (Sum f g a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: Sum f g a -> () #
NFData (a :~~: b)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: (a :~~: b) -> () #
(forall (o' :: k). NFData (instr i o')) => NFData (RemFail instr i o)
Instance details Defined in Morley.Michelson.Typed.Value Methods rnf :: RemFail instr i o -> () #
NFData (ViewCode' instr arg st ret) => NFData (View' instr arg st ret)
Instance details Defined in Morley.Michelson.Typed.View Methods rnf :: View' instr arg st ret -> () #
(NFData a1, NFData a2, NFData a3, NFData a4) => NFData (a1, a2, a3, a4)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4) -> () #
(NFData1 f, NFData1 g, NFData a) => NFData (Compose f g a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: Compose f g a -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5) => NFData (a1, a2, a3, a4, a5)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4, a5) -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6) => NFData (a1, a2, a3, a4, a5, a6)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4, a5, a6) -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7) => NFData (a1, a2, a3, a4, a5, a6, a7)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4, a5, a6, a7) -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8) => NFData (a1, a2, a3, a4, a5, a6, a7, a8)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4, a5, a6, a7, a8) -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8, NFData a9) => NFData (a1, a2, a3, a4, a5, a6, a7, a8, a9)
Instance details Defined in Control.DeepSeq Methods rnf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> () #

data Set a #

A set of values a.

Instances

Instances details

Foldable Set	Folds in order of increasing key.
Instance details Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m # foldMap :: Monoid m => (a -> m) -> Set a -> m # foldMap' :: Monoid m => (a -> m) -> Set a -> m # foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b # foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b # foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # toList :: Set a -> [a] # null :: Set a -> Bool # length :: Set a -> Int # elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # minimum :: Ord a => Set a -> a # sum :: Num a => Set a -> a # product :: Num a => Set a -> a #
Eq1 Set	Since: containers-0.5.9
Instance details Defined in Data.Set.Internal Methods liftEq :: (a -> b -> Bool) -> Set a -> Set b -> Bool #
Ord1 Set	Since: containers-0.5.9
Instance details Defined in Data.Set.Internal Methods liftCompare :: (a -> b -> Ordering) -> Set a -> Set b -> Ordering #
Show1 Set	Since: containers-0.5.9
Instance details Defined in Data.Set.Internal Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Set a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Set a] -> ShowS #
Hashable1 Set	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Set a -> Int #
(NiceComparable a, NiceComparable b) => LorentzFunctor Set a b
Instance details Defined in Lorentz.Instr Methods lmap :: forall (s :: [Type]). KnownValue b => ('[a] :-> '[b]) -> (Set a ': s) :-> (Set b ': s) #
Structured k => Structured (Set k)
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy (Set k) -> Structure # structureHash' :: Tagged (Set k) MD5
(Data a, Ord a) => Data (Set a)
Instance details Defined in Data.Set.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Set a -> c (Set a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Set a) # toConstr :: Set a -> Constr # dataTypeOf :: Set a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Set a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Set a)) # gmapT :: (forall b. Data b => b -> b) -> Set a -> Set a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r # gmapQ :: (forall d. Data d => d -> u) -> Set a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Set a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) #
Ord a => Monoid (Set a)
Instance details Defined in Data.Set.Internal Methods mempty :: Set a # mappend :: Set a -> Set a -> Set a # mconcat :: [Set a] -> Set a #
Ord a => Semigroup (Set a)	Since: containers-0.5.7
Instance details Defined in Data.Set.Internal Methods (<>) :: Set a -> Set a -> Set a # sconcat :: NonEmpty (Set a) -> Set a # stimes :: Integral b => b -> Set a -> Set a #
Ord a => IsList (Set a)	Since: containers-0.5.6.2
Instance details Defined in Data.Set.Internal Associated Types type Item (Set a) # Methods fromList :: [Item (Set a)] -> Set a # fromListN :: Int -> [Item (Set a)] -> Set a # toList :: Set a -> [Item (Set a)] #
(Read a, Ord a) => Read (Set a)
Instance details Defined in Data.Set.Internal Methods readsPrec :: Int -> ReadS (Set a) # readList :: ReadS [Set a] # readPrec :: ReadPrec (Set a) # readListPrec :: ReadPrec [Set a] #
Show a => Show (Set a)
Instance details Defined in Data.Set.Internal Methods showsPrec :: Int -> Set a -> ShowS # show :: Set a -> String # showList :: [Set a] -> ShowS #
NFData a => NFData (Set a)
Instance details Defined in Data.Set.Internal Methods rnf :: Set a -> () #
Eq a => Eq (Set a)
Instance details Defined in Data.Set.Internal Methods (==) :: Set a -> Set a -> Bool # (/=) :: Set a -> Set a -> Bool #
Ord a => Ord (Set a)
Instance details Defined in Data.Set.Internal Methods compare :: Set a -> Set a -> Ordering # (<) :: Set a -> Set a -> Bool # (<=) :: Set a -> Set a -> Bool # (>) :: Set a -> Set a -> Bool # (>=) :: Set a -> Set a -> Bool # max :: Set a -> Set a -> Set a # min :: Set a -> Set a -> Set a #
Hashable v => Hashable (Set v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Set v -> Int # hash :: Set v -> Int #
Ord k => At (Set k)
Instance details Defined in Control.Lens.At Methods at :: Index (Set k) -> Lens' (Set k) (Maybe (IxValue (Set k))) #
Ord a => Contains (Set a)
Instance details Defined in Control.Lens.At Methods contains :: Index (Set a) -> Lens' (Set a) Bool #
Ord k => Ixed (Set k)
Instance details Defined in Control.Lens.At Methods ix :: Index (Set k) -> Traversal' (Set k) (IxValue (Set k)) #
Ord a => Wrapped (Set a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Set a) # Methods _Wrapped' :: Iso' (Set a) (Unwrapped (Set a)) #
KnownIsoT v => HasAnnotation (Set v)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Set v)) # annOptions :: Maybe AnnOptions #
NiceComparable e => IterOpHs (Set e)
Instance details Defined in Lorentz.Polymorphic Associated Types type IterOpElHs (Set e) #
NiceComparable e => MemOpHs (Set e)
Instance details Defined in Lorentz.Polymorphic Associated Types type MemOpKeyHs (Set e) #
SizeOpHs (Set a)
Instance details Defined in Lorentz.Polymorphic
NiceComparable a => UpdOpHs (Set a)
Instance details Defined in Lorentz.Polymorphic Associated Types type UpdOpKeyHs (Set a) # type UpdOpParamsHs (Set a) #
HasRPCRepr (Set a)
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (Set a) #
PolyCTypeHasDocC '[a] => TypeHasDoc (Set a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Set a) :: FieldDescriptions # Methods typeDocName :: Proxy (Set a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Set a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Set a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Set a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Set a) #
(Comparable (ToT c), Ord c, IsoValue c) => IsoValue (Set c)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Set c) :: T # Methods toVal :: Set c -> Value (ToT (Set c)) # fromVal :: Value (ToT (Set c)) -> Set c #
(Ord a, Monoid a) => Semiring (Set a)	The multiplication laws are satisfied for any underlying `Monoid`, so we require a `Monoid` constraint instead of a `Semiring` constraint since `times` can use the context of either.
Instance details Defined in Data.Semiring Methods plus :: Set a -> Set a -> Set a # zero :: Set a # times :: Set a -> Set a -> Set a # one :: Set a # fromNatural :: Natural -> Set a #
Ord v => Container (Set v)
Instance details Defined in Universum.Container.Class Associated Types type Element (Set v) # Methods toList :: Set v -> [Element (Set v)] # null :: Set v -> Bool # foldr :: (Element (Set v) -> b -> b) -> b -> Set v -> b # foldl :: (b -> Element (Set v) -> b) -> b -> Set v -> b # foldl' :: (b -> Element (Set v) -> b) -> b -> Set v -> b # length :: Set v -> Int # elem :: Element (Set v) -> Set v -> Bool # foldMap :: Monoid m => (Element (Set v) -> m) -> Set v -> m # fold :: Set v -> Element (Set v) # foldr' :: (Element (Set v) -> b -> b) -> b -> Set v -> b # notElem :: Element (Set v) -> Set v -> Bool # all :: (Element (Set v) -> Bool) -> Set v -> Bool # any :: (Element (Set v) -> Bool) -> Set v -> Bool # and :: Set v -> Bool # or :: Set v -> Bool # find :: (Element (Set v) -> Bool) -> Set v -> Maybe (Element (Set v)) # safeHead :: Set v -> Maybe (Element (Set v)) # safeMaximum :: Set v -> Maybe (Element (Set v)) # safeMinimum :: Set v -> Maybe (Element (Set v)) # safeFoldr1 :: (Element (Set v) -> Element (Set v) -> Element (Set v)) -> Set v -> Maybe (Element (Set v)) # safeFoldl1 :: (Element (Set v) -> Element (Set v) -> Element (Set v)) -> Set v -> Maybe (Element (Set v)) #
Ord a => FromList (Set a)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (Set a) # type FromListC (Set a) # Methods fromList :: [ListElement (Set a)] -> Set a #
One (Set v)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Set v) # Methods one :: OneItem (Set v) -> Set v #
(t ~ Set a', Ord a) => Rewrapped (Set a) t	Use `wrapping fromList`. unwrapping returns a sorted list.
Instance details Defined in Control.Lens.Wrapped
CanCastTo k1 k2 => CanCastTo (Set k1 :: Type) (Set k2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Set k1) -> Proxy (Set k2) -> () #
(NiceComparable key, Ord key, Dupable key) => StoreHasSubmap (Set key) SelfRef key ()
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (Set key) SelfRef key () #
type Item (Set a)
Instance details Defined in Data.Set.Internal type Item (Set a) = a
type Index (Set a)
Instance details Defined in Control.Lens.At type Index (Set a) = a
type IxValue (Set k)
Instance details Defined in Control.Lens.At type IxValue (Set k) = ()
type Unwrapped (Set a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Set a) = [a]
type IterOpElHs (Set e)
Instance details Defined in Lorentz.Polymorphic type IterOpElHs (Set e) = e
type MemOpKeyHs (Set e)
Instance details Defined in Lorentz.Polymorphic type MemOpKeyHs (Set e) = e
type UpdOpKeyHs (Set a)
Instance details Defined in Lorentz.Polymorphic type UpdOpKeyHs (Set a) = a
type UpdOpParamsHs (Set a)
Instance details Defined in Lorentz.Polymorphic type UpdOpParamsHs (Set a) = Bool
type AsRPC (Set a)
Instance details Defined in Morley.AsRPC type AsRPC (Set a) = Set a
type TypeDocFieldDescriptions (Set a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Set a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (Set c)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Set c) = 'TSet (ToT c)
type Element (Set v)
Instance details Defined in Universum.Container.Class type Element (Set v) = ElementDefault (Set v)
type FromListC (Set a)
Instance details Defined in Universum.Container.Class type FromListC (Set a) = ()
type ListElement (Set a)
Instance details Defined in Universum.Container.Class type ListElement (Set a) = Item (Set a)
type OneItem (Set v)
Instance details Defined in Universum.Container.Class type OneItem (Set v) = v

data Map k a #

A Map from keys k to values a.

The Semigroup operation for Map is union, which prefers values from the left operand. If m1 maps a key k to a value a1, and m2 maps the same key to a different value a2, then their union m1 <> m2 maps k to a1.

Instances

Instances details

Bifoldable Map	Since: containers-0.6.3.1
Instance details Defined in Data.Map.Internal Methods bifold :: Monoid m => Map m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Map a b -> m # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Map a b -> c # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Map a b -> c #
Eq2 Map	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Map a c -> Map b d -> Bool #
Ord2 Map	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Map a c -> Map b d -> Ordering #
Show2 Map	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Map a b -> ShowS # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Map a b] -> ShowS #
Hashable2 Map	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Map a b -> Int #
MapInstrs Map
Instance details Defined in Lorentz.Macro Methods mapUpdate :: forall k v (s :: [Type]). NiceComparable k => (k ': (Maybe v ': (Map k v ': s))) :-> (Map k v ': s) mapInsert :: forall k v (s :: [Type]). NiceComparable k => (k ': (v ': (Map k v ': s))) :-> (Map k v ': s) # mapInsertNew :: forall k v e (s :: [Type]). (IsoValue (Map k v), NiceComparable k, NiceConstant e, Dupable k, KnownValue v) => (forall (s0 :: [Type]). (k ': s0) :-> (e ': s0)) -> (k ': (v ': (Map k v ': s))) :-> (Map k v ': s) # deleteMap :: forall k v (s :: [Type]). (NiceComparable k, KnownValue v) => (k ': (Map k v ': s)) :-> (Map k v ': s) #
Foldable (Map k)	Folds in order of increasing key.
Instance details Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m # foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldMap' :: Monoid m => (a -> m) -> Map k a -> m # foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b # foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b # foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # toList :: Map k a -> [a] # null :: Map k a -> Bool # length :: Map k a -> Int # elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # sum :: Num a => Map k a -> a # product :: Num a => Map k a -> a #
Eq k => Eq1 (Map k)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftEq :: (a -> b -> Bool) -> Map k a -> Map k b -> Bool #
Ord k => Ord1 (Map k)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftCompare :: (a -> b -> Ordering) -> Map k a -> Map k b -> Ordering #
(Ord k, Read k) => Read1 (Map k)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Map k a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Map k a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Map k a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Map k a] #
Show k => Show1 (Map k)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Map k a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Map k a] -> ShowS #
Traversable (Map k)	Traverses in order of increasing key.
Instance details Defined in Data.Map.Internal Methods traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) # sequenceA :: Applicative f => Map k (f a) -> f (Map k a) # mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) # sequence :: Monad m => Map k (m a) -> m (Map k a) #
Functor (Map k)
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> Map k a -> Map k b # (<$) :: a -> Map k b -> Map k a #
Hashable k => Hashable1 (Map k)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Map k a -> Int #
NiceComparable k => LorentzFunctor (Map k) a b
Instance details Defined in Lorentz.Instr Methods lmap :: forall (s :: [Type]). KnownValue b => ('[a] :-> '[b]) -> (Map k a ': s) :-> (Map k b ': s) #
(CanCastTo k1 k2, CanCastTo v1 v2) => CanCastTo (Map k1 v1 :: Type) (Map k2 v2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Map k1 v1) -> Proxy (Map k2 v2) -> () #
(Structured k, Structured v) => Structured (Map k v)
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy (Map k v) -> Structure # structureHash' :: Tagged (Map k v) MD5
(Data k, Data a, Ord k) => Data (Map k a)
Instance details Defined in Data.Map.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Map k a -> c (Map k a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Map k a) # toConstr :: Map k a -> Constr # dataTypeOf :: Map k a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Map k a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Map k a)) # gmapT :: (forall b. Data b => b -> b) -> Map k a -> Map k a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r # gmapQ :: (forall d. Data d => d -> u) -> Map k a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Map k a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) #
Ord k => Monoid (Map k v)
Instance details Defined in Data.Map.Internal Methods mempty :: Map k v # mappend :: Map k v -> Map k v -> Map k v # mconcat :: [Map k v] -> Map k v #
Ord k => Semigroup (Map k v)
Instance details Defined in Data.Map.Internal Methods (<>) :: Map k v -> Map k v -> Map k v # sconcat :: NonEmpty (Map k v) -> Map k v # stimes :: Integral b => b -> Map k v -> Map k v #
Ord k => IsList (Map k v)	Since: containers-0.5.6.2
Instance details Defined in Data.Map.Internal Associated Types type Item (Map k v) # Methods fromList :: [Item (Map k v)] -> Map k v # fromListN :: Int -> [Item (Map k v)] -> Map k v # toList :: Map k v -> [Item (Map k v)] #
(Ord k, Read k, Read e) => Read (Map k e)
Instance details Defined in Data.Map.Internal Methods readsPrec :: Int -> ReadS (Map k e) # readList :: ReadS [Map k e] # readPrec :: ReadPrec (Map k e) # readListPrec :: ReadPrec [Map k e] #
(Show k, Show a) => Show (Map k a)
Instance details Defined in Data.Map.Internal Methods showsPrec :: Int -> Map k a -> ShowS # show :: Map k a -> String # showList :: [Map k a] -> ShowS #
(NFData k, NFData a) => NFData (Map k a)
Instance details Defined in Data.Map.Internal Methods rnf :: Map k a -> () #
(Eq k, Eq a) => Eq (Map k a)
Instance details Defined in Data.Map.Internal Methods (==) :: Map k a -> Map k a -> Bool # (/=) :: Map k a -> Map k a -> Bool #
(Ord k, Ord v) => Ord (Map k v)
Instance details Defined in Data.Map.Internal Methods compare :: Map k v -> Map k v -> Ordering # (<) :: Map k v -> Map k v -> Bool # (<=) :: Map k v -> Map k v -> Bool # (>) :: Map k v -> Map k v -> Bool # (>=) :: Map k v -> Map k v -> Bool # max :: Map k v -> Map k v -> Map k v # min :: Map k v -> Map k v -> Map k v #
(Hashable k, Hashable v) => Hashable (Map k v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Map k v -> Int # hash :: Map k v -> Int #
Ord k => At (Map k a)
Instance details Defined in Control.Lens.At Methods at :: Index (Map k a) -> Lens' (Map k a) (Maybe (IxValue (Map k a))) #
Ord k => Ixed (Map k a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Map k a) -> Traversal' (Map k a) (IxValue (Map k a)) #
Ord k => Wrapped (Map k a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Map k a) # Methods _Wrapped' :: Iso' (Map k a) (Unwrapped (Map k a)) #
(HasAnnotation k, HasAnnotation v) => HasAnnotation (Map k v)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Map k v)) # annOptions :: Maybe AnnOptions #
NiceComparable k => GetOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type GetOpKeyHs (Map k v) # type GetOpValHs (Map k v) #
NiceComparable k => IterOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type IterOpElHs (Map k v) #
NiceComparable k => MapOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type MapOpInpHs (Map k v) # type MapOpResHs (Map k v) :: Type -> Type #
NiceComparable k => MemOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type MemOpKeyHs (Map k v) #
SizeOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic
NiceComparable k => UpdOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type UpdOpKeyHs (Map k v) # type UpdOpParamsHs (Map k v) #
HasRPCRepr v => HasRPCRepr (Map k v)
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (Map k v) #
(PolyCTypeHasDocC '[k], PolyTypeHasDocC '[v], Ord k) => TypeHasDoc (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Map k v) :: FieldDescriptions # Methods typeDocName :: Proxy (Map k v) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Map k v) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Map k v) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Map k v) # typeDocMichelsonRep :: TypeDocMichelsonRep (Map k v) #
(Comparable (ToT k), Ord k, IsoValue k, IsoValue v) => IsoValue (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Map k v) :: T # Methods toVal :: Map k v -> Value (ToT (Map k v)) # fromVal :: Value (ToT (Map k v)) -> Map k v #
ToBigMap (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToBigMapKey (Map k v) # type ToBigMapValue (Map k v) # Methods mkBigMap :: Map k v -> BigMap (ToBigMapKey (Map k v)) (ToBigMapValue (Map k v)) #
(Ord k, Monoid k, Semiring v) => Semiring (Map k v)	The multiplication laws are satisfied for any underlying `Monoid` as the key type, so we require a `Monoid` constraint instead of a `Semiring` constraint since `times` can use the context of either.
Instance details Defined in Data.Semiring Methods plus :: Map k v -> Map k v -> Map k v # zero :: Map k v # times :: Map k v -> Map k v -> Map k v # one :: Map k v # fromNatural :: Natural -> Map k v #
Container (Map k v)
Instance details Defined in Universum.Container.Class Associated Types type Element (Map k v) # Methods toList :: Map k v -> [Element (Map k v)] # null :: Map k v -> Bool # foldr :: (Element (Map k v) -> b -> b) -> b -> Map k v -> b # foldl :: (b -> Element (Map k v) -> b) -> b -> Map k v -> b # foldl' :: (b -> Element (Map k v) -> b) -> b -> Map k v -> b # length :: Map k v -> Int # elem :: Element (Map k v) -> Map k v -> Bool # foldMap :: Monoid m => (Element (Map k v) -> m) -> Map k v -> m # fold :: Map k v -> Element (Map k v) # foldr' :: (Element (Map k v) -> b -> b) -> b -> Map k v -> b # notElem :: Element (Map k v) -> Map k v -> Bool # all :: (Element (Map k v) -> Bool) -> Map k v -> Bool # any :: (Element (Map k v) -> Bool) -> Map k v -> Bool # and :: Map k v -> Bool # or :: Map k v -> Bool # find :: (Element (Map k v) -> Bool) -> Map k v -> Maybe (Element (Map k v)) # safeHead :: Map k v -> Maybe (Element (Map k v)) # safeMaximum :: Map k v -> Maybe (Element (Map k v)) # safeMinimum :: Map k v -> Maybe (Element (Map k v)) # safeFoldr1 :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Maybe (Element (Map k v)) # safeFoldl1 :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Maybe (Element (Map k v)) #
Ord k => FromList (Map k v)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (Map k v) # type FromListC (Map k v) # Methods fromList :: [ListElement (Map k v)] -> Map k v #
One (Map k v)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Map k v) # Methods one :: OneItem (Map k v) -> Map k v #
ToPairs (Map k v)
Instance details Defined in Universum.Container.Class Associated Types type Key (Map k v) # type Val (Map k v) # Methods toPairs :: Map k v -> [(Key (Map k v), Val (Map k v))] # keys :: Map k v -> [Key (Map k v)] # elems :: Map k v -> [Val (Map k v)] #
(t ~ Map k' a', Ord k) => Rewrapped (Map k a) t	Use `wrapping fromList`. unwrapping returns a sorted list.
Instance details Defined in Control.Lens.Wrapped
(NiceComparable key, KnownValue value) => StoreHasSubmap (Map key value) SelfRef key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (Map key value) SelfRef key value #
type Item (Map k v)
Instance details Defined in Data.Map.Internal type Item (Map k v) = (k, v)
type Index (Map k a)
Instance details Defined in Control.Lens.At type Index (Map k a) = k
type IxValue (Map k a)
Instance details Defined in Control.Lens.At type IxValue (Map k a) = a
type Unwrapped (Map k a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Map k a) = [(k, a)]
type GetOpKeyHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type GetOpKeyHs (Map k v) = k
type GetOpValHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type GetOpValHs (Map k v) = v
type IterOpElHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type IterOpElHs (Map k v) = (k, v)
type MapOpInpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type MapOpInpHs (Map k v) = (k, v)
type MapOpResHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type MapOpResHs (Map k v) = Map k
type MemOpKeyHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type MemOpKeyHs (Map k v) = k
type UpdOpKeyHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type UpdOpKeyHs (Map k v) = k
type UpdOpParamsHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type UpdOpParamsHs (Map k v) = Maybe v
type AsRPC (Map k v)
Instance details Defined in Morley.AsRPC type AsRPC (Map k v) = Map k (AsRPC v)
type TypeDocFieldDescriptions (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Map k v) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToBigMapKey (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToBigMapKey (Map k v) = k
type ToBigMapValue (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToBigMapValue (Map k v) = v
type ToT (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Map k v) = 'TMap (ToT k) (ToT v)
type Element (Map k v)
Instance details Defined in Universum.Container.Class type Element (Map k v) = ElementDefault (Map k v)
type FromListC (Map k v)
Instance details Defined in Universum.Container.Class type FromListC (Map k v) = ()
type Key (Map k v)
Instance details Defined in Universum.Container.Class type Key (Map k v) = k
type ListElement (Map k v)
Instance details Defined in Universum.Container.Class type ListElement (Map k v) = Item (Map k v)
type OneItem (Map k v)
Instance details Defined in Universum.Container.Class type OneItem (Map k v) = (k, v)
type Val (Map k v)
Instance details Defined in Universum.Container.Class type Val (Map k v) = v

data SomeException #

The SomeException type is the root of the exception type hierarchy. When an exception of type e is thrown, behind the scenes it is encapsulated in a SomeException.

Constructors

Exception e => SomeException e

Instances

Instances details

Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Show SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 #

Function composition.

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 #

Same as >>=, but with the arguments interchanged.

ap :: Monad m => m (a -> b) -> m a -> m b #

In many situations, the liftM operations can be replaced by uses of ap, which promotes function application.

return f `ap` x1 `ap` ... `ap` xn

is equivalent to

liftMn f x1 x2 ... xn

asTypeOf :: a -> a -> a #

asTypeOf is a type-restricted version of const. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the second.

const :: a -> b -> a #

const x is a unary function which evaluates to x for all inputs.

>>> const 42 "hello"
42

>>> map (const 42) [0..3]
[42,42,42,42]

flip :: (a -> b -> c) -> b -> a -> c #

flip f takes its (first) two arguments in the reverse order of f.

>>> flip (++) "hello" "world"
"worldhello"

id :: a -> a #

Identity function.

id x = x

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r #

Promote a function to a monad, scanning the monadic arguments from left to right. For example,

liftM2 (+) [0,1] [0,2] = [0,2,1,3]
liftM2 (+) (Just 1) Nothing = Nothing

ord :: Char -> Int #

The fromEnum method restricted to the type Char.

class Applicative f => Alternative (f :: Type -> Type) where #

A monoid on applicative functors.

If defined, some and many should be the least solutions of the equations:

```
some v = (:) <$> v <*> many v
```
```
many v = some v <|> pure []
```

Minimal complete definition

empty, (<|>)

Methods

(<|>) :: f a -> f a -> f a infixl 3 #

An associative binary operation

many :: f a -> f [a] #

Zero or more.

Instances

Instances details

Alternative IResult
Instance details Defined in Data.Aeson.Types.Internal Methods empty :: IResult a # (<\|>) :: IResult a -> IResult a -> IResult a # some :: IResult a -> IResult [a] # many :: IResult a -> IResult [a] #
Alternative Parser
Instance details Defined in Data.Aeson.Types.Internal Methods empty :: Parser a # (<\|>) :: Parser a -> Parser a -> Parser a # some :: Parser a -> Parser [a] # many :: Parser a -> Parser [a] #
Alternative Result
Instance details Defined in Data.Aeson.Types.Internal Methods empty :: Result a # (<\|>) :: Result a -> Result a -> Result a # some :: Result a -> Result [a] # many :: Result a -> Result [a] #
Alternative ZipList	Since: base-4.11.0.0
Instance details Defined in Control.Applicative Methods empty :: ZipList a # (<\|>) :: ZipList a -> ZipList a -> ZipList a # some :: ZipList a -> ZipList [a] # many :: ZipList a -> ZipList [a] #
Alternative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods empty :: Option a # (<\|>) :: Option a -> Option a -> Option a # some :: Option a -> Option [a] # many :: Option a -> Option [a] #
Alternative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods empty :: STM a # (<\|>) :: STM a -> STM a -> STM a # some :: STM a -> STM [a] # many :: STM a -> STM [a] #
Alternative P	Since: base-4.5.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods empty :: P a # (<\|>) :: P a -> P a -> P a # some :: P a -> P [a] # many :: P a -> P [a] #
Alternative ReadP	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods empty :: ReadP a # (<\|>) :: ReadP a -> ReadP a -> ReadP a # some :: ReadP a -> ReadP [a] # many :: ReadP a -> ReadP [a] #
Alternative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods empty :: Seq a # (<\|>) :: Seq a -> Seq a -> Seq a # some :: Seq a -> Seq [a] # many :: Seq a -> Seq [a] #
Alternative DList
Instance details Defined in Data.DList.Internal Methods empty :: DList a # (<\|>) :: DList a -> DList a -> DList a # some :: DList a -> DList [a] # many :: DList a -> DList [a] #
Alternative IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods empty :: IO a # (<\|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
Alternative Array
Instance details Defined in Data.Primitive.Array Methods empty :: Array a # (<\|>) :: Array a -> Array a -> Array a # some :: Array a -> Array [a] # many :: Array a -> Array [a] #
Alternative SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods empty :: SmallArray a # (<\|>) :: SmallArray a -> SmallArray a -> SmallArray a # some :: SmallArray a -> SmallArray [a] # many :: SmallArray a -> SmallArray [a] #
Alternative Vector
Instance details Defined in Data.Vector Methods empty :: Vector a # (<\|>) :: Vector a -> Vector a -> Vector a # some :: Vector a -> Vector [a] # many :: Vector a -> Vector [a] #
Alternative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
Alternative []	Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: [a] # (<\|>) :: [a] -> [a] -> [a] # some :: [a] -> [[a]] # many :: [a] -> [[a]] #
() :=> (Alternative Maybe)
Instance details Defined in Data.Constraint Methods ins :: () :- Alternative Maybe #
() :=> (Alternative [])
Instance details Defined in Data.Constraint Methods ins :: () :- Alternative [] #
Alternative (Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods empty :: Parser i a # (<\|>) :: Parser i a -> Parser i a -> Parser i a # some :: Parser i a -> Parser i [a] # many :: Parser i a -> Parser i [a] #
MonadPlus m => Alternative (WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedMonad m a # (<\|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] #
ArrowPlus a => Alternative (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods empty :: ArrowMonad a a0 # (<\|>) :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 # some :: ArrowMonad a a0 -> ArrowMonad a [a0] # many :: ArrowMonad a a0 -> ArrowMonad a [a0] #
Alternative (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods empty :: Proxy a # (<\|>) :: Proxy a -> Proxy a -> Proxy a # some :: Proxy a -> Proxy [a] # many :: Proxy a -> Proxy [a] #
Alternative (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: U1 a # (<\|>) :: U1 a -> U1 a -> U1 a # some :: U1 a -> U1 [a] # many :: U1 a -> U1 [a] #
Alternative v => Alternative (Free v)	This violates the Alternative laws, handle with care.
Instance details Defined in Control.Monad.Free Methods empty :: Free v a # (<\|>) :: Free v a -> Free v a -> Free v a # some :: Free v a -> Free v [a] # many :: Free v a -> Free v [a] #
Alternative f => Alternative (Yoneda f)
Instance details Defined in Data.Functor.Yoneda Methods empty :: Yoneda f a # (<\|>) :: Yoneda f a -> Yoneda f a -> Yoneda f a # some :: Yoneda f a -> Yoneda f [a] # many :: Yoneda f a -> Yoneda f [a] #
Alternative (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods empty :: ReifiedFold s a # (<\|>) :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a # some :: ReifiedFold s a -> ReifiedFold s [a] # many :: ReifiedFold s a -> ReifiedFold s [a] #
(Functor m, Monad m) => Alternative (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods empty :: MaybeT m a # (<\|>) :: MaybeT m a -> MaybeT m a -> MaybeT m a # some :: MaybeT m a -> MaybeT m [a] # many :: MaybeT m a -> MaybeT m [a] #
(MonadPlus m) :=> (Alternative (WrappedMonad m))
Instance details Defined in Data.Constraint Methods ins :: MonadPlus m :- Alternative (WrappedMonad m) #
Class (Applicative f) (Alternative f)
Instance details Defined in Data.Constraint Methods cls :: Alternative f :- Applicative f #
MonadPlus m => Alternative (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods empty :: RandT g m a # (<\|>) :: RandT g m a -> RandT g m a -> RandT g m a # some :: RandT g m a -> RandT g m [a] # many :: RandT g m a -> RandT g m [a] #
MonadPlus m => Alternative (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Strict Methods empty :: RandT g m a # (<\|>) :: RandT g m a -> RandT g m a -> RandT g m a # some :: RandT g m a -> RandT g m [a] # many :: RandT g m a -> RandT g m [a] #
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 # (<\|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] #
Alternative m => Alternative (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods empty :: Kleisli m a a0 # (<\|>) :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 # some :: Kleisli m a a0 -> Kleisli m a [a0] # many :: Kleisli m a a0 -> Kleisli m a [a0] #
Alternative f => Alternative (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods empty :: Ap f a # (<\|>) :: Ap f a -> Ap f a -> Ap f a # some :: Ap f a -> Ap f [a] # many :: Ap f a -> Ap f [a] #
Alternative f => Alternative (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods empty :: Alt f a # (<\|>) :: Alt f a -> Alt f a -> Alt f a # some :: Alt f a -> Alt f [a] # many :: Alt f a -> Alt f [a] #
Alternative f => Alternative (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: Rec1 f a # (<\|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a # some :: Rec1 f a -> Rec1 f [a] # many :: Rec1 f a -> Rec1 f [a] #
(Functor f, MonadPlus m) => Alternative (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods empty :: FreeT f m a # (<\|>) :: FreeT f m a -> FreeT f m a -> FreeT f m a # some :: FreeT f m a -> FreeT f m [a] # many :: FreeT f m a -> FreeT f m [a] #
(Functor m, Monad m, Error e) => Alternative (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods empty :: ErrorT e m a # (<\|>) :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a # some :: ErrorT e m a -> ErrorT e m [a] # many :: ErrorT e m a -> ErrorT e m [a] #
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods empty :: ExceptT e m a # (<\|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # some :: ExceptT e m a -> ExceptT e m [a] # many :: ExceptT e m a -> ExceptT e m [a] #
Alternative m => Alternative (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods empty :: IdentityT m a # (<\|>) :: IdentityT m a -> IdentityT m a -> IdentityT m a # some :: IdentityT m a -> IdentityT m [a] # many :: IdentityT m a -> IdentityT m [a] #
Alternative m => Alternative (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods empty :: ReaderT r m a # (<\|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a # some :: ReaderT r m a -> ReaderT r m [a] # many :: ReaderT r m a -> ReaderT r m [a] #
(Functor m, MonadPlus m) => Alternative (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods empty :: StateT s m a # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
(Functor m, MonadPlus m) => Alternative (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods empty :: StateT s m a # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
Class (Monad f, Alternative f) (MonadPlus f)
Instance details Defined in Data.Constraint Methods cls :: MonadPlus f :- (Monad f, Alternative f) #
(Alternative f, Alternative g) => Alternative (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods empty :: Product f g a # (<\|>) :: Product f g a -> Product f g a -> Product f g a # some :: Product f g a -> Product f g [a] # many :: Product f g a -> Product f g [a] #
(Alternative f, Alternative g) => Alternative (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: (f :: g) a # (<\|>) :: (f :: g) a -> (f :: g) a -> (f :: g) a # some :: (f :: g) a -> (f :: g) [a] # many :: (f :: g) a -> (f :: g) [a] #
(Alternative f, Applicative g) => Alternative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods empty :: Compose f g a # (<\|>) :: Compose f g a -> Compose f g a -> Compose f g a # some :: Compose f g a -> Compose f g [a] # many :: Compose f g a -> Compose f g [a] #
(Alternative f, Applicative g) => Alternative (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: (f :.: g) a # (<\|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a # some :: (f :.: g) a -> (f :.: g) [a] # many :: (f :.: g) a -> (f :.: g) [a] #
Alternative f => Alternative (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: M1 i c f a # (<\|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a # some :: M1 i c f a -> M1 i c f [a] # many :: M1 i c f a -> M1 i c f [a] #

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #

Monads that also support choice and failure.

Minimal complete definition

Nothing

Methods

mzero :: m a #

The identity of mplus. It should also satisfy the equations

mzero >>= f  =  mzero
v >> mzero   =  mzero

The default definition is

mzero = empty

mplus :: m a -> m a -> m a #

An associative operation. The default definition is

mplus = (<|>)

Instances

Instances details

MonadPlus IResult
Instance details Defined in Data.Aeson.Types.Internal Methods mzero :: IResult a # mplus :: IResult a -> IResult a -> IResult a #
MonadPlus Parser
Instance details Defined in Data.Aeson.Types.Internal Methods mzero :: Parser a # mplus :: Parser a -> Parser a -> Parser a #
MonadPlus Result
Instance details Defined in Data.Aeson.Types.Internal Methods mzero :: Result a # mplus :: Result a -> Result a -> Result a #
MonadPlus Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mzero :: Option a # mplus :: Option a -> Option a -> Option a #
MonadPlus STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods mzero :: STM a # mplus :: STM a -> STM a -> STM a #
MonadPlus P	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: P a # mplus :: P a -> P a -> P a #
MonadPlus ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: ReadP a # mplus :: ReadP a -> ReadP a -> ReadP a #
MonadPlus Seq
Instance details Defined in Data.Sequence.Internal Methods mzero :: Seq a # mplus :: Seq a -> Seq a -> Seq a #
MonadPlus DList
Instance details Defined in Data.DList.Internal Methods mzero :: DList a # mplus :: DList a -> DList a -> DList a #
MonadPlus IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
MonadPlus Array
Instance details Defined in Data.Primitive.Array Methods mzero :: Array a # mplus :: Array a -> Array a -> Array a #
MonadPlus SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods mzero :: SmallArray a # mplus :: SmallArray a -> SmallArray a -> SmallArray a #
MonadPlus Vector
Instance details Defined in Data.Vector Methods mzero :: Vector a # mplus :: Vector a -> Vector a -> Vector a #
MonadPlus Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
MonadPlus []	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: [a] # mplus :: [a] -> [a] -> [a] #
() :=> (MonadPlus Maybe)
Instance details Defined in Data.Constraint Methods ins :: () :- MonadPlus Maybe #
() :=> (MonadPlus [])
Instance details Defined in Data.Constraint Methods ins :: () :- MonadPlus [] #
MonadPlus (Parser i)
Instance details Defined in Data.Attoparsec.Internal.Types Methods mzero :: Parser i a # mplus :: Parser i a -> Parser i a -> Parser i a #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods mzero :: ArrowMonad a a0 # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 #
MonadPlus (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods mzero :: Proxy a # mplus :: Proxy a -> Proxy a -> Proxy a #
MonadPlus (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: U1 a # mplus :: U1 a -> U1 a -> U1 a #
(Functor v, MonadPlus v) => MonadPlus (Free v)	This violates the MonadPlus laws, handle with care.
Instance details Defined in Control.Monad.Free Methods mzero :: Free v a # mplus :: Free v a -> Free v a -> Free v a #
MonadPlus m => MonadPlus (Yoneda m)
Instance details Defined in Data.Functor.Yoneda Methods mzero :: Yoneda m a # mplus :: Yoneda m a -> Yoneda m a -> Yoneda m a #
MonadPlus (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods mzero :: ReifiedFold s a # mplus :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a #
Monad m => MonadPlus (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mzero :: MaybeT m a # mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a #
(MonadPlus m) :=> (Alternative (WrappedMonad m))
Instance details Defined in Data.Constraint Methods ins :: MonadPlus m :- Alternative (WrappedMonad m) #
MonadPlus m => MonadPlus (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods mzero :: RandT g m a # mplus :: RandT g m a -> RandT g m a -> RandT g m a #
MonadPlus m => MonadPlus (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Strict Methods mzero :: RandT g m a # mplus :: RandT g m a -> RandT g m a -> RandT g m a #
MonadPlus m => MonadPlus (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods mzero :: Kleisli m a a0 # mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 #
MonadPlus f => MonadPlus (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mzero :: Ap f a # mplus :: Ap f a -> Ap f a -> Ap f a #
MonadPlus f => MonadPlus (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods mzero :: Alt f a # mplus :: Alt f a -> Alt f a -> Alt f a #
MonadPlus f => MonadPlus (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: Rec1 f a # mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a #
(Functor f, MonadPlus m) => MonadPlus (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods mzero :: FreeT f m a # mplus :: FreeT f m a -> FreeT f m a -> FreeT f m a #
(Monad m, Error e) => MonadPlus (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods mzero :: ErrorT e m a # mplus :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a #
(Monad m, Monoid e) => MonadPlus (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mzero :: ExceptT e m a # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
MonadPlus m => MonadPlus (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods mzero :: IdentityT m a # mplus :: IdentityT m a -> IdentityT m a -> IdentityT m a #
MonadPlus m => MonadPlus (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mzero :: ReaderT r m a # mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a #
MonadPlus m => MonadPlus (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
MonadPlus m => MonadPlus (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
Class (Monad f, Alternative f) (MonadPlus f)
Instance details Defined in Data.Constraint Methods cls :: MonadPlus f :- (Monad f, Alternative f) #
(MonadPlus f, MonadPlus g) => MonadPlus (Product f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods mzero :: Product f g a # mplus :: Product f g a -> Product f g a -> Product f g a #
(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: (f :: g) a # mplus :: (f :: g) a -> (f :: g) a -> (f :: g) a #
MonadPlus f => MonadPlus (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: M1 i c f a # mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a #

data NonEmpty a #

Non-empty (and non-strict) list type.

Since: base-4.9.0.0

Constructors

a :| [a] infixr 5

Instances

Instances details

Foldable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m # foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m # foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b # foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b # foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # toList :: NonEmpty a -> [a] # null :: NonEmpty a -> Bool # length :: NonEmpty a -> Int # elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # sum :: Num a => NonEmpty a -> a # product :: Num a => NonEmpty a -> a #
Traversable NonEmpty	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) # sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) # mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) # sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) #
Applicative NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods pure :: a -> NonEmpty a # (<>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b # liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c # (>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a #
Functor NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Monad NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a #
NFData1 NonEmpty	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> NonEmpty a -> () #
Hashable1 NonEmpty	Since: hashable-1.3.1.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> NonEmpty a -> Int #
PApplicative NonEmpty
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type Pure arg :: f a # type arg <> arg1 :: f b # type LiftA2 arg arg1 arg2 :: f c # type arg > arg1 :: f b # type arg <* arg1 :: f a #
PFunctor NonEmpty
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type Fmap arg arg1 :: f b # type arg <$ arg1 :: f a #
PMonad NonEmpty
Instance details Defined in Control.Monad.Singletons.Internal Associated Types type arg >>= arg1 :: m b # type arg >> arg1 :: m b # type Return arg :: m a #
SApplicative NonEmpty
Instance details Defined in Control.Monad.Singletons.Internal Methods sPure :: forall a (t :: a). Sing t -> Sing (Apply PureSym0 t) # (%<>) :: forall a b (t1 :: NonEmpty (a ~> b)) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sLiftA2 :: forall a b c (t1 :: a ~> (b ~> c)) (t2 :: NonEmpty a) (t3 :: NonEmpty b). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply LiftA2Sym0 t1) t2) t3) # (%>) :: forall a b (t1 :: NonEmpty a) (t2 :: NonEmpty b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%<) :: forall a b (t1 :: NonEmpty a) (t2 :: NonEmpty b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) #
SFunctor NonEmpty
Instance details Defined in Control.Monad.Singletons.Internal Methods sFmap :: forall a b (t1 :: a ~> b) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply FmapSym0 t1) t2) # (%<$) :: forall a b (t1 :: a) (t2 :: NonEmpty b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<$@#@$) t1) t2) #
SMonad NonEmpty
Instance details Defined in Control.Monad.Singletons.Internal Methods (%>>=) :: forall a b (t1 :: NonEmpty a) (t2 :: a ~> NonEmpty b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>>=@#@$) t1) t2) # (%>>) :: forall a b (t1 :: NonEmpty a) (t2 :: NonEmpty b). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>>@#@$) t1) t2) # sReturn :: forall a (t :: a). Sing t -> Sing (Apply ReturnSym0 t) #
PFoldable NonEmpty
Instance details Defined in Data.Foldable.Singletons Associated Types type Fold arg :: m # type FoldMap arg arg1 :: m # type Foldr arg arg1 arg2 :: b # type Foldr' arg arg1 arg2 :: b # type Foldl arg arg1 arg2 :: b # type Foldl' arg arg1 arg2 :: b # type Foldr1 arg arg1 :: a # type Foldl1 arg arg1 :: a # type ToList arg :: [a] # type Null arg :: Bool # type Length arg :: Nat # type Elem arg arg1 :: Bool # type Maximum arg :: a # type Minimum arg :: a # type Sum arg :: a # type Product arg :: a #
SFoldable NonEmpty
Instance details Defined in Data.Foldable.Singletons Methods sFold :: forall m (t1 :: NonEmpty m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a m (t1 :: a ~> m) (t2 :: NonEmpty a). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a (t1 :: NonEmpty a). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a (t1 :: NonEmpty a). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a (t1 :: NonEmpty a). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a (t1 :: a) (t2 :: NonEmpty a). SEq a => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a (t1 :: NonEmpty a). SOrd a => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a (t1 :: NonEmpty a). SOrd a => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a (t1 :: NonEmpty a). SNum a => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a (t1 :: NonEmpty a). SNum a => Sing t1 -> Sing (Apply ProductSym0 t1) #
PTraversable NonEmpty
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable NonEmpty
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: NonEmpty a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: NonEmpty (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: NonEmpty a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: NonEmpty (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) #
Lift a => Lift (NonEmpty a :: Type)	Since: template-haskell-2.15.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => NonEmpty a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => NonEmpty a -> Code m (NonEmpty a) #
Structured a => Structured (NonEmpty a)
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy (NonEmpty a) -> Structure # structureHash' :: Tagged (NonEmpty a) MD5
Semigroup (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #
IsList (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Exts Associated Types type Item (NonEmpty a) # Methods fromList :: [Item (NonEmpty a)] -> NonEmpty a # fromListN :: Int -> [Item (NonEmpty a)] -> NonEmpty a # toList :: NonEmpty a -> [Item (NonEmpty a)] #
Generic (NonEmpty a)
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type # Methods from :: NonEmpty a -> Rep (NonEmpty a) x # to :: Rep (NonEmpty a) x -> NonEmpty a #
Read a => Read (NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (NonEmpty a) # readList :: ReadS [NonEmpty a] # readPrec :: ReadPrec (NonEmpty a) # readListPrec :: ReadPrec [NonEmpty a] #
Show a => Show (NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
NFData a => NFData (NonEmpty a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: NonEmpty a -> () #
Eq a => Eq (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Ord a => Ord (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods compare :: NonEmpty a -> NonEmpty a -> Ordering # (<) :: NonEmpty a -> NonEmpty a -> Bool # (<=) :: NonEmpty a -> NonEmpty a -> Bool # (>) :: NonEmpty a -> NonEmpty a -> Bool # (>=) :: NonEmpty a -> NonEmpty a -> Bool # max :: NonEmpty a -> NonEmpty a -> NonEmpty a # min :: NonEmpty a -> NonEmpty a -> NonEmpty a #
Hashable a => Hashable (NonEmpty a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> NonEmpty a -> Int # hash :: NonEmpty a -> Int #
Ixed (NonEmpty a)
Instance details Defined in Control.Lens.At Methods ix :: Index (NonEmpty a) -> Traversal' (NonEmpty a) (IxValue (NonEmpty a)) #
Wrapped (NonEmpty a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (NonEmpty a) # Methods _Wrapped' :: Iso' (NonEmpty a) (Unwrapped (NonEmpty a)) #
Ixed (NonEmpty a)
Instance details Defined in Lens.Micro.Internal Methods ix :: Index (NonEmpty a) -> Traversal' (NonEmpty a) (IxValue (NonEmpty a)) #
Ord k => ToBigMap (NonEmpty (k, v))
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToBigMapKey (NonEmpty (k, v)) # type ToBigMapValue (NonEmpty (k, v)) # Methods mkBigMap :: NonEmpty (k, v) -> BigMap (ToBigMapKey (NonEmpty (k, v))) (ToBigMapValue (NonEmpty (k, v))) #
PEq (NonEmpty a)
Instance details Defined in Data.Eq.Singletons Associated Types type arg == arg1 :: Bool # type arg /= arg1 :: Bool #
(SEq a, SEq [a]) => SEq (NonEmpty a)
Instance details Defined in Data.Eq.Singletons Methods (%==) :: forall (t1 :: NonEmpty a) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (==@#@$) t1) t2) # (%/=) :: forall (t1 :: NonEmpty a) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (/=@#@$) t1) t2) #
POrd (NonEmpty a)
Instance details Defined in Data.Ord.Singletons Associated Types type Compare arg arg1 :: Ordering # type arg < arg1 :: Bool # type arg <= arg1 :: Bool # type arg > arg1 :: Bool # type arg >= arg1 :: Bool # type Max arg arg1 :: a # type Min arg arg1 :: a #
(SOrd a, SOrd [a]) => SOrd (NonEmpty a)
Instance details Defined in Data.Ord.Singletons Methods sCompare :: forall (t1 :: NonEmpty a) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2) # (%<) :: forall (t1 :: NonEmpty a) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) # (%<=) :: forall (t1 :: NonEmpty a) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2) # (%>) :: forall (t1 :: NonEmpty a) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%>=) :: forall (t1 :: NonEmpty a) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2) # sMax :: forall (t1 :: NonEmpty a) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2) # sMin :: forall (t1 :: NonEmpty a) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2) #
PSemigroup (NonEmpty a)
Instance details Defined in Data.Semigroup.Singletons.Internal Associated Types type arg <> arg1 :: a # type Sconcat arg :: a #
SSemigroup (NonEmpty a)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods (%<>) :: forall (t1 :: NonEmpty a) (t2 :: NonEmpty a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sSconcat :: forall (t :: NonEmpty (NonEmpty a)). Sing t -> Sing (Apply SconcatSym0 t) #
PShow (NonEmpty a)
Instance details Defined in Text.Show.Singletons Associated Types type ShowsPrec arg arg1 arg2 :: Symbol # type Show_ arg :: Symbol # type ShowList arg arg1 :: Symbol #
(SShow a, SShow [a]) => SShow (NonEmpty a)
Instance details Defined in Text.Show.Singletons Methods sShowsPrec :: forall (t1 :: Nat) (t2 :: NonEmpty a) (t3 :: Symbol). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3) # sShow_ :: forall (t :: NonEmpty a). Sing t -> Sing (Apply Show_Sym0 t) # sShowList :: forall (t1 :: [NonEmpty a]) (t2 :: Symbol). Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2) #
Container (NonEmpty a)
Instance details Defined in Universum.Container.Class Associated Types type Element (NonEmpty a) # Methods toList :: NonEmpty a -> [Element (NonEmpty a)] # null :: NonEmpty a -> Bool # foldr :: (Element (NonEmpty a) -> b -> b) -> b -> NonEmpty a -> b # foldl :: (b -> Element (NonEmpty a) -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> Element (NonEmpty a) -> b) -> b -> NonEmpty a -> b # length :: NonEmpty a -> Int # elem :: Element (NonEmpty a) -> NonEmpty a -> Bool # foldMap :: Monoid m => (Element (NonEmpty a) -> m) -> NonEmpty a -> m # fold :: NonEmpty a -> Element (NonEmpty a) # foldr' :: (Element (NonEmpty a) -> b -> b) -> b -> NonEmpty a -> b # notElem :: Element (NonEmpty a) -> NonEmpty a -> Bool # all :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Bool # any :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Bool # and :: NonEmpty a -> Bool # or :: NonEmpty a -> Bool # find :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Maybe (Element (NonEmpty a)) # safeHead :: NonEmpty a -> Maybe (Element (NonEmpty a)) # safeMaximum :: NonEmpty a -> Maybe (Element (NonEmpty a)) # safeMinimum :: NonEmpty a -> Maybe (Element (NonEmpty a)) # safeFoldr1 :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> Maybe (Element (NonEmpty a)) # safeFoldl1 :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> Maybe (Element (NonEmpty a)) #
FromList (NonEmpty a)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (NonEmpty a) # type FromListC (NonEmpty a) # Methods fromList :: [ListElement (NonEmpty a)] -> NonEmpty a #
One (NonEmpty a)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (NonEmpty a) # Methods one :: OneItem (NonEmpty a) -> NonEmpty a #
ToPairs (NonEmpty (k, v))
Instance details Defined in Universum.Container.Class Associated Types type Key (NonEmpty (k, v)) # type Val (NonEmpty (k, v)) # Methods toPairs :: NonEmpty (k, v) -> [(Key (NonEmpty (k, v)), Val (NonEmpty (k, v)))] # keys :: NonEmpty (k, v) -> [Key (NonEmpty (k, v))] # elems :: NonEmpty (k, v) -> [Val (NonEmpty (k, v))] #
Generic1 NonEmpty
Instance details Defined in GHC.Generics Associated Types type Rep1 NonEmpty :: k -> Type # Methods from1 :: forall (a :: k). NonEmpty a -> Rep1 NonEmpty a # to1 :: forall (a :: k). Rep1 NonEmpty a -> NonEmpty a #
t ~ NonEmpty b => Rewrapped (NonEmpty a) t
Instance details Defined in Control.Lens.Wrapped
(SDecide a, SDecide [a]) => TestCoercion (SNonEmpty :: NonEmpty a -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods testCoercion :: forall (a0 :: k) (b :: k). SNonEmpty a0 -> SNonEmpty b -> Maybe (Coercion a0 b) #
(SDecide a, SDecide [a]) => TestEquality (SNonEmpty :: NonEmpty a -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods testEquality :: forall (a0 :: k) (b :: k). SNonEmpty a0 -> SNonEmpty b -> Maybe (a0 :~: b) #
Each (NonEmpty a) (NonEmpty b) a b
Instance details Defined in Lens.Micro.Internal Methods each :: Traversal (NonEmpty a) (NonEmpty b) a b #
SuppressUnusedWarnings Sconcat_6989586621679584058Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SSemigroup a => SingI (SconcatSym0 :: TyFun (NonEmpty a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing SconcatSym0 #
SingI ((:\|@#@$) :: TyFun a ([a] ~> NonEmpty a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing (:\|@#@$) #
SuppressUnusedWarnings (TFHelper_6989586621679584022Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> NonEmpty a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181443Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130622Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ToList_6989586621680194114Sym0 :: TyFun (NonEmpty a) [a] -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (SconcatSym0 :: TyFun (NonEmpty a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fold_6989586621680194106Sym0 :: TyFun (NonEmpty m) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680194063Sym0 :: TyFun (a ~> (a ~> a)) (NonEmpty a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680194075Sym0 :: TyFun (a ~> (a ~> a)) (NonEmpty a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680071810Sym0 :: TyFun Nat (NonEmpty a ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621679357507Sym0 :: TyFun a (NonEmpty a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((:\|@#@$) :: TyFun a ([a] ~> NonEmpty a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods suppressUnusedWarnings :: () #
SingI d => SingI ((:\|@#@$$) d :: TyFun [a] (NonEmpty a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing ((:\|@#@$$) d) #
SuppressUnusedWarnings (Sconcat_6989586621680163618Sym0 :: TyFun (NonEmpty (Proxy s)) (Proxy s) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357515Sym0 :: TyFun (NonEmpty (a ~> b)) (NonEmpty a ~> NonEmpty b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679584022Sym1 a6989586621679584027 :: TyFun (NonEmpty a) (NonEmpty a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181443Sym1 a6989586621679181448 :: TyFun (NonEmpty a) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357659Sym0 :: TyFun (NonEmpty a) ((a ~> NonEmpty b) ~> NonEmpty b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680071810Sym1 a6989586621680071818 :: TyFun (NonEmpty a) (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130622Sym1 a6989586621679130627 :: TyFun (NonEmpty a) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680194063Sym1 a6989586621680194068 :: TyFun (NonEmpty a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680194075Sym1 a6989586621680194080 :: TyFun (NonEmpty a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194032Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (NonEmpty a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679357364Sym0 :: TyFun (a ~> b) (NonEmpty a ~> NonEmpty b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194095Sym0 :: TyFun (a ~> m) (NonEmpty a ~> m) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194048Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (NonEmpty a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ((:\|@#@$$) a6989586621679028369 :: TyFun [a] (NonEmpty a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357376Sym0 :: TyFun a (NonEmpty b ~> NonEmpty a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679357364Sym1 a6989586621679357369 :: TyFun (NonEmpty a) (NonEmpty b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357515Sym1 a6989586621679357524 :: TyFun (NonEmpty a) (NonEmpty b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194095Sym1 a6989586621680194100 :: TyFun (NonEmpty a) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357376Sym1 a6989586621679357381 :: TyFun (NonEmpty b) (NonEmpty a) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679357659Sym1 a6989586621679357664 :: TyFun (a ~> NonEmpty b) (NonEmpty b) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621679357531Sym0 :: TyFun (a ~> (b ~> c)) (NonEmpty a ~> (NonEmpty b ~> NonEmpty c)) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478691Sym0 :: TyFun (a ~> f b) (NonEmpty a ~> f (NonEmpty b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194048Sym1 a6989586621680194054 :: TyFun b (NonEmpty a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194032Sym1 a6989586621680194038 :: TyFun b (NonEmpty a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669Bs'Sym0 :: TyFun k (TyFun [a] (TyFun (a ~> NonEmpty b) [b] -> Type) -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669BsSym0 :: TyFun k1 (TyFun k (TyFun (k1 ~> NonEmpty a) [a] -> Type) -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669BSym0 :: TyFun k1 (TyFun k2 (TyFun (k1 ~> NonEmpty k3) k3 -> Type) -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621679357531Sym1 a6989586621679357543 :: TyFun (NonEmpty a) (NonEmpty b ~> NonEmpty c) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194048Sym2 a6989586621680194054 a6989586621680194055 :: TyFun (NonEmpty a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194032Sym2 a6989586621680194038 a6989586621680194039 :: TyFun (NonEmpty a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478691Sym1 a6989586621680478696 :: TyFun (NonEmpty a) (f (NonEmpty b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669Bs'Sym1 a6989586621679357666 :: TyFun [a] (TyFun (a ~> NonEmpty b) [b] -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669BsSym1 a6989586621679357666 :: TyFun k (TyFun (k1 ~> NonEmpty a) [a] -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669ToListSym0 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type) -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669BSym1 a6989586621679357666 :: TyFun k2 (TyFun (k1 ~> NonEmpty k3) k3 -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621679357531Sym2 a6989586621679357543 a6989586621679357544 :: TyFun (NonEmpty b) (NonEmpty c) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669Bs'Sym2 a6989586621679357666 as6989586621679357667 :: TyFun (a ~> NonEmpty b) [b] -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669BsSym2 a6989586621679357666 as6989586621679357667 :: TyFun (k1 ~> NonEmpty a) [a] -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669BSym2 a6989586621679357666 as6989586621679357667 :: TyFun (k1 ~> NonEmpty k3) k3 -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669ToListSym1 a6989586621679357666 :: TyFun k2 (TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669ToListSym2 a6989586621679357666 as6989586621679357667 :: TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621679357669ToListSym3 a6989586621679357666 as6989586621679357667 f6989586621679357668 :: TyFun (NonEmpty k4) [k4] -> Type)
Instance details Defined in Control.Monad.Singletons.Internal Methods suppressUnusedWarnings :: () #
type Pure (a :: k1)
Instance details Defined in Control.Monad.Singletons.Internal type Pure (a :: k1) = Apply (Pure_6989586621679357507Sym0 :: TyFun k1 (NonEmpty k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Control.Monad.Singletons.Internal type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (NonEmpty a) -> Type) arg
type Fold (a :: NonEmpty k2)
Instance details Defined in Data.Foldable.Singletons type Fold (a :: NonEmpty k2) = Apply (Fold_6989586621680194106Sym0 :: TyFun (NonEmpty k2) k2 -> Type) a
type Length (arg :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Length (arg :: NonEmpty a) = Apply (Length_6989586621680193731Sym0 :: TyFun (NonEmpty a) Nat -> Type) arg
type Maximum (arg :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Maximum (arg :: NonEmpty a) = Apply (Maximum_6989586621680193764Sym0 :: TyFun (NonEmpty a) a -> Type) arg
type Minimum (arg :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Minimum (arg :: NonEmpty a) = Apply (Minimum_6989586621680193779Sym0 :: TyFun (NonEmpty a) a -> Type) arg
type Null (arg :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Null (arg :: NonEmpty a) = Apply (Null_6989586621680193714Sym0 :: TyFun (NonEmpty a) Bool -> Type) arg
type Product (arg :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Product (arg :: NonEmpty a) = Apply (Product_6989586621680193803Sym0 :: TyFun (NonEmpty a) a -> Type) arg
type Sum (arg :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Sum (arg :: NonEmpty a) = Apply (Sum_6989586621680193794Sym0 :: TyFun (NonEmpty a) a -> Type) arg
type ToList (a2 :: NonEmpty a1)
Instance details Defined in Data.Foldable.Singletons type ToList (a2 :: NonEmpty a1) = Apply (ToList_6989586621680194114Sym0 :: TyFun (NonEmpty a1) [a1] -> Type) a2
type Elem (arg1 :: a) (arg2 :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Elem (arg1 :: a) (arg2 :: NonEmpty a) = Apply (Apply (Elem_6989586621680193750Sym0 :: TyFun a (NonEmpty a ~> Bool) -> Type) arg1) arg2
type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: NonEmpty k2)
Instance details Defined in Data.Foldable.Singletons type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: NonEmpty k2) = Apply (Apply (Foldl1_6989586621680194063Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (NonEmpty k2 ~> k2) -> Type) a1) a2
type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: NonEmpty k2)
Instance details Defined in Data.Foldable.Singletons type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: NonEmpty k2) = Apply (Apply (Foldr1_6989586621680194075Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (NonEmpty k2 ~> k2) -> Type) a1) a2
type Sequence (arg :: NonEmpty (m a))
Instance details Defined in Data.Traversable.Singletons type Sequence (arg :: NonEmpty (m a)) = Apply (Sequence_6989586621680471117Sym0 :: TyFun (NonEmpty (m a)) (m (NonEmpty a)) -> Type) arg
type SequenceA (arg :: NonEmpty (f a))
Instance details Defined in Data.Traversable.Singletons type SequenceA (arg :: NonEmpty (f a)) = Apply (SequenceA_6989586621680471093Sym0 :: TyFun (NonEmpty (f a)) (f (NonEmpty a)) -> Type) arg
type (arg1 :: NonEmpty a) *> (arg2 :: NonEmpty b)
Instance details Defined in Control.Monad.Singletons.Internal type (arg1 :: NonEmpty a) *> (arg2 :: NonEmpty b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (NonEmpty a) (NonEmpty b ~> NonEmpty b) -> Type) arg1) arg2
type (a1 :: k1) <$ (a2 :: NonEmpty b)
Instance details Defined in Control.Monad.Singletons.Internal type (a1 :: k1) <$ (a2 :: NonEmpty b) = Apply (Apply (TFHelper_6989586621679357376Sym0 :: TyFun k1 (NonEmpty b ~> NonEmpty k1) -> Type) a1) a2
type (arg1 :: NonEmpty a) <* (arg2 :: NonEmpty b)
Instance details Defined in Control.Monad.Singletons.Internal type (arg1 :: NonEmpty a) <* (arg2 :: NonEmpty b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (NonEmpty a) (NonEmpty b ~> NonEmpty a) -> Type) arg1) arg2
type (a2 :: NonEmpty (a1 ~> b)) <*> (a3 :: NonEmpty a1)
Instance details Defined in Control.Monad.Singletons.Internal type (a2 :: NonEmpty (a1 ~> b)) <*> (a3 :: NonEmpty a1) = Apply (Apply (TFHelper_6989586621679357515Sym0 :: TyFun (NonEmpty (a1 ~> b)) (NonEmpty a1 ~> NonEmpty b) -> Type) a2) a3
type (arg1 :: NonEmpty a) >> (arg2 :: NonEmpty b)
Instance details Defined in Control.Monad.Singletons.Internal type (arg1 :: NonEmpty a) >> (arg2 :: NonEmpty b) = Apply (Apply (TFHelper_6989586621679287148Sym0 :: TyFun (NonEmpty a) (NonEmpty b ~> NonEmpty b) -> Type) arg1) arg2
type (a2 :: NonEmpty a1) >>= (a3 :: a1 ~> NonEmpty b)
Instance details Defined in Control.Monad.Singletons.Internal type (a2 :: NonEmpty a1) >>= (a3 :: a1 ~> NonEmpty b) = Apply (Apply (TFHelper_6989586621679357659Sym0 :: TyFun (NonEmpty a1) ((a1 ~> NonEmpty b) ~> NonEmpty b) -> Type) a2) a3
type Fmap (a2 :: a1 ~> b) (a3 :: NonEmpty a1)
Instance details Defined in Control.Monad.Singletons.Internal type Fmap (a2 :: a1 ~> b) (a3 :: NonEmpty a1) = Apply (Apply (Fmap_6989586621679357364Sym0 :: TyFun (a1 ~> b) (NonEmpty a1 ~> NonEmpty b) -> Type) a2) a3
type FoldMap (a2 :: a1 ~> k2) (a3 :: NonEmpty a1)
Instance details Defined in Data.Foldable.Singletons type FoldMap (a2 :: a1 ~> k2) (a3 :: NonEmpty a1) = Apply (Apply (FoldMap_6989586621680194095Sym0 :: TyFun (a1 ~> k2) (NonEmpty a1 ~> k2) -> Type) a2) a3
type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: NonEmpty a1)
Instance details Defined in Data.Foldable.Singletons type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: NonEmpty a1) = Apply (Apply (Apply (Foldl_6989586621680194048Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (NonEmpty a1 ~> k2)) -> Type) a2) a3) a4
type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: NonEmpty a) = Apply (Apply (Apply (Foldl'_6989586621680193642Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (NonEmpty a ~> b)) -> Type) arg1) arg2) arg3
type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: NonEmpty a1)
Instance details Defined in Data.Foldable.Singletons type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: NonEmpty a1) = Apply (Apply (Apply (Foldr_6989586621680194032Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (NonEmpty a1 ~> k2)) -> Type) a2) a3) a4
type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: NonEmpty a) = Apply (Apply (Apply (Foldr'_6989586621680193604Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (NonEmpty a ~> b)) -> Type) arg1) arg2) arg3
type MapM (arg1 :: a ~> m b) (arg2 :: NonEmpty a)
Instance details Defined in Data.Traversable.Singletons type MapM (arg1 :: a ~> m b) (arg2 :: NonEmpty a) = Apply (Apply (MapM_6989586621680471103Sym0 :: TyFun (a ~> m b) (NonEmpty a ~> m (NonEmpty b)) -> Type) arg1) arg2
type Traverse (a2 :: a1 ~> f b) (a3 :: NonEmpty a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a2 :: a1 ~> f b) (a3 :: NonEmpty a1) = Apply (Apply (Traverse_6989586621680478691Sym0 :: TyFun (a1 ~> f b) (NonEmpty a1 ~> f (NonEmpty b)) -> Type) a2) a3
type LiftA2 (a2 :: a1 ~> (b ~> c)) (a3 :: NonEmpty a1) (a4 :: NonEmpty b)
Instance details Defined in Control.Monad.Singletons.Internal type LiftA2 (a2 :: a1 ~> (b ~> c)) (a3 :: NonEmpty a1) (a4 :: NonEmpty b) = Apply (Apply (Apply (LiftA2_6989586621679357531Sym0 :: TyFun (a1 ~> (b ~> c)) (NonEmpty a1 ~> (NonEmpty b ~> NonEmpty c)) -> Type) a2) a3) a4
type Apply (Pure_6989586621679357507Sym0 :: TyFun a (NonEmpty a) -> Type) (a6989586621679357511 :: a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Pure_6989586621679357507Sym0 :: TyFun a (NonEmpty a) -> Type) (a6989586621679357511 :: a) = Pure_6989586621679357507 a6989586621679357511
type Apply (ShowsPrec_6989586621680071810Sym0 :: TyFun Nat (NonEmpty a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680071818 :: Nat)
Instance details Defined in Text.Show.Singletons type Apply (ShowsPrec_6989586621680071810Sym0 :: TyFun Nat (NonEmpty a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680071818 :: Nat) = ShowsPrec_6989586621680071810Sym1 a6989586621680071818 :: TyFun (NonEmpty a) (Symbol ~> Symbol) -> Type
type Apply ((:\|@#@$) :: TyFun a ([a] ~> NonEmpty a) -> Type) (a6989586621679028369 :: a)
Instance details Defined in Data.Singletons.Base.Instances type Apply ((:\|@#@$) :: TyFun a ([a] ~> NonEmpty a) -> Type) (a6989586621679028369 :: a) = (:\|@#@$$) a6989586621679028369
type Apply (TFHelper_6989586621679357376Sym0 :: TyFun a (NonEmpty b ~> NonEmpty a) -> Type) (a6989586621679357381 :: a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357376Sym0 :: TyFun a (NonEmpty b ~> NonEmpty a) -> Type) (a6989586621679357381 :: a) = TFHelper_6989586621679357376Sym1 a6989586621679357381 :: TyFun (NonEmpty b) (NonEmpty a) -> Type
type Apply (Foldl_6989586621680194048Sym1 a6989586621680194054 :: TyFun b (NonEmpty a ~> b) -> Type) (a6989586621680194055 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194048Sym1 a6989586621680194054 :: TyFun b (NonEmpty a ~> b) -> Type) (a6989586621680194055 :: b) = Foldl_6989586621680194048Sym2 a6989586621680194054 a6989586621680194055
type Apply (Foldr_6989586621680194032Sym1 a6989586621680194038 :: TyFun b (NonEmpty a ~> b) -> Type) (a6989586621680194039 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194032Sym1 a6989586621680194038 :: TyFun b (NonEmpty a ~> b) -> Type) (a6989586621680194039 :: b) = Foldr_6989586621680194032Sym2 a6989586621680194038 a6989586621680194039
type Apply (Let6989586621679357669Bs'Sym0 :: TyFun k (TyFun [a] (TyFun (a ~> NonEmpty b) [b] -> Type) -> Type) -> Type) (a6989586621679357666 :: k)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669Bs'Sym0 :: TyFun k (TyFun [a] (TyFun (a ~> NonEmpty b) [b] -> Type) -> Type) -> Type) (a6989586621679357666 :: k) = Let6989586621679357669Bs'Sym1 a6989586621679357666 :: TyFun [a] (TyFun (a ~> NonEmpty b) [b] -> Type) -> Type
type Apply (Let6989586621679357669BsSym0 :: TyFun k1 (TyFun k (TyFun (k1 ~> NonEmpty a) [a] -> Type) -> Type) -> Type) (a6989586621679357666 :: k1)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669BsSym0 :: TyFun k1 (TyFun k (TyFun (k1 ~> NonEmpty a) [a] -> Type) -> Type) -> Type) (a6989586621679357666 :: k1) = Let6989586621679357669BsSym1 a6989586621679357666 :: TyFun k (TyFun (k1 ~> NonEmpty a) [a] -> Type) -> Type
type Apply (Let6989586621679357669BSym0 :: TyFun k1 (TyFun k2 (TyFun (k1 ~> NonEmpty k3) k3 -> Type) -> Type) -> Type) (a6989586621679357666 :: k1)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669BSym0 :: TyFun k1 (TyFun k2 (TyFun (k1 ~> NonEmpty k3) k3 -> Type) -> Type) -> Type) (a6989586621679357666 :: k1) = Let6989586621679357669BSym1 a6989586621679357666 :: TyFun k2 (TyFun (k1 ~> NonEmpty k3) k3 -> Type) -> Type
type Apply (Let6989586621679357669BsSym1 a6989586621679357666 :: TyFun k (TyFun (k1 ~> NonEmpty a) [a] -> Type) -> Type) (as6989586621679357667 :: k)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669BsSym1 a6989586621679357666 :: TyFun k (TyFun (k1 ~> NonEmpty a) [a] -> Type) -> Type) (as6989586621679357667 :: k) = Let6989586621679357669BsSym2 a6989586621679357666 as6989586621679357667 :: TyFun (k1 ~> NonEmpty a) [a] -> Type
type Apply (Let6989586621679357669ToListSym0 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type) -> Type) -> Type) (a6989586621679357666 :: k1)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669ToListSym0 :: TyFun k1 (TyFun k2 (TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type) -> Type) -> Type) (a6989586621679357666 :: k1) = Let6989586621679357669ToListSym1 a6989586621679357666 :: TyFun k2 (TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type) -> Type
type Apply (Let6989586621679357669BSym1 a6989586621679357666 :: TyFun k2 (TyFun (k1 ~> NonEmpty k3) k3 -> Type) -> Type) (as6989586621679357667 :: k2)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669BSym1 a6989586621679357666 :: TyFun k2 (TyFun (k1 ~> NonEmpty k3) k3 -> Type) -> Type) (as6989586621679357667 :: k2) = Let6989586621679357669BSym2 a6989586621679357666 as6989586621679357667 :: TyFun (k1 ~> NonEmpty k3) k3 -> Type
type Apply (Let6989586621679357669ToListSym1 a6989586621679357666 :: TyFun k2 (TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type) -> Type) (as6989586621679357667 :: k2)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669ToListSym1 a6989586621679357666 :: TyFun k2 (TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type) -> Type) (as6989586621679357667 :: k2) = Let6989586621679357669ToListSym2 a6989586621679357666 as6989586621679357667 :: TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type
type Apply (Let6989586621679357669ToListSym2 a6989586621679357666 as6989586621679357667 :: TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type) (f6989586621679357668 :: k3)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669ToListSym2 a6989586621679357666 as6989586621679357667 :: TyFun k3 (TyFun (NonEmpty k4) [k4] -> Type) -> Type) (f6989586621679357668 :: k3) = Let6989586621679357669ToListSym3 a6989586621679357666 as6989586621679357667 f6989586621679357668 :: TyFun (NonEmpty k4) [k4] -> Type
type Item (NonEmpty a)
Instance details Defined in GHC.Exts type Item (NonEmpty a) = a
type Rep (NonEmpty a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep (NonEmpty a) = D1 ('MetaData "NonEmpty" "GHC.Base" "base" 'False) (C1 ('MetaCons ":\|" ('InfixI 'LeftAssociative 9) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a])))
type Index (NonEmpty a)
Instance details Defined in Control.Lens.At type Index (NonEmpty a) = Int
type IxValue (NonEmpty a)
Instance details Defined in Control.Lens.At type IxValue (NonEmpty a) = a
type Unwrapped (NonEmpty a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (NonEmpty a) = (a, [a])
type Index (NonEmpty a)
Instance details Defined in Lens.Micro.Internal type Index (NonEmpty a) = Int
type IxValue (NonEmpty a)
Instance details Defined in Lens.Micro.Internal type IxValue (NonEmpty a) = a
type ToBigMapKey (NonEmpty (k, v))
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToBigMapKey (NonEmpty (k, v)) = k
type ToBigMapValue (NonEmpty (k, v))
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToBigMapValue (NonEmpty (k, v)) = v
type Demote (NonEmpty a)
Instance details Defined in Data.Singletons.Base.Instances type Demote (NonEmpty a) = NonEmpty (Demote a)
type Sing
Instance details Defined in Data.Singletons.Base.Instances type Sing = SNonEmpty :: NonEmpty a -> Type
type Element (NonEmpty a)
Instance details Defined in Universum.Container.Class type Element (NonEmpty a) = ElementDefault (NonEmpty a)
type FromListC (NonEmpty a)
Instance details Defined in Universum.Container.Class type FromListC (NonEmpty a) = HasCallStack
type Key (NonEmpty (k, v))
Instance details Defined in Universum.Container.Class type Key (NonEmpty (k, v)) = k
type ListElement (NonEmpty a)
Instance details Defined in Universum.Container.Class type ListElement (NonEmpty a) = Item (NonEmpty a)
type OneItem (NonEmpty a)
Instance details Defined in Universum.Container.Class type OneItem (NonEmpty a) = a
type Val (NonEmpty (k, v))
Instance details Defined in Universum.Container.Class type Val (NonEmpty (k, v)) = v
type Rep1 NonEmpty	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep1 NonEmpty = D1 ('MetaData "NonEmpty" "GHC.Base" "base" 'False) (C1 ('MetaCons ":\|" ('InfixI 'LeftAssociative 9) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 [])))
type Sconcat (arg :: NonEmpty (NonEmpty a))
Instance details Defined in Data.Semigroup.Singletons.Internal type Sconcat (arg :: NonEmpty (NonEmpty a)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (NonEmpty a)) (NonEmpty a) -> Type) arg
type Show_ (arg :: NonEmpty a)
Instance details Defined in Text.Show.Singletons type Show_ (arg :: NonEmpty a) = Apply (Show__6989586621680047550Sym0 :: TyFun (NonEmpty a) Symbol -> Type) arg
type (arg1 :: NonEmpty a) /= (arg2 :: NonEmpty a)
Instance details Defined in Data.Eq.Singletons type (arg1 :: NonEmpty a) /= (arg2 :: NonEmpty a) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type) arg1) arg2
type (a2 :: NonEmpty a1) == (a3 :: NonEmpty a1)
Instance details Defined in Data.Eq.Singletons type (a2 :: NonEmpty a1) == (a3 :: NonEmpty a1) = Apply (Apply (TFHelper_6989586621679130622Sym0 :: TyFun (NonEmpty a1) (NonEmpty a1 ~> Bool) -> Type) a2) a3
type (arg1 :: NonEmpty a) < (arg2 :: NonEmpty a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: NonEmpty a) < (arg2 :: NonEmpty a) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type) arg1) arg2
type (arg1 :: NonEmpty a) <= (arg2 :: NonEmpty a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: NonEmpty a) <= (arg2 :: NonEmpty a) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type) arg1) arg2
type (arg1 :: NonEmpty a) > (arg2 :: NonEmpty a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: NonEmpty a) > (arg2 :: NonEmpty a) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type) arg1) arg2
type (arg1 :: NonEmpty a) >= (arg2 :: NonEmpty a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: NonEmpty a) >= (arg2 :: NonEmpty a) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type) arg1) arg2
type Compare (a2 :: NonEmpty a1) (a3 :: NonEmpty a1)
Instance details Defined in Data.Ord.Singletons type Compare (a2 :: NonEmpty a1) (a3 :: NonEmpty a1) = Apply (Apply (Compare_6989586621679181443Sym0 :: TyFun (NonEmpty a1) (NonEmpty a1 ~> Ordering) -> Type) a2) a3
type Max (arg1 :: NonEmpty a) (arg2 :: NonEmpty a)
Instance details Defined in Data.Ord.Singletons type Max (arg1 :: NonEmpty a) (arg2 :: NonEmpty a) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> NonEmpty a) -> Type) arg1) arg2
type Min (arg1 :: NonEmpty a) (arg2 :: NonEmpty a)
Instance details Defined in Data.Ord.Singletons type Min (arg1 :: NonEmpty a) (arg2 :: NonEmpty a) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> NonEmpty a) -> Type) arg1) arg2
type (a2 :: NonEmpty a1) <> (a3 :: NonEmpty a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: NonEmpty a1) <> (a3 :: NonEmpty a1) = Apply (Apply (TFHelper_6989586621679584022Sym0 :: TyFun (NonEmpty a1) (NonEmpty a1 ~> NonEmpty a1) -> Type) a2) a3
type ShowList (arg1 :: [NonEmpty a]) arg2
Instance details Defined in Text.Show.Singletons type ShowList (arg1 :: [NonEmpty a]) arg2 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [NonEmpty a] (Symbol ~> Symbol) -> Type) arg1) arg2
type Apply Sconcat_6989586621679584058Sym0 (a6989586621679584062 :: NonEmpty ())
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply Sconcat_6989586621679584058Sym0 (a6989586621679584062 :: NonEmpty ()) = Sconcat_6989586621679584058 a6989586621679584062
type ShowsPrec a2 (a3 :: NonEmpty a1) a4
Instance details Defined in Text.Show.Singletons type ShowsPrec a2 (a3 :: NonEmpty a1) a4 = Apply (Apply (Apply (ShowsPrec_6989586621680071810Sym0 :: TyFun Nat (NonEmpty a1 ~> (Symbol ~> Symbol)) -> Type) a2) a3) a4
type Apply (SconcatSym0 :: TyFun (NonEmpty a) a -> Type) (a6989586621679583988 :: NonEmpty a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (SconcatSym0 :: TyFun (NonEmpty a) a -> Type) (a6989586621679583988 :: NonEmpty a) = Sconcat a6989586621679583988
type Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty a) a -> Type) (a6989586621679583994 :: NonEmpty a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty a) a -> Type) (a6989586621679583994 :: NonEmpty a) = Sconcat_6989586621679583990 a6989586621679583994
type Apply (Fold_6989586621680194106Sym0 :: TyFun (NonEmpty m) m -> Type) (a6989586621680194110 :: NonEmpty m)
Instance details Defined in Data.Foldable.Singletons type Apply (Fold_6989586621680194106Sym0 :: TyFun (NonEmpty m) m -> Type) (a6989586621680194110 :: NonEmpty m) = Fold_6989586621680194106 a6989586621680194110
type Apply (Compare_6989586621679181443Sym1 a6989586621679181448 :: TyFun (NonEmpty a) Ordering -> Type) (a6989586621679181449 :: NonEmpty a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181443Sym1 a6989586621679181448 :: TyFun (NonEmpty a) Ordering -> Type) (a6989586621679181449 :: NonEmpty a) = Compare_6989586621679181443 a6989586621679181448 a6989586621679181449
type Apply (TFHelper_6989586621679130622Sym1 a6989586621679130627 :: TyFun (NonEmpty a) Bool -> Type) (a6989586621679130628 :: NonEmpty a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130622Sym1 a6989586621679130627 :: TyFun (NonEmpty a) Bool -> Type) (a6989586621679130628 :: NonEmpty a) = TFHelper_6989586621679130622 a6989586621679130627 a6989586621679130628
type Apply (Foldl1_6989586621680194063Sym1 a6989586621680194068 :: TyFun (NonEmpty a) a -> Type) (a6989586621680194069 :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl1_6989586621680194063Sym1 a6989586621680194068 :: TyFun (NonEmpty a) a -> Type) (a6989586621680194069 :: NonEmpty a) = Foldl1_6989586621680194063 a6989586621680194068 a6989586621680194069
type Apply (Foldr1_6989586621680194075Sym1 a6989586621680194080 :: TyFun (NonEmpty a) a -> Type) (a6989586621680194081 :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr1_6989586621680194075Sym1 a6989586621680194080 :: TyFun (NonEmpty a) a -> Type) (a6989586621680194081 :: NonEmpty a) = Foldr1_6989586621680194075 a6989586621680194080 a6989586621680194081
type Apply (FoldMap_6989586621680194095Sym1 a6989586621680194100 :: TyFun (NonEmpty a) m -> Type) (a6989586621680194101 :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194095Sym1 a6989586621680194100 :: TyFun (NonEmpty a) m -> Type) (a6989586621680194101 :: NonEmpty a) = FoldMap_6989586621680194095 a6989586621680194100 a6989586621680194101
type Apply (Foldl_6989586621680194048Sym2 a6989586621680194054 a6989586621680194055 :: TyFun (NonEmpty a) b -> Type) (a6989586621680194056 :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194048Sym2 a6989586621680194054 a6989586621680194055 :: TyFun (NonEmpty a) b -> Type) (a6989586621680194056 :: NonEmpty a) = Foldl_6989586621680194048 a6989586621680194054 a6989586621680194055 a6989586621680194056
type Apply (Foldr_6989586621680194032Sym2 a6989586621680194038 a6989586621680194039 :: TyFun (NonEmpty a) b -> Type) (a6989586621680194040 :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194032Sym2 a6989586621680194038 a6989586621680194039 :: TyFun (NonEmpty a) b -> Type) (a6989586621680194040 :: NonEmpty a) = Foldr_6989586621680194032 a6989586621680194038 a6989586621680194039 a6989586621680194040
type Apply (ToList_6989586621680194114Sym0 :: TyFun (NonEmpty a) [a] -> Type) (a6989586621680194118 :: NonEmpty a)
Instance details Defined in Data.Foldable.Singletons type Apply (ToList_6989586621680194114Sym0 :: TyFun (NonEmpty a) [a] -> Type) (a6989586621680194118 :: NonEmpty a) = ToList_6989586621680194114 a6989586621680194118
type Apply (TFHelper_6989586621679584022Sym1 a6989586621679584027 :: TyFun (NonEmpty a) (NonEmpty a) -> Type) (a6989586621679584028 :: NonEmpty a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679584022Sym1 a6989586621679584027 :: TyFun (NonEmpty a) (NonEmpty a) -> Type) (a6989586621679584028 :: NonEmpty a) = TFHelper_6989586621679584022 a6989586621679584027 a6989586621679584028
type Apply ((:\|@#@$$) a6989586621679028369 :: TyFun [a] (NonEmpty a) -> Type) (a6989586621679028370 :: [a])
Instance details Defined in Data.Singletons.Base.Instances type Apply ((:\|@#@$$) a6989586621679028369 :: TyFun [a] (NonEmpty a) -> Type) (a6989586621679028370 :: [a]) = a6989586621679028369 :\| a6989586621679028370
type Apply (Fmap_6989586621679357364Sym1 a6989586621679357369 :: TyFun (NonEmpty a) (NonEmpty b) -> Type) (a6989586621679357370 :: NonEmpty a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Fmap_6989586621679357364Sym1 a6989586621679357369 :: TyFun (NonEmpty a) (NonEmpty b) -> Type) (a6989586621679357370 :: NonEmpty a) = Fmap_6989586621679357364 a6989586621679357369 a6989586621679357370
type Apply (TFHelper_6989586621679357515Sym1 a6989586621679357524 :: TyFun (NonEmpty a) (NonEmpty b) -> Type) (a6989586621679357525 :: NonEmpty a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357515Sym1 a6989586621679357524 :: TyFun (NonEmpty a) (NonEmpty b) -> Type) (a6989586621679357525 :: NonEmpty a) = TFHelper_6989586621679357515 a6989586621679357524 a6989586621679357525
type Apply (TFHelper_6989586621679357376Sym1 a6989586621679357381 :: TyFun (NonEmpty b) (NonEmpty a) -> Type) (a6989586621679357382 :: NonEmpty b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357376Sym1 a6989586621679357381 :: TyFun (NonEmpty b) (NonEmpty a) -> Type) (a6989586621679357382 :: NonEmpty b) = TFHelper_6989586621679357376 a6989586621679357381 a6989586621679357382
type Apply (Traverse_6989586621680478691Sym1 a6989586621680478696 :: TyFun (NonEmpty a) (f (NonEmpty b)) -> Type) (a6989586621680478697 :: NonEmpty a)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478691Sym1 a6989586621680478696 :: TyFun (NonEmpty a) (f (NonEmpty b)) -> Type) (a6989586621680478697 :: NonEmpty a) = Traverse_6989586621680478691 a6989586621680478696 a6989586621680478697
type Apply (LiftA2_6989586621679357531Sym2 a6989586621679357543 a6989586621679357544 :: TyFun (NonEmpty b) (NonEmpty c) -> Type) (a6989586621679357545 :: NonEmpty b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (LiftA2_6989586621679357531Sym2 a6989586621679357543 a6989586621679357544 :: TyFun (NonEmpty b) (NonEmpty c) -> Type) (a6989586621679357545 :: NonEmpty b) = LiftA2_6989586621679357531 a6989586621679357543 a6989586621679357544 a6989586621679357545
type Apply (Let6989586621679357669ToListSym3 a6989586621679357666 as6989586621679357667 f6989586621679357668 :: TyFun (NonEmpty k4) [k4] -> Type) (a6989586621679357676 :: NonEmpty k4)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669ToListSym3 a6989586621679357666 as6989586621679357667 f6989586621679357668 :: TyFun (NonEmpty k4) [k4] -> Type) (a6989586621679357676 :: NonEmpty k4) = Let6989586621679357669ToList a6989586621679357666 as6989586621679357667 f6989586621679357668 a6989586621679357676
type Apply (TFHelper_6989586621679584022Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> NonEmpty a) -> Type) (a6989586621679584027 :: NonEmpty a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679584022Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> NonEmpty a) -> Type) (a6989586621679584027 :: NonEmpty a) = TFHelper_6989586621679584022Sym1 a6989586621679584027
type Apply (Compare_6989586621679181443Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Ordering) -> Type) (a6989586621679181448 :: NonEmpty a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181443Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Ordering) -> Type) (a6989586621679181448 :: NonEmpty a) = Compare_6989586621679181443Sym1 a6989586621679181448
type Apply (TFHelper_6989586621679130622Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type) (a6989586621679130627 :: NonEmpty a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130622Sym0 :: TyFun (NonEmpty a) (NonEmpty a ~> Bool) -> Type) (a6989586621679130627 :: NonEmpty a) = TFHelper_6989586621679130622Sym1 a6989586621679130627
type Apply (Sconcat_6989586621680163618Sym0 :: TyFun (NonEmpty (Proxy s)) (Proxy s) -> Type) (a6989586621680163622 :: NonEmpty (Proxy s))
Instance details Defined in Data.Proxy.Singletons type Apply (Sconcat_6989586621680163618Sym0 :: TyFun (NonEmpty (Proxy s)) (Proxy s) -> Type) (a6989586621680163622 :: NonEmpty (Proxy s)) = Sconcat_6989586621680163618 a6989586621680163622
type Apply (TFHelper_6989586621679357515Sym0 :: TyFun (NonEmpty (a ~> b)) (NonEmpty a ~> NonEmpty b) -> Type) (a6989586621679357524 :: NonEmpty (a ~> b))
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357515Sym0 :: TyFun (NonEmpty (a ~> b)) (NonEmpty a ~> NonEmpty b) -> Type) (a6989586621679357524 :: NonEmpty (a ~> b)) = TFHelper_6989586621679357515Sym1 a6989586621679357524
type Apply (TFHelper_6989586621679357659Sym0 :: TyFun (NonEmpty a) ((a ~> NonEmpty b) ~> NonEmpty b) -> Type) (a6989586621679357664 :: NonEmpty a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357659Sym0 :: TyFun (NonEmpty a) ((a ~> NonEmpty b) ~> NonEmpty b) -> Type) (a6989586621679357664 :: NonEmpty a) = TFHelper_6989586621679357659Sym1 a6989586621679357664 :: TyFun (a ~> NonEmpty b) (NonEmpty b) -> Type
type Apply (ShowsPrec_6989586621680071810Sym1 a6989586621680071818 :: TyFun (NonEmpty a) (Symbol ~> Symbol) -> Type) (a6989586621680071819 :: NonEmpty a)
Instance details Defined in Text.Show.Singletons type Apply (ShowsPrec_6989586621680071810Sym1 a6989586621680071818 :: TyFun (NonEmpty a) (Symbol ~> Symbol) -> Type) (a6989586621680071819 :: NonEmpty a) = ShowsPrec_6989586621680071810Sym2 a6989586621680071818 a6989586621680071819
type Apply (LiftA2_6989586621679357531Sym1 a6989586621679357543 :: TyFun (NonEmpty a) (NonEmpty b ~> NonEmpty c) -> Type) (a6989586621679357544 :: NonEmpty a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (LiftA2_6989586621679357531Sym1 a6989586621679357543 :: TyFun (NonEmpty a) (NonEmpty b ~> NonEmpty c) -> Type) (a6989586621679357544 :: NonEmpty a) = LiftA2_6989586621679357531Sym2 a6989586621679357543 a6989586621679357544
type Apply (Let6989586621679357669Bs'Sym1 a6989586621679357666 :: TyFun [a] (TyFun (a ~> NonEmpty b) [b] -> Type) -> Type) (as6989586621679357667 :: [a])
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669Bs'Sym1 a6989586621679357666 :: TyFun [a] (TyFun (a ~> NonEmpty b) [b] -> Type) -> Type) (as6989586621679357667 :: [a]) = Let6989586621679357669Bs'Sym2 a6989586621679357666 as6989586621679357667 :: TyFun (a ~> NonEmpty b) [b] -> Type
type Apply (Let6989586621679357669BSym2 a6989586621679357666 as6989586621679357667 :: TyFun (k1 ~> NonEmpty k3) k3 -> Type) (f6989586621679357668 :: k1 ~> NonEmpty k3)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669BSym2 a6989586621679357666 as6989586621679357667 :: TyFun (k1 ~> NonEmpty k3) k3 -> Type) (f6989586621679357668 :: k1 ~> NonEmpty k3) = Let6989586621679357669B a6989586621679357666 as6989586621679357667 f6989586621679357668
type Apply (TFHelper_6989586621679357659Sym1 a6989586621679357664 :: TyFun (a ~> NonEmpty b) (NonEmpty b) -> Type) (a6989586621679357665 :: a ~> NonEmpty b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (TFHelper_6989586621679357659Sym1 a6989586621679357664 :: TyFun (a ~> NonEmpty b) (NonEmpty b) -> Type) (a6989586621679357665 :: a ~> NonEmpty b) = TFHelper_6989586621679357659 a6989586621679357664 a6989586621679357665
type Apply (Let6989586621679357669Bs'Sym2 a6989586621679357666 as6989586621679357667 :: TyFun (a ~> NonEmpty b) [b] -> Type) (f6989586621679357668 :: a ~> NonEmpty b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669Bs'Sym2 a6989586621679357666 as6989586621679357667 :: TyFun (a ~> NonEmpty b) [b] -> Type) (f6989586621679357668 :: a ~> NonEmpty b) = Let6989586621679357669Bs' a6989586621679357666 as6989586621679357667 f6989586621679357668
type Apply (Let6989586621679357669BsSym2 a6989586621679357666 as6989586621679357667 :: TyFun (k1 ~> NonEmpty a) [a] -> Type) (f6989586621679357668 :: k1 ~> NonEmpty a)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Let6989586621679357669BsSym2 a6989586621679357666 as6989586621679357667 :: TyFun (k1 ~> NonEmpty a) [a] -> Type) (f6989586621679357668 :: k1 ~> NonEmpty a) = Let6989586621679357669Bs a6989586621679357666 as6989586621679357667 f6989586621679357668
type Apply (Foldl1_6989586621680194063Sym0 :: TyFun (a ~> (a ~> a)) (NonEmpty a ~> a) -> Type) (a6989586621680194068 :: a ~> (a ~> a))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl1_6989586621680194063Sym0 :: TyFun (a ~> (a ~> a)) (NonEmpty a ~> a) -> Type) (a6989586621680194068 :: a ~> (a ~> a)) = Foldl1_6989586621680194063Sym1 a6989586621680194068
type Apply (Foldr1_6989586621680194075Sym0 :: TyFun (a ~> (a ~> a)) (NonEmpty a ~> a) -> Type) (a6989586621680194080 :: a ~> (a ~> a))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr1_6989586621680194075Sym0 :: TyFun (a ~> (a ~> a)) (NonEmpty a ~> a) -> Type) (a6989586621680194080 :: a ~> (a ~> a)) = Foldr1_6989586621680194075Sym1 a6989586621680194080
type Apply (Foldr_6989586621680194032Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (NonEmpty a ~> b)) -> Type) (a6989586621680194038 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194032Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (NonEmpty a ~> b)) -> Type) (a6989586621680194038 :: a ~> (b ~> b)) = Foldr_6989586621680194032Sym1 a6989586621680194038
type Apply (Fmap_6989586621679357364Sym0 :: TyFun (a ~> b) (NonEmpty a ~> NonEmpty b) -> Type) (a6989586621679357369 :: a ~> b)
Instance details Defined in Control.Monad.Singletons.Internal type Apply (Fmap_6989586621679357364Sym0 :: TyFun (a ~> b) (NonEmpty a ~> NonEmpty b) -> Type) (a6989586621679357369 :: a ~> b) = Fmap_6989586621679357364Sym1 a6989586621679357369
type Apply (FoldMap_6989586621680194095Sym0 :: TyFun (a ~> m) (NonEmpty a ~> m) -> Type) (a6989586621680194100 :: a ~> m)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194095Sym0 :: TyFun (a ~> m) (NonEmpty a ~> m) -> Type) (a6989586621680194100 :: a ~> m) = FoldMap_6989586621680194095Sym1 a6989586621680194100
type Apply (Foldl_6989586621680194048Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (NonEmpty a ~> b)) -> Type) (a6989586621680194054 :: b ~> (a ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194048Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (NonEmpty a ~> b)) -> Type) (a6989586621680194054 :: b ~> (a ~> b)) = Foldl_6989586621680194048Sym1 a6989586621680194054
type Apply (LiftA2_6989586621679357531Sym0 :: TyFun (a ~> (b ~> c)) (NonEmpty a ~> (NonEmpty b ~> NonEmpty c)) -> Type) (a6989586621679357543 :: a ~> (b ~> c))
Instance details Defined in Control.Monad.Singletons.Internal type Apply (LiftA2_6989586621679357531Sym0 :: TyFun (a ~> (b ~> c)) (NonEmpty a ~> (NonEmpty b ~> NonEmpty c)) -> Type) (a6989586621679357543 :: a ~> (b ~> c)) = LiftA2_6989586621679357531Sym1 a6989586621679357543
type Apply (Traverse_6989586621680478691Sym0 :: TyFun (a ~> f b) (NonEmpty a ~> f (NonEmpty b)) -> Type) (a6989586621680478696 :: a ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478691Sym0 :: TyFun (a ~> f b) (NonEmpty a ~> f (NonEmpty b)) -> Type) (a6989586621680478696 :: a ~> f b) = Traverse_6989586621680478691Sym1 a6989586621680478696

subtract :: Num a => a -> a -> a #

the same as flip (-).

Because - is treated specially in the Haskell grammar, (- e) is not a section, but an application of prefix negation. However, (subtract exp) is equivalent to the disallowed section.

curry :: ((a, b) -> c) -> a -> b -> c #

curry converts an uncurried function to a curried function.

Examples

Expand

>>> curry fst 1 2
1

uncurry :: (a -> b -> c) -> (a, b) -> c #

uncurry converts a curried function to a function on pairs.

Examples

Expand

>>> uncurry (+) (1,2)
3

>>> uncurry ($) (show, 1)
"1"

>>> map (uncurry max) [(1,2), (3,4), (6,8)]
[2,4,8]

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 #

An infix synonym for fmap.

The name of this operator is an allusion to $. Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas $ is function application, <$> is function application lifted over a Functor.

Examples

Expand

Convert from a Maybe Int to a Maybe String using show:

>>> show <$> Nothing
Nothing
>>> show <$> Just 3
Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> show <$> Left 17
Left 17
>>> show <$> Right 17
Right "17"

Double each element of a list:

>>> (*2) <$> [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> even <$> (2,2)
(2,True)

void :: Functor f => f a -> f () #

void value discards or ignores the result of evaluation, such as the return value of an IO action.

Examples

Expand

Replace the contents of a Maybe Int with unit:

>>> void Nothing
Nothing
>>> void (Just 3)
Just ()

Replace the contents of an Either Int Int with unit, resulting in an Either Int ():

>>> void (Left 8675309)
Left 8675309
>>> void (Right 8675309)
Right ()

Replace every element of a list with unit:

>>> void [1,2,3]
[(),(),()]

Replace the second element of a pair with unit:

>>> void (1,2)
(1,())

Discard the result of an IO action:

>>> mapM print [1,2]
1
2
[(),()]
>>> void $ mapM print [1,2]
1
2

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c infixl 0 #

on b u x y runs the binary function b on the results of applying unary function u to two arguments x and y. From the opposite perspective, it transforms two inputs and combines the outputs.

((+) `on` f) x y = f x + f y

Typical usage: sortBy (compare `on` fst).

Algebraic properties:

(*) `on` id = (*) -- (if (*) ∉ {⊥, const ⊥})

```
((*) `on` f) `on` g = (*) `on` (f . g)
```
```
flip on f . flip on g = flip on (g . f)
```

catMaybes :: [Maybe a] -> [a] #

The catMaybes function takes a list of Maybes and returns a list of all the Just values.

Examples

Expand

Basic usage:

>>> catMaybes [Just 1, Nothing, Just 3]
[1,3]

When constructing a list of Maybe values, catMaybes can be used to return all of the "success" results (if the list is the result of a map, then mapMaybe would be more appropriate):

>>> import Text.Read ( readMaybe )
>>> [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[Just 1,Nothing,Just 3]
>>> catMaybes $ [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[1,3]

fromMaybe :: a -> Maybe a -> a #

The fromMaybe function takes a default value and a Maybe value. If the Maybe is Nothing, it returns the default value; otherwise, it returns the value contained in the Maybe.

Examples

Expand

Basic usage:

>>> fromMaybe "" (Just "Hello, World!")
"Hello, World!"

>>> fromMaybe "" Nothing
""

Read an integer from a string using readMaybe. If we fail to parse an integer, we want to return 0 by default:

>>> import Text.Read ( readMaybe )
>>> fromMaybe 0 (readMaybe "5")
5
>>> fromMaybe 0 (readMaybe "")
0

isJust :: Maybe a -> Bool #

The isJust function returns True iff its argument is of the form Just _.

Examples

Expand

Basic usage:

>>> isJust (Just 3)
True

>>> isJust (Just ())
True

>>> isJust Nothing
False

Only the outer constructor is taken into consideration:

>>> isJust (Just Nothing)
True

isNothing :: Maybe a -> Bool #

The isNothing function returns True iff its argument is Nothing.

Examples

Expand

Basic usage:

>>> isNothing (Just 3)
False

>>> isNothing (Just ())
False

>>> isNothing Nothing
True

Only the outer constructor is taken into consideration:

>>> isNothing (Just Nothing)
False

listToMaybe :: [a] -> Maybe a #

The listToMaybe function returns Nothing on an empty list or Just a where a is the first element of the list.

Examples

Expand

Basic usage:

>>> listToMaybe []
Nothing

>>> listToMaybe [9]
Just 9

>>> listToMaybe [1,2,3]
Just 1

Composing maybeToList with listToMaybe should be the identity on singleton/empty lists:

>>> maybeToList $ listToMaybe [5]
[5]
>>> maybeToList $ listToMaybe []
[]

But not on lists with more than one element:

>>> maybeToList $ listToMaybe [1,2,3]
[1]

mapMaybe :: (a -> Maybe b) -> [a] -> [b] #

The mapMaybe function is a version of map which can throw out elements. In particular, the functional argument returns something of type Maybe b. If this is Nothing, no element is added on to the result list. If it is Just b, then b is included in the result list.

Examples

Expand

Using mapMaybe f x is a shortcut for catMaybes $ map f x in most cases:

>>> import Text.Read ( readMaybe )
>>> let readMaybeInt = readMaybe :: String -> Maybe Int
>>> mapMaybe readMaybeInt ["1", "Foo", "3"]
[1,3]
>>> catMaybes $ map readMaybeInt ["1", "Foo", "3"]
[1,3]

If we map the Just constructor, the entire list should be returned:

>>> mapMaybe Just [1,2,3]
[1,2,3]

maybe :: b -> (a -> b) -> Maybe a -> b #

The maybe function takes a default value, a function, and a Maybe value. If the Maybe value is Nothing, the function returns the default value. Otherwise, it applies the function to the value inside the Just and returns the result.

Examples

Expand

Basic usage:

>>> maybe False odd (Just 3)
True

>>> maybe False odd Nothing
False

Read an integer from a string using readMaybe. If we succeed, return twice the integer; that is, apply (*2) to it. If instead we fail to parse an integer, return 0 by default:

>>> import Text.Read ( readMaybe )
>>> maybe 0 (*2) (readMaybe "5")
10
>>> maybe 0 (*2) (readMaybe "")
0

Apply show to a Maybe Int. If we have Just n, we want to show the underlying Int n. But if we have Nothing, we return the empty string instead of (for example) "Nothing":

>>> maybe "" show (Just 5)
"5"
>>> maybe "" show Nothing
""

maybeToList :: Maybe a -> [a] #

The maybeToList function returns an empty list when given Nothing or a singleton list when given Just.

Examples

Expand

Basic usage:

>>> maybeToList (Just 7)
[7]

>>> maybeToList Nothing
[]

One can use maybeToList to avoid pattern matching when combined with a function that (safely) works on lists:

>>> import Text.Read ( readMaybe )
>>> sum $ maybeToList (readMaybe "3")
3
>>> sum $ maybeToList (readMaybe "")
0

break :: (a -> Bool) -> [a] -> ([a], [a]) #

break, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that do not satisfy p and second element is the remainder of the list:

>>> break (> 3) [1,2,3,4,1,2,3,4]
([1,2,3],[4,1,2,3,4])
>>> break (< 9) [1,2,3]
([],[1,2,3])
>>> break (> 9) [1,2,3]
([1,2,3],[])

break p is equivalent to span (not . p).

cycle :: [a] -> [a] #

cycle ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.

>>> cycle []
*** Exception: Prelude.cycle: empty list
>>> take 20 $ cycle [42]
[42,42,42,42,42,42,42,42,42,42...
>>> take 20 $ cycle [2, 5, 7]
[2,5,7,2,5,7,2,5,7,2,5,7...

drop :: Int -> [a] -> [a] #

drop n xs returns the suffix of xs after the first n elements, or [] if n >= length xs.

>>> drop 6 "Hello World!"
"World!"
>>> drop 3 [1,2,3,4,5]
[4,5]
>>> drop 3 [1,2]
[]
>>> drop 3 []
[]
>>> drop (-1) [1,2]
[1,2]
>>> drop 0 [1,2]
[1,2]

It is an instance of the more general genericDrop, in which n may be of any integral type.

dropWhile :: (a -> Bool) -> [a] -> [a] #

dropWhile p xs returns the suffix remaining after takeWhile p xs.

>>> dropWhile (< 3) [1,2,3,4,5,1,2,3]
[3,4,5,1,2,3]
>>> dropWhile (< 9) [1,2,3]
[]
>>> dropWhile (< 0) [1,2,3]
[1,2,3]

iterate :: (a -> a) -> a -> [a] #

iterate f x returns an infinite list of repeated applications of f to x:

iterate f x == [x, f x, f (f x), ...]

Note that iterate is lazy, potentially leading to thunk build-up if the consumer doesn't force each iterate. See iterate' for a strict variant of this function.

>>> take 10 $ iterate not True
[True,False,True,False...
>>> take 10 $ iterate (+3) 42
[42,45,48,51,54,57,60,63...

repeat :: a -> [a] #

repeat x is an infinite list, with x the value of every element.

>>> take 20 $ repeat 17
[17,17,17,17,17,17,17,17,17...

replicate :: Int -> a -> [a] #

replicate n x is a list of length n with x the value of every element. It is an instance of the more general genericReplicate, in which n may be of any integral type.

>>> replicate 0 True
[]
>>> replicate (-1) True
[]
>>> replicate 4 True
[True,True,True,True]

reverse :: [a] -> [a] #

reverse xs returns the elements of xs in reverse order. xs must be finite.

>>> reverse []
[]
>>> reverse [42]
[42]
>>> reverse [2,5,7]
[7,5,2]
>>> reverse [1..]
* Hangs forever *

scanl :: (b -> a -> b) -> b -> [a] -> [b] #

$\mathcal{O}(n)$. scanl is similar to foldl, but returns a list of successive reduced values from the left:

scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]

Note that

last (scanl f z xs) == foldl f z xs

>>> scanl (+) 0 [1..4]
[0,1,3,6,10]
>>> scanl (+) 42 []
[42]
>>> scanl (-) 100 [1..4]
[100,99,97,94,90]
>>> scanl (\reversedString nextChar -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
["foo","afoo","bafoo","cbafoo","dcbafoo"]
>>> scanl (+) 0 [1..]
* Hangs forever *

scanr :: (a -> b -> b) -> b -> [a] -> [b] #

$\mathcal{O}(n)$. scanr is the right-to-left dual of scanl. Note that the order of parameters on the accumulating function are reversed compared to scanl. Also note that

head (scanr f z xs) == foldr f z xs.

>>> scanr (+) 0 [1..4]
[10,9,7,4,0]
>>> scanr (+) 42 []
[42]
>>> scanr (-) 100 [1..4]
[98,-97,99,-96,100]
>>> scanr (\nextChar reversedString -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
["abcdfoo","bcdfoo","cdfoo","dfoo","foo"]
>>> force $ scanr (+) 0 [1..]
*** Exception: stack overflow

splitAt :: Int -> [a] -> ([a], [a]) #

splitAt n xs returns a tuple where first element is xs prefix of length n and second element is the remainder of the list:

>>> splitAt 6 "Hello World!"
("Hello ","World!")
>>> splitAt 3 [1,2,3,4,5]
([1,2,3],[4,5])
>>> splitAt 1 [1,2,3]
([1],[2,3])
>>> splitAt 3 [1,2,3]
([1,2,3],[])
>>> splitAt 4 [1,2,3]
([1,2,3],[])
>>> splitAt 0 [1,2,3]
([],[1,2,3])
>>> splitAt (-1) [1,2,3]
([],[1,2,3])

It is equivalent to (take n xs, drop n xs) when n is not _|_ (splitAt _|_ xs = _|_). splitAt is an instance of the more general genericSplitAt, in which n may be of any integral type.

take :: Int -> [a] -> [a] #

take n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n >= length xs.

>>> take 5 "Hello World!"
"Hello"
>>> take 3 [1,2,3,4,5]
[1,2,3]
>>> take 3 [1,2]
[1,2]
>>> take 3 []
[]
>>> take (-1) [1,2]
[]
>>> take 0 [1,2]
[]

It is an instance of the more general genericTake, in which n may be of any integral type.

takeWhile :: (a -> Bool) -> [a] -> [a] #

takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p.

>>> takeWhile (< 3) [1,2,3,4,1,2,3,4]
[1,2]
>>> takeWhile (< 9) [1,2,3]
[1,2,3]
>>> takeWhile (< 0) [1,2,3]
[]

unzip :: [(a, b)] -> ([a], [b]) #

unzip transforms a list of pairs into a list of first components and a list of second components.

>>> unzip []
([],[])
>>> unzip [(1, 'a'), (2, 'b')]
([1,2],"ab")

unzip3 :: [(a, b, c)] -> ([a], [b], [c]) #

The unzip3 function takes a list of triples and returns three lists, analogous to unzip.

>>> unzip3 []
([],[],[])
>>> unzip3 [(1, 'a', True), (2, 'b', False)]
([1,2],"ab",[True,False])

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] #

zip3 takes three lists and returns a list of triples, analogous to zip. It is capable of list fusion, but it is restricted to its first list argument and its resulting list.

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] #

$\mathcal{O}(\min(m,n))$. zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function.

zipWith (,) xs ys == zip xs ys
zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]

For example, zipWith (+) is applied to two lists to produce the list of corresponding sums:

>>> zipWith (+) [1, 2, 3] [4, 5, 6]
[5,7,9]

zipWith is right-lazy:

>>> zipWith f [] _|_
[]

zipWith is capable of list fusion, but it is restricted to its first list argument and its resulting list.

chr :: Int -> Char #

The toEnum method restricted to the type Char.

(^^) :: (Fractional a, Integral b) => a -> b -> a infixr 8 #

raise a number to an integral power

gcd :: Integral a => a -> a -> a #

gcd x y is the non-negative factor of both x and y of which every common factor of x and y is also a factor; for example gcd 4 2 = 2, gcd (-4) 6 = 2, gcd 0 4 = 4. gcd 0 0 = 0. (That is, the common divisor that is "greatest" in the divisibility preordering.)

Note: Since for signed fixed-width integer types, abs minBound < 0, the result may be negative if one of the arguments is minBound (and necessarily is if the other is 0 or minBound) for such types.

lcm :: Integral a => a -> a -> a #

lcm x y is the smallest positive integer that both x and y divide.

data Proxy (t :: k) #

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

Instances details

Generic1 (Proxy :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 Proxy :: k -> Type # Methods from1 :: forall (a :: k0). Proxy a -> Rep1 Proxy a # to1 :: forall (a :: k0). Rep1 Proxy a -> Proxy a #
Representable (Proxy :: Type -> Type)
Instance details Defined in Data.Functor.Rep Associated Types type Rep Proxy # Methods tabulate :: (Rep Proxy -> a) -> Proxy a # index :: Proxy a -> Rep Proxy -> a #
Foldable (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m # foldMap :: Monoid m => (a -> m) -> Proxy a -> 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
Instance details 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) #
Alternative (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods empty :: Proxy a # (<\|>) :: Proxy a -> Proxy a -> Proxy a # some :: Proxy a -> Proxy [a] # many :: Proxy a -> Proxy [a] #
Applicative (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details 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 #
Functor (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods fmap :: (a -> b) -> Proxy a -> Proxy b # (<$) :: a -> Proxy b -> Proxy a #
Monad (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b # (>>) :: Proxy a -> Proxy b -> Proxy b # return :: a -> Proxy a #
MonadPlus (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods mzero :: Proxy a # mplus :: Proxy a -> Proxy a -> Proxy a #
NFData1 (Proxy :: Type -> Type)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Proxy a -> () #
Hashable1 (Proxy :: Type -> Type)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Proxy a -> Int #
PFoldable (Proxy :: Type -> Type)
Instance details Defined in Data.Foldable.Singletons Associated Types type Fold arg :: m # type FoldMap arg arg1 :: m # type Foldr arg arg1 arg2 :: b # type Foldr' arg arg1 arg2 :: b # type Foldl arg arg1 arg2 :: b # type Foldl' arg arg1 arg2 :: b # type Foldr1 arg arg1 :: a # type Foldl1 arg arg1 :: a # type ToList arg :: [a] # type Null arg :: Bool # type Length arg :: Nat # type Elem arg arg1 :: Bool # type Maximum arg :: a # type Minimum arg :: a # type Sum arg :: a # type Product arg :: a #
SFoldable (Proxy :: Type -> Type)
Instance details Defined in Data.Foldable.Singletons Methods sFold :: forall m (t1 :: Proxy m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a m (t1 :: a ~> m) (t2 :: Proxy a). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Proxy a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Proxy a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Proxy a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Proxy a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Proxy a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Proxy a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a (t1 :: Proxy a). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a (t1 :: Proxy a). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a (t1 :: Proxy a). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a (t1 :: a) (t2 :: Proxy a). SEq a => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a (t1 :: Proxy a). SOrd a => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a (t1 :: Proxy a). SOrd a => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a (t1 :: Proxy a). SNum a => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a (t1 :: Proxy a). SNum a => Sing t1 -> Sing (Apply ProductSym0 t1) #
PTraversable (Proxy :: Type -> Type)
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable (Proxy :: Type -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: Proxy a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: Proxy (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: Proxy a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: Proxy (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) #
Monoid (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods mempty :: Proxy s # mappend :: Proxy s -> Proxy s -> Proxy s # mconcat :: [Proxy s] -> Proxy s #
Semigroup (Proxy s)	Since: base-4.9.0.0
Instance details 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 #
Bounded (Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods minBound :: Proxy t # maxBound :: Proxy t #
Enum (Proxy s)	Since: base-4.7.0.0
Instance details 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] #
Generic (Proxy t)
Instance details 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 #
Ix (Proxy s)	Since: base-4.7.0.0
Instance details 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 #
Read (Proxy t)	Since: base-4.7.0.0
Instance details 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
Instance details Defined in Data.Proxy Methods showsPrec :: Int -> Proxy s -> ShowS # show :: Proxy s -> String # showList :: [Proxy s] -> ShowS #
NFData (Proxy a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Proxy a -> () #
Eq (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (==) :: Proxy s -> Proxy s -> Bool # (/=) :: Proxy s -> Proxy s -> Bool #
Ord (Proxy s)	Since: base-4.7.0.0
Instance details 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 #
Hashable (Proxy a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Proxy a -> Int # hash :: Proxy a -> Int #
Semiring (Proxy a)
Instance details Defined in Data.Semiring Methods plus :: Proxy a -> Proxy a -> Proxy a # zero :: Proxy a # times :: Proxy a -> Proxy a -> Proxy a # one :: Proxy a # fromNatural :: Natural -> Proxy a #
SuppressUnusedWarnings (Product_6989586621680194250Sym0 :: TyFun (Proxy a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Sum_6989586621680194244Sym0 :: TyFun (Proxy a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fold_6989586621680194173Sym0 :: TyFun (Proxy m) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680194206Sym0 :: TyFun (a ~> (a ~> a)) (Proxy a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680194215Sym0 :: TyFun (a ~> (a ~> a)) (Proxy a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621680163954Sym0 :: TyFun a (Proxy a) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194236Sym0 :: TyFun a (Proxy a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
TestCoercion (SProxy :: Proxy t -> Type)
Instance details Defined in Data.Proxy.Singletons Methods testCoercion :: forall (a :: k) (b :: k). SProxy a -> SProxy b -> Maybe (Coercion a b) #
TestEquality (SProxy :: Proxy t -> Type)
Instance details Defined in Data.Proxy.Singletons Methods testEquality :: forall (a :: k) (b :: k). SProxy a -> SProxy b -> Maybe (a :~: b) #
SuppressUnusedWarnings (Elem_6989586621680194236Sym1 a6989586621680194241 :: TyFun (Proxy a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680163961Sym0 :: TyFun (Proxy (a ~> b)) (Proxy a ~> Proxy b) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680194206Sym1 a6989586621680194211 :: TyFun (Proxy a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680194215Sym1 a6989586621680194220 :: TyFun (Proxy a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (SequenceA_6989586621680478736Sym0 :: TyFun (Proxy (f a)) (f (Proxy a)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Sequence_6989586621680478751Sym0 :: TyFun (Proxy (m a)) (m (Proxy a)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680163985Sym0 :: TyFun (Proxy a) (Proxy a ~> Proxy a) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680194229Sym0 :: TyFun (Proxy a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Length_6989586621680194223Sym0 :: TyFun (Proxy a) Nat -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pred_6989586621680163542Sym0 :: TyFun (Proxy s) (Proxy s) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Succ_6989586621680163536Sym0 :: TyFun (Proxy s) (Proxy s) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680163610Sym0 :: TyFun (Proxy s) (Proxy s ~> Proxy s) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680163447Sym0 :: TyFun (Proxy s) (Proxy s ~> Ordering) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680163568Sym0 :: TyFun (Proxy s) (Proxy s ~> (Proxy s ~> [Proxy s])) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680163384Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromTo_6989586621680163579Sym0 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromEnum_6989586621680163548Sym0 :: TyFun (Proxy s) Nat -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Sconcat_6989586621680163618Sym0 :: TyFun (NonEmpty (Proxy s)) (Proxy s) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194181Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Proxy a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621680163886Sym0 :: TyFun (a ~> b) (Proxy a ~> Proxy b) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194165Sym0 :: TyFun (a ~> m) (Proxy a ~> m) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194194Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Proxy a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ToEnum_6989586621680163554Sym0 :: TyFun Nat (Proxy s) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680163487Sym0 :: TyFun Nat (Proxy s ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Mconcat_6989586621680163839Sym0 :: TyFun [Proxy s] (Proxy s) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621680163886Sym1 a6989586621680163891 :: TyFun (Proxy a) (Proxy b) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680163961Sym1 a6989586621680163966 :: TyFun (Proxy a) (Proxy b) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680164026Sym0 :: TyFun (Proxy a) ((a ~> Proxy b) ~> Proxy b) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194165Sym1 a6989586621680194170 :: TyFun (Proxy a) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680163985Sym1 a6989586621680163990 :: TyFun (Proxy a) (Proxy a) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680163610Sym1 a6989586621680163615 :: TyFun (Proxy s) (Proxy s) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680163447Sym1 a6989586621680163452 :: TyFun (Proxy s) Ordering -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680163568Sym1 a6989586621680163574 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680163487Sym1 a6989586621680163495 :: TyFun (Proxy s) (Symbol ~> Symbol) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680163384Sym1 a6989586621680163389 :: TyFun (Proxy s) Bool -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromTo_6989586621680163579Sym1 a6989586621680163584 :: TyFun (Proxy s) [Proxy s] -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478728Sym0 :: TyFun (a ~> f b) (Proxy a ~> f (Proxy b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MapM_6989586621680478743Sym0 :: TyFun (a ~> m b) (Proxy a ~> m (Proxy b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194194Sym1 a6989586621680194200 :: TyFun b (Proxy a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194181Sym1 a6989586621680194187 :: TyFun b (Proxy a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194194Sym2 a6989586621680194200 a6989586621680194201 :: TyFun (Proxy a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194181Sym2 a6989586621680194187 a6989586621680194188 :: TyFun (Proxy a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478728Sym1 a6989586621680478733 :: TyFun (Proxy a) (f (Proxy b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (MapM_6989586621680478743Sym1 a6989586621680478748 :: TyFun (Proxy a) (m (Proxy b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680163568Sym2 a6989586621680163574 a6989586621680163575 :: TyFun (Proxy s) [Proxy s] -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680164026Sym1 a6989586621680164031 :: TyFun (a ~> Proxy b) (Proxy b) -> Type)
Instance details Defined in Data.Proxy.Singletons Methods suppressUnusedWarnings :: () #
type MapM (a2 :: a1 ~> m b) (a3 :: Proxy a1)
Instance details Defined in Data.Traversable.Singletons type MapM (a2 :: a1 ~> m b) (a3 :: Proxy a1) = Apply (Apply (MapM_6989586621680478743Sym0 :: TyFun (a1 ~> m b) (Proxy a1 ~> m (Proxy b)) -> Type) a2) a3
type Traverse (a2 :: a1 ~> f b) (a3 :: Proxy a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a2 :: a1 ~> f b) (a3 :: Proxy a1) = Apply (Apply (Traverse_6989586621680478728Sym0 :: TyFun (a1 ~> f b) (Proxy a1 ~> f (Proxy b)) -> Type) a2) a3
type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Proxy a) (arg2 :: Proxy b)
Instance details Defined in Data.Proxy.Singletons type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Proxy a) (arg2 :: Proxy b) = Apply (Apply (Apply (LiftA2_6989586621679287093Sym0 :: TyFun (a ~> (b ~> c)) (Proxy a ~> (Proxy b ~> Proxy c)) -> Type) arg) arg1) arg2
type Fmap (a2 :: a1 ~> b) (a3 :: Proxy a1)
Instance details Defined in Data.Proxy.Singletons type Fmap (a2 :: a1 ~> b) (a3 :: Proxy a1) = Apply (Apply (Fmap_6989586621680163886Sym0 :: TyFun (a1 ~> b) (Proxy a1 ~> Proxy b) -> Type) a2) a3
type FoldMap (a2 :: a1 ~> k2) (a3 :: Proxy a1)
Instance details Defined in Data.Foldable.Singletons type FoldMap (a2 :: a1 ~> k2) (a3 :: Proxy a1) = Apply (Apply (FoldMap_6989586621680194165Sym0 :: TyFun (a1 ~> k2) (Proxy a1 ~> k2) -> Type) a2) a3
type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Proxy a1)
Instance details Defined in Data.Foldable.Singletons type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Proxy a1) = Apply (Apply (Apply (Foldl_6989586621680194194Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (Proxy a1 ~> k2)) -> Type) a2) a3) a4
type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: Proxy a) = Apply (Apply (Apply (Foldl'_6989586621680193642Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Proxy a ~> b)) -> Type) arg1) arg2) arg3
type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Proxy a1)
Instance details Defined in Data.Foldable.Singletons type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Proxy a1) = Apply (Apply (Apply (Foldr_6989586621680194181Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Proxy a1 ~> k2)) -> Type) a2) a3) a4
type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: Proxy a) = Apply (Apply (Apply (Foldr'_6989586621680193604Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Proxy a ~> b)) -> Type) arg1) arg2) arg3
type Rep1 (Proxy :: k -> Type)	Since: base-4.6.0.0
Instance details 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 Empty
Instance details Defined in Data.Proxy.Singletons type Empty = Empty_6989586621680163980Sym0 :: Proxy a
type Mzero
Instance details Defined in Data.Proxy.Singletons type Mzero = Mzero_6989586621679287185Sym0 :: Proxy a
type Pure (a :: k1)
Instance details Defined in Data.Proxy.Singletons type Pure (a :: k1) = Apply (Pure_6989586621680163954Sym0 :: TyFun k1 (Proxy k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Data.Proxy.Singletons type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (Proxy a) -> Type) arg
type Elem (a1 :: k1) (a2 :: Proxy k1)
Instance details Defined in Data.Foldable.Singletons type Elem (a1 :: k1) (a2 :: Proxy k1) = Apply (Apply (Elem_6989586621680194236Sym0 :: TyFun k1 (Proxy k1 ~> Bool) -> Type) a1) a2
type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Proxy k2)
Instance details Defined in Data.Foldable.Singletons type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Proxy k2) = Apply (Apply (Foldl1_6989586621680194206Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (Proxy k2 ~> k2) -> Type) a1) a2
type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Proxy k2)
Instance details Defined in Data.Foldable.Singletons type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Proxy k2) = Apply (Apply (Foldr1_6989586621680194215Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (Proxy k2 ~> k2) -> Type) a1) a2
type (arg :: a) <$ (arg1 :: Proxy b)
Instance details Defined in Data.Proxy.Singletons type (arg :: a) <$ (arg1 :: Proxy b) = Apply (Apply (TFHelper_6989586621679287037Sym0 :: TyFun a (Proxy b ~> Proxy a) -> Type) arg) arg1
type (a2 :: Proxy a1) <\|> (a3 :: Proxy a1)
Instance details Defined in Data.Proxy.Singletons type (a2 :: Proxy a1) <\|> (a3 :: Proxy a1) = Apply (Apply (TFHelper_6989586621680163985Sym0 :: TyFun (Proxy a1) (Proxy a1 ~> Proxy a1) -> Type) a2) a3
type Mplus (arg :: Proxy a) (arg1 :: Proxy a)
Instance details Defined in Data.Proxy.Singletons type Mplus (arg :: Proxy a) (arg1 :: Proxy a) = Apply (Apply (Mplus_6989586621679287190Sym0 :: TyFun (Proxy a) (Proxy a ~> Proxy a) -> Type) arg) arg1
type Apply (Pure_6989586621680163954Sym0 :: TyFun a (Proxy a) -> Type) (a6989586621680163958 :: a)
Instance details Defined in Data.Proxy.Singletons type Apply (Pure_6989586621680163954Sym0 :: TyFun a (Proxy a) -> Type) (a6989586621680163958 :: a) = Pure_6989586621680163954 a6989586621680163958
type Apply (Elem_6989586621680194236Sym0 :: TyFun a (Proxy a ~> Bool) -> Type) (a6989586621680194241 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194236Sym0 :: TyFun a (Proxy a ~> Bool) -> Type) (a6989586621680194241 :: a) = Elem_6989586621680194236Sym1 a6989586621680194241
type Apply (ToEnum_6989586621680163554Sym0 :: TyFun Nat (Proxy s) -> Type) (a6989586621680163558 :: Nat)
Instance details Defined in Data.Proxy.Singletons type Apply (ToEnum_6989586621680163554Sym0 :: TyFun Nat (Proxy s) -> Type) (a6989586621680163558 :: Nat) = ToEnum_6989586621680163554 a6989586621680163558 :: Proxy s
type Apply (ShowsPrec_6989586621680163487Sym0 :: TyFun Nat (Proxy s ~> (Symbol ~> Symbol)) -> Type) (a6989586621680163495 :: Nat)
Instance details Defined in Data.Proxy.Singletons type Apply (ShowsPrec_6989586621680163487Sym0 :: TyFun Nat (Proxy s ~> (Symbol ~> Symbol)) -> Type) (a6989586621680163495 :: Nat) = ShowsPrec_6989586621680163487Sym1 a6989586621680163495 :: TyFun (Proxy s) (Symbol ~> Symbol) -> Type
type Apply (Foldl_6989586621680194194Sym1 a6989586621680194200 :: TyFun b (Proxy a ~> b) -> Type) (a6989586621680194201 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194194Sym1 a6989586621680194200 :: TyFun b (Proxy a ~> b) -> Type) (a6989586621680194201 :: b) = Foldl_6989586621680194194Sym2 a6989586621680194200 a6989586621680194201
type Apply (Foldr_6989586621680194181Sym1 a6989586621680194187 :: TyFun b (Proxy a ~> b) -> Type) (a6989586621680194188 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194181Sym1 a6989586621680194187 :: TyFun b (Proxy a ~> b) -> Type) (a6989586621680194188 :: b) = Foldr_6989586621680194181Sym2 a6989586621680194187 a6989586621680194188
type Rep (Proxy :: Type -> Type)
Instance details Defined in Data.Functor.Rep type Rep (Proxy :: Type -> Type) = Void
type Fold (a :: Proxy k2)
Instance details Defined in Data.Foldable.Singletons type Fold (a :: Proxy k2) = Apply (Fold_6989586621680194173Sym0 :: TyFun (Proxy k2) k2 -> Type) a
type Length (a2 :: Proxy a1)
Instance details Defined in Data.Foldable.Singletons type Length (a2 :: Proxy a1) = Apply (Length_6989586621680194223Sym0 :: TyFun (Proxy a1) Nat -> Type) a2
type Maximum (arg :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Maximum (arg :: Proxy a) = Apply (Maximum_6989586621680193764Sym0 :: TyFun (Proxy a) a -> Type) arg
type Minimum (arg :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Minimum (arg :: Proxy a) = Apply (Minimum_6989586621680193779Sym0 :: TyFun (Proxy a) a -> Type) arg
type Null (a2 :: Proxy a1)
Instance details Defined in Data.Foldable.Singletons type Null (a2 :: Proxy a1) = Apply (Null_6989586621680194229Sym0 :: TyFun (Proxy a1) Bool -> Type) a2
type Product (a :: Proxy k2)
Instance details Defined in Data.Foldable.Singletons type Product (a :: Proxy k2) = Apply (Product_6989586621680194250Sym0 :: TyFun (Proxy k2) k2 -> Type) a
type Sum (a :: Proxy k2)
Instance details Defined in Data.Foldable.Singletons type Sum (a :: Proxy k2) = Apply (Sum_6989586621680194244Sym0 :: TyFun (Proxy k2) k2 -> Type) a
type ToList (arg :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type ToList (arg :: Proxy a) = Apply (ToList_6989586621680193705Sym0 :: TyFun (Proxy a) [a] -> Type) arg
type Sequence (a2 :: Proxy (m a1))
Instance details Defined in Data.Traversable.Singletons type Sequence (a2 :: Proxy (m a1)) = Apply (Sequence_6989586621680478751Sym0 :: TyFun (Proxy (m a1)) (m (Proxy a1)) -> Type) a2
type SequenceA (a2 :: Proxy (f a1))
Instance details Defined in Data.Traversable.Singletons type SequenceA (a2 :: Proxy (f a1)) = Apply (SequenceA_6989586621680478736Sym0 :: TyFun (Proxy (f a1)) (f (Proxy a1)) -> Type) a2
type (arg :: Proxy a) *> (arg1 :: Proxy b)
Instance details Defined in Data.Proxy.Singletons type (arg :: Proxy a) *> (arg1 :: Proxy b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (Proxy a) (Proxy b ~> Proxy b) -> Type) arg) arg1
type (arg :: Proxy a) <* (arg1 :: Proxy b)
Instance details Defined in Data.Proxy.Singletons type (arg :: Proxy a) <* (arg1 :: Proxy b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (Proxy a) (Proxy b ~> Proxy a) -> Type) arg) arg1
type (a2 :: Proxy (a1 ~> b)) <*> (a3 :: Proxy a1)
Instance details Defined in Data.Proxy.Singletons type (a2 :: Proxy (a1 ~> b)) <*> (a3 :: Proxy a1) = Apply (Apply (TFHelper_6989586621680163961Sym0 :: TyFun (Proxy (a1 ~> b)) (Proxy a1 ~> Proxy b) -> Type) a2) a3
type (arg :: Proxy a) >> (arg1 :: Proxy b)
Instance details Defined in Data.Proxy.Singletons type (arg :: Proxy a) >> (arg1 :: Proxy b) = Apply (Apply (TFHelper_6989586621679287148Sym0 :: TyFun (Proxy a) (Proxy b ~> Proxy b) -> Type) arg) arg1
type (a2 :: Proxy a1) >>= (a3 :: a1 ~> Proxy b)
Instance details Defined in Data.Proxy.Singletons type (a2 :: Proxy a1) >>= (a3 :: a1 ~> Proxy b) = Apply (Apply (TFHelper_6989586621680164026Sym0 :: TyFun (Proxy a1) ((a1 ~> Proxy b) ~> Proxy b) -> Type) a2) a3
type Apply (Sconcat_6989586621680163618Sym0 :: TyFun (NonEmpty (Proxy s)) (Proxy s) -> Type) (a6989586621680163622 :: NonEmpty (Proxy s))
Instance details Defined in Data.Proxy.Singletons type Apply (Sconcat_6989586621680163618Sym0 :: TyFun (NonEmpty (Proxy s)) (Proxy s) -> Type) (a6989586621680163622 :: NonEmpty (Proxy s)) = Sconcat_6989586621680163618 a6989586621680163622
type Apply (Mconcat_6989586621680163839Sym0 :: TyFun [Proxy s] (Proxy s) -> Type) (a6989586621680163843 :: [Proxy s])
Instance details Defined in Data.Proxy.Singletons type Apply (Mconcat_6989586621680163839Sym0 :: TyFun [Proxy s] (Proxy s) -> Type) (a6989586621680163843 :: [Proxy s]) = Mconcat_6989586621680163839 a6989586621680163843
type Rep (Proxy t)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep (Proxy t) = D1 ('MetaData "Proxy" "Data.Proxy" "base" 'False) (C1 ('MetaCons "Proxy" 'PrefixI 'False) (U1 :: Type -> Type))
type Demote (Proxy t)
Instance details Defined in Data.Proxy.Singletons type Demote (Proxy t) = Proxy t
type Sing
Instance details Defined in Data.Proxy.Singletons type Sing = SProxy :: Proxy t -> Type
type Mempty
Instance details Defined in Data.Proxy.Singletons type Mempty = Mempty_6989586621680163835Sym0 :: Proxy s
type MaxBound
Instance details Defined in Data.Proxy.Singletons type MaxBound = MaxBound_6989586621680163355Sym0 :: Proxy s
type MinBound
Instance details Defined in Data.Proxy.Singletons type MinBound = MinBound_6989586621680163352Sym0 :: Proxy s
type Mconcat (a :: [Proxy s])
Instance details Defined in Data.Proxy.Singletons type Mconcat (a :: [Proxy s]) = Apply (Mconcat_6989586621680163839Sym0 :: TyFun [Proxy s] (Proxy s) -> Type) a
type Sconcat (a :: NonEmpty (Proxy s))
Instance details Defined in Data.Proxy.Singletons type Sconcat (a :: NonEmpty (Proxy s)) = Apply (Sconcat_6989586621680163618Sym0 :: TyFun (NonEmpty (Proxy s)) (Proxy s) -> Type) a
type FromEnum (a :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type FromEnum (a :: Proxy s) = Apply (FromEnum_6989586621680163548Sym0 :: TyFun (Proxy s) Nat -> Type) a
type Pred (a :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Pred (a :: Proxy s) = Apply (Pred_6989586621680163542Sym0 :: TyFun (Proxy s) (Proxy s) -> Type) a
type Succ (a :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Succ (a :: Proxy s) = Apply (Succ_6989586621680163536Sym0 :: TyFun (Proxy s) (Proxy s) -> Type) a
type ToEnum a
Instance details Defined in Data.Proxy.Singletons type ToEnum a = Apply (ToEnum_6989586621680163554Sym0 :: TyFun Nat (Proxy s) -> Type) a
type Show_ (arg :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Show_ (arg :: Proxy s) = Apply (Show__6989586621680047550Sym0 :: TyFun (Proxy s) Symbol -> Type) arg
type (arg :: Proxy s) /= (arg1 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type (arg :: Proxy s) /= (arg1 :: Proxy s) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) arg) arg1
type (a1 :: Proxy s) == (a2 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type (a1 :: Proxy s) == (a2 :: Proxy s) = Apply (Apply (TFHelper_6989586621680163384Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) a1) a2
type Mappend (arg :: Proxy s) (arg1 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Mappend (arg :: Proxy s) (arg1 :: Proxy s) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (Proxy s) (Proxy s ~> Proxy s) -> Type) arg) arg1
type (arg :: Proxy s) < (arg1 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type (arg :: Proxy s) < (arg1 :: Proxy s) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) arg) arg1
type (arg :: Proxy s) <= (arg1 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type (arg :: Proxy s) <= (arg1 :: Proxy s) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) arg) arg1
type (arg :: Proxy s) > (arg1 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type (arg :: Proxy s) > (arg1 :: Proxy s) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) arg) arg1
type (arg :: Proxy s) >= (arg1 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type (arg :: Proxy s) >= (arg1 :: Proxy s) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) arg) arg1
type Compare (a1 :: Proxy s) (a2 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Compare (a1 :: Proxy s) (a2 :: Proxy s) = Apply (Apply (Compare_6989586621680163447Sym0 :: TyFun (Proxy s) (Proxy s ~> Ordering) -> Type) a1) a2
type Max (arg :: Proxy s) (arg1 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Max (arg :: Proxy s) (arg1 :: Proxy s) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (Proxy s) (Proxy s ~> Proxy s) -> Type) arg) arg1
type Min (arg :: Proxy s) (arg1 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Min (arg :: Proxy s) (arg1 :: Proxy s) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (Proxy s) (Proxy s ~> Proxy s) -> Type) arg) arg1
type (a1 :: Proxy s) <> (a2 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type (a1 :: Proxy s) <> (a2 :: Proxy s) = Apply (Apply (TFHelper_6989586621680163610Sym0 :: TyFun (Proxy s) (Proxy s ~> Proxy s) -> Type) a1) a2
type EnumFromTo (a1 :: Proxy s) (a2 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type EnumFromTo (a1 :: Proxy s) (a2 :: Proxy s) = Apply (Apply (EnumFromTo_6989586621680163579Sym0 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type) a1) a2
type ShowList (arg :: [Proxy s]) arg1
Instance details Defined in Data.Proxy.Singletons type ShowList (arg :: [Proxy s]) arg1 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Proxy s] (Symbol ~> Symbol) -> Type) arg) arg1
type EnumFromThenTo (a1 :: Proxy s) (a2 :: Proxy s) (a3 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type EnumFromThenTo (a1 :: Proxy s) (a2 :: Proxy s) (a3 :: Proxy s) = Apply (Apply (Apply (EnumFromThenTo_6989586621680163568Sym0 :: TyFun (Proxy s) (Proxy s ~> (Proxy s ~> [Proxy s])) -> Type) a1) a2) a3
type ShowsPrec a1 (a2 :: Proxy s) a3
Instance details Defined in Data.Proxy.Singletons type ShowsPrec a1 (a2 :: Proxy s) a3 = Apply (Apply (Apply (ShowsPrec_6989586621680163487Sym0 :: TyFun Nat (Proxy s ~> (Symbol ~> Symbol)) -> Type) a1) a2) a3
type Apply (Product_6989586621680194250Sym0 :: TyFun (Proxy a) a -> Type) (a6989586621680194254 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Product_6989586621680194250Sym0 :: TyFun (Proxy a) a -> Type) (a6989586621680194254 :: Proxy a) = Product_6989586621680194250 a6989586621680194254
type Apply (Sum_6989586621680194244Sym0 :: TyFun (Proxy a) a -> Type) (a6989586621680194248 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Sum_6989586621680194244Sym0 :: TyFun (Proxy a) a -> Type) (a6989586621680194248 :: Proxy a) = Sum_6989586621680194244 a6989586621680194248
type Apply (Fold_6989586621680194173Sym0 :: TyFun (Proxy m) m -> Type) (a6989586621680194177 :: Proxy m)
Instance details Defined in Data.Foldable.Singletons type Apply (Fold_6989586621680194173Sym0 :: TyFun (Proxy m) m -> Type) (a6989586621680194177 :: Proxy m) = Fold_6989586621680194173 a6989586621680194177
type Apply (Elem_6989586621680194236Sym1 a6989586621680194241 :: TyFun (Proxy a) Bool -> Type) (a6989586621680194242 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194236Sym1 a6989586621680194241 :: TyFun (Proxy a) Bool -> Type) (a6989586621680194242 :: Proxy a) = Elem_6989586621680194236 a6989586621680194241 a6989586621680194242
type Apply (Foldl1_6989586621680194206Sym1 a6989586621680194211 :: TyFun (Proxy a) a -> Type) (a6989586621680194212 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl1_6989586621680194206Sym1 a6989586621680194211 :: TyFun (Proxy a) a -> Type) (a6989586621680194212 :: Proxy a) = Foldl1_6989586621680194206 a6989586621680194211 a6989586621680194212
type Apply (Foldr1_6989586621680194215Sym1 a6989586621680194220 :: TyFun (Proxy a) a -> Type) (a6989586621680194221 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr1_6989586621680194215Sym1 a6989586621680194220 :: TyFun (Proxy a) a -> Type) (a6989586621680194221 :: Proxy a) = Foldr1_6989586621680194215 a6989586621680194220 a6989586621680194221
type Apply (Null_6989586621680194229Sym0 :: TyFun (Proxy a) Bool -> Type) (a6989586621680194233 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680194229Sym0 :: TyFun (Proxy a) Bool -> Type) (a6989586621680194233 :: Proxy a) = Null_6989586621680194229 a6989586621680194233
type Apply (Length_6989586621680194223Sym0 :: TyFun (Proxy a) Nat -> Type) (a6989586621680194227 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Length_6989586621680194223Sym0 :: TyFun (Proxy a) Nat -> Type) (a6989586621680194227 :: Proxy a) = Length_6989586621680194223 a6989586621680194227
type Apply (FromEnum_6989586621680163548Sym0 :: TyFun (Proxy s) Nat -> Type) (a6989586621680163552 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (FromEnum_6989586621680163548Sym0 :: TyFun (Proxy s) Nat -> Type) (a6989586621680163552 :: Proxy s) = FromEnum_6989586621680163548 a6989586621680163552
type Apply (FoldMap_6989586621680194165Sym1 a6989586621680194170 :: TyFun (Proxy a) m -> Type) (a6989586621680194171 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194165Sym1 a6989586621680194170 :: TyFun (Proxy a) m -> Type) (a6989586621680194171 :: Proxy a) = FoldMap_6989586621680194165 a6989586621680194170 a6989586621680194171
type Apply (Compare_6989586621680163447Sym1 a6989586621680163452 :: TyFun (Proxy s) Ordering -> Type) (a6989586621680163453 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (Compare_6989586621680163447Sym1 a6989586621680163452 :: TyFun (Proxy s) Ordering -> Type) (a6989586621680163453 :: Proxy s) = Compare_6989586621680163447 a6989586621680163452 a6989586621680163453
type Apply (TFHelper_6989586621680163384Sym1 a6989586621680163389 :: TyFun (Proxy s) Bool -> Type) (a6989586621680163390 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680163384Sym1 a6989586621680163389 :: TyFun (Proxy s) Bool -> Type) (a6989586621680163390 :: Proxy s) = TFHelper_6989586621680163384 a6989586621680163389 a6989586621680163390
type Apply (Foldl_6989586621680194194Sym2 a6989586621680194200 a6989586621680194201 :: TyFun (Proxy a) b -> Type) (a6989586621680194202 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194194Sym2 a6989586621680194200 a6989586621680194201 :: TyFun (Proxy a) b -> Type) (a6989586621680194202 :: Proxy a) = Foldl_6989586621680194194 a6989586621680194200 a6989586621680194201 a6989586621680194202
type Apply (Foldr_6989586621680194181Sym2 a6989586621680194187 a6989586621680194188 :: TyFun (Proxy a) b -> Type) (a6989586621680194189 :: Proxy a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194181Sym2 a6989586621680194187 a6989586621680194188 :: TyFun (Proxy a) b -> Type) (a6989586621680194189 :: Proxy a) = Foldr_6989586621680194181 a6989586621680194187 a6989586621680194188 a6989586621680194189
type Apply (SequenceA_6989586621680478736Sym0 :: TyFun (Proxy (f a)) (f (Proxy a)) -> Type) (a6989586621680478740 :: Proxy (f a))
Instance details Defined in Data.Traversable.Singletons type Apply (SequenceA_6989586621680478736Sym0 :: TyFun (Proxy (f a)) (f (Proxy a)) -> Type) (a6989586621680478740 :: Proxy (f a)) = SequenceA_6989586621680478736 a6989586621680478740
type Apply (Sequence_6989586621680478751Sym0 :: TyFun (Proxy (m a)) (m (Proxy a)) -> Type) (a6989586621680478755 :: Proxy (m a))
Instance details Defined in Data.Traversable.Singletons type Apply (Sequence_6989586621680478751Sym0 :: TyFun (Proxy (m a)) (m (Proxy a)) -> Type) (a6989586621680478755 :: Proxy (m a)) = Sequence_6989586621680478751 a6989586621680478755
type Apply (EnumFromTo_6989586621680163579Sym1 a6989586621680163584 :: TyFun (Proxy s) [Proxy s] -> Type) (a6989586621680163585 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (EnumFromTo_6989586621680163579Sym1 a6989586621680163584 :: TyFun (Proxy s) [Proxy s] -> Type) (a6989586621680163585 :: Proxy s) = EnumFromTo_6989586621680163579 a6989586621680163584 a6989586621680163585
type Apply (Traverse_6989586621680478728Sym1 a6989586621680478733 :: TyFun (Proxy a) (f (Proxy b)) -> Type) (a6989586621680478734 :: Proxy a)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478728Sym1 a6989586621680478733 :: TyFun (Proxy a) (f (Proxy b)) -> Type) (a6989586621680478734 :: Proxy a) = Traverse_6989586621680478728 a6989586621680478733 a6989586621680478734
type Apply (MapM_6989586621680478743Sym1 a6989586621680478748 :: TyFun (Proxy a) (m (Proxy b)) -> Type) (a6989586621680478749 :: Proxy a)
Instance details Defined in Data.Traversable.Singletons type Apply (MapM_6989586621680478743Sym1 a6989586621680478748 :: TyFun (Proxy a) (m (Proxy b)) -> Type) (a6989586621680478749 :: Proxy a) = MapM_6989586621680478743 a6989586621680478748 a6989586621680478749
type Apply (EnumFromThenTo_6989586621680163568Sym2 a6989586621680163574 a6989586621680163575 :: TyFun (Proxy s) [Proxy s] -> Type) (a6989586621680163576 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (EnumFromThenTo_6989586621680163568Sym2 a6989586621680163574 a6989586621680163575 :: TyFun (Proxy s) [Proxy s] -> Type) (a6989586621680163576 :: Proxy s) = EnumFromThenTo_6989586621680163568 a6989586621680163574 a6989586621680163575 a6989586621680163576
type Apply (Foldl1_6989586621680194206Sym0 :: TyFun (a ~> (a ~> a)) (Proxy a ~> a) -> Type) (a6989586621680194211 :: a ~> (a ~> a))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl1_6989586621680194206Sym0 :: TyFun (a ~> (a ~> a)) (Proxy a ~> a) -> Type) (a6989586621680194211 :: a ~> (a ~> a)) = Foldl1_6989586621680194206Sym1 a6989586621680194211
type Apply (Foldr1_6989586621680194215Sym0 :: TyFun (a ~> (a ~> a)) (Proxy a ~> a) -> Type) (a6989586621680194220 :: a ~> (a ~> a))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr1_6989586621680194215Sym0 :: TyFun (a ~> (a ~> a)) (Proxy a ~> a) -> Type) (a6989586621680194220 :: a ~> (a ~> a)) = Foldr1_6989586621680194215Sym1 a6989586621680194220
type Apply (TFHelper_6989586621680163961Sym0 :: TyFun (Proxy (a ~> b)) (Proxy a ~> Proxy b) -> Type) (a6989586621680163966 :: Proxy (a ~> b))
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680163961Sym0 :: TyFun (Proxy (a ~> b)) (Proxy a ~> Proxy b) -> Type) (a6989586621680163966 :: Proxy (a ~> b)) = TFHelper_6989586621680163961Sym1 a6989586621680163966
type Apply (TFHelper_6989586621680163985Sym0 :: TyFun (Proxy a) (Proxy a ~> Proxy a) -> Type) (a6989586621680163990 :: Proxy a)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680163985Sym0 :: TyFun (Proxy a) (Proxy a ~> Proxy a) -> Type) (a6989586621680163990 :: Proxy a) = TFHelper_6989586621680163985Sym1 a6989586621680163990
type Apply (Pred_6989586621680163542Sym0 :: TyFun (Proxy s) (Proxy s) -> Type) (a6989586621680163546 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (Pred_6989586621680163542Sym0 :: TyFun (Proxy s) (Proxy s) -> Type) (a6989586621680163546 :: Proxy s) = Pred_6989586621680163542 a6989586621680163546
type Apply (Succ_6989586621680163536Sym0 :: TyFun (Proxy s) (Proxy s) -> Type) (a6989586621680163540 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (Succ_6989586621680163536Sym0 :: TyFun (Proxy s) (Proxy s) -> Type) (a6989586621680163540 :: Proxy s) = Succ_6989586621680163536 a6989586621680163540
type Apply (TFHelper_6989586621680163610Sym0 :: TyFun (Proxy s) (Proxy s ~> Proxy s) -> Type) (a6989586621680163615 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680163610Sym0 :: TyFun (Proxy s) (Proxy s ~> Proxy s) -> Type) (a6989586621680163615 :: Proxy s) = TFHelper_6989586621680163610Sym1 a6989586621680163615
type Apply (Compare_6989586621680163447Sym0 :: TyFun (Proxy s) (Proxy s ~> Ordering) -> Type) (a6989586621680163452 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (Compare_6989586621680163447Sym0 :: TyFun (Proxy s) (Proxy s ~> Ordering) -> Type) (a6989586621680163452 :: Proxy s) = Compare_6989586621680163447Sym1 a6989586621680163452
type Apply (EnumFromThenTo_6989586621680163568Sym0 :: TyFun (Proxy s) (Proxy s ~> (Proxy s ~> [Proxy s])) -> Type) (a6989586621680163574 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (EnumFromThenTo_6989586621680163568Sym0 :: TyFun (Proxy s) (Proxy s ~> (Proxy s ~> [Proxy s])) -> Type) (a6989586621680163574 :: Proxy s) = EnumFromThenTo_6989586621680163568Sym1 a6989586621680163574
type Apply (TFHelper_6989586621680163384Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) (a6989586621680163389 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680163384Sym0 :: TyFun (Proxy s) (Proxy s ~> Bool) -> Type) (a6989586621680163389 :: Proxy s) = TFHelper_6989586621680163384Sym1 a6989586621680163389
type Apply (EnumFromTo_6989586621680163579Sym0 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type) (a6989586621680163584 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (EnumFromTo_6989586621680163579Sym0 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type) (a6989586621680163584 :: Proxy s) = EnumFromTo_6989586621680163579Sym1 a6989586621680163584
type Apply (Foldr_6989586621680194181Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Proxy a ~> b)) -> Type) (a6989586621680194187 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194181Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Proxy a ~> b)) -> Type) (a6989586621680194187 :: a ~> (b ~> b)) = Foldr_6989586621680194181Sym1 a6989586621680194187
type Apply (Fmap_6989586621680163886Sym0 :: TyFun (a ~> b) (Proxy a ~> Proxy b) -> Type) (a6989586621680163891 :: a ~> b)
Instance details Defined in Data.Proxy.Singletons type Apply (Fmap_6989586621680163886Sym0 :: TyFun (a ~> b) (Proxy a ~> Proxy b) -> Type) (a6989586621680163891 :: a ~> b) = Fmap_6989586621680163886Sym1 a6989586621680163891
type Apply (FoldMap_6989586621680194165Sym0 :: TyFun (a ~> m) (Proxy a ~> m) -> Type) (a6989586621680194170 :: a ~> m)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194165Sym0 :: TyFun (a ~> m) (Proxy a ~> m) -> Type) (a6989586621680194170 :: a ~> m) = FoldMap_6989586621680194165Sym1 a6989586621680194170
type Apply (Foldl_6989586621680194194Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Proxy a ~> b)) -> Type) (a6989586621680194200 :: b ~> (a ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194194Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Proxy a ~> b)) -> Type) (a6989586621680194200 :: b ~> (a ~> b)) = Foldl_6989586621680194194Sym1 a6989586621680194200
type Apply (Fmap_6989586621680163886Sym1 a6989586621680163891 :: TyFun (Proxy a) (Proxy b) -> Type) (a6989586621680163892 :: Proxy a)
Instance details Defined in Data.Proxy.Singletons type Apply (Fmap_6989586621680163886Sym1 a6989586621680163891 :: TyFun (Proxy a) (Proxy b) -> Type) (a6989586621680163892 :: Proxy a) = Fmap_6989586621680163886 a6989586621680163891 a6989586621680163892
type Apply (TFHelper_6989586621680163961Sym1 a6989586621680163966 :: TyFun (Proxy a) (Proxy b) -> Type) (a6989586621680163967 :: Proxy a)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680163961Sym1 a6989586621680163966 :: TyFun (Proxy a) (Proxy b) -> Type) (a6989586621680163967 :: Proxy a) = TFHelper_6989586621680163961 a6989586621680163966 a6989586621680163967
type Apply (TFHelper_6989586621680164026Sym0 :: TyFun (Proxy a) ((a ~> Proxy b) ~> Proxy b) -> Type) (a6989586621680164031 :: Proxy a)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680164026Sym0 :: TyFun (Proxy a) ((a ~> Proxy b) ~> Proxy b) -> Type) (a6989586621680164031 :: Proxy a) = TFHelper_6989586621680164026Sym1 a6989586621680164031 :: TyFun (a ~> Proxy b) (Proxy b) -> Type
type Apply (TFHelper_6989586621680163985Sym1 a6989586621680163990 :: TyFun (Proxy a) (Proxy a) -> Type) (a6989586621680163991 :: Proxy a)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680163985Sym1 a6989586621680163990 :: TyFun (Proxy a) (Proxy a) -> Type) (a6989586621680163991 :: Proxy a) = TFHelper_6989586621680163985 a6989586621680163990 a6989586621680163991
type Apply (TFHelper_6989586621680163610Sym1 a6989586621680163615 :: TyFun (Proxy s) (Proxy s) -> Type) (a6989586621680163616 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680163610Sym1 a6989586621680163615 :: TyFun (Proxy s) (Proxy s) -> Type) (a6989586621680163616 :: Proxy s) = TFHelper_6989586621680163610 a6989586621680163615 a6989586621680163616
type Apply (EnumFromThenTo_6989586621680163568Sym1 a6989586621680163574 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type) (a6989586621680163575 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (EnumFromThenTo_6989586621680163568Sym1 a6989586621680163574 :: TyFun (Proxy s) (Proxy s ~> [Proxy s]) -> Type) (a6989586621680163575 :: Proxy s) = EnumFromThenTo_6989586621680163568Sym2 a6989586621680163574 a6989586621680163575
type Apply (ShowsPrec_6989586621680163487Sym1 a6989586621680163495 :: TyFun (Proxy s) (Symbol ~> Symbol) -> Type) (a6989586621680163496 :: Proxy s)
Instance details Defined in Data.Proxy.Singletons type Apply (ShowsPrec_6989586621680163487Sym1 a6989586621680163495 :: TyFun (Proxy s) (Symbol ~> Symbol) -> Type) (a6989586621680163496 :: Proxy s) = ShowsPrec_6989586621680163487Sym2 a6989586621680163495 a6989586621680163496
type Apply (Traverse_6989586621680478728Sym0 :: TyFun (a ~> f b) (Proxy a ~> f (Proxy b)) -> Type) (a6989586621680478733 :: a ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478728Sym0 :: TyFun (a ~> f b) (Proxy a ~> f (Proxy b)) -> Type) (a6989586621680478733 :: a ~> f b) = Traverse_6989586621680478728Sym1 a6989586621680478733
type Apply (MapM_6989586621680478743Sym0 :: TyFun (a ~> m b) (Proxy a ~> m (Proxy b)) -> Type) (a6989586621680478748 :: a ~> m b)
Instance details Defined in Data.Traversable.Singletons type Apply (MapM_6989586621680478743Sym0 :: TyFun (a ~> m b) (Proxy a ~> m (Proxy b)) -> Type) (a6989586621680478748 :: a ~> m b) = MapM_6989586621680478743Sym1 a6989586621680478748
type Apply (TFHelper_6989586621680164026Sym1 a6989586621680164031 :: TyFun (a ~> Proxy b) (Proxy b) -> Type) (a6989586621680164032 :: a ~> Proxy b)
Instance details Defined in Data.Proxy.Singletons type Apply (TFHelper_6989586621680164026Sym1 a6989586621680164031 :: TyFun (a ~> Proxy b) (Proxy b) -> Type) (a6989586621680164032 :: a ~> Proxy b) = TFHelper_6989586621680164026 a6989586621680164031 a6989586621680164032

either :: (a -> c) -> (b -> c) -> Either a b -> c #

Case analysis for the Either type. If the value is Left a, apply the first function to a; if it is Right b, apply the second function to b.

Examples

Expand

We create two values of type Either String Int, one using the Left constructor and another using the Right constructor. Then we apply "either" the length function (if we have a String) or the "times-two" function (if we have an Int):

>>> let s = Left "foo" :: Either String Int
>>> let n = Right 3 :: Either String Int
>>> either length (*2) s
3
>>> either length (*2) n
6

partitionEithers :: [Either a b] -> ([a], [b]) #

Partitions a list of Either into two lists. All the Left elements are extracted, in order, to the first component of the output. Similarly the Right elements are extracted to the second component of the output.

Examples

Expand

Basic usage:

>>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
>>> partitionEithers list
(["foo","bar","baz"],[3,7])

The pair returned by partitionEithers x should be the same pair as (lefts x, rights x):

>>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
>>> partitionEithers list == (lefts list, rights list)
True

readMaybe :: Read a => String -> Maybe a #

Parse a string using the Read instance. Succeeds if there is exactly one valid result.

>>> readMaybe "123" :: Maybe Int
Just 123

>>> readMaybe "hello" :: Maybe Int
Nothing

Since: base-4.6.0.0

reads :: Read a => ReadS a #

equivalent to readsPrec with a precedence of 0.

comparing :: Ord a => (b -> a) -> b -> b -> Ordering #

comparing p x y = compare (p x) (p y)

Useful combinator for use in conjunction with the xxxBy family of functions from Data.List, for example:

  ... sortBy (comparing fst) ...

intercalate :: [a] -> [[a]] -> [a] #

intercalate xs xss is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.

>>> intercalate ", " ["Lorem", "ipsum", "dolor"]
"Lorem, ipsum, dolor"

intersperse :: a -> [a] -> [a] #

$\mathcal{O}(n)$. The intersperse function takes an element and a list and `intersperses' that element between the elements of the list. For example,

>>> intersperse ',' "abcde"
"a,b,c,d,e"

isPrefixOf :: Eq a => [a] -> [a] -> Bool #

$\mathcal{O}(\min(m,n))$. The isPrefixOf function takes two lists and returns True iff the first list is a prefix of the second.

>>> "Hello" `isPrefixOf` "Hello World!"
True

>>> "Hello" `isPrefixOf` "Wello Horld!"
False

sort :: Ord a => [a] -> [a] #

The sort function implements a stable sorting algorithm. It is a special case of sortBy, which allows the programmer to supply their own comparison function.

Elements are arranged from lowest to highest, keeping duplicates in the order they appeared in the input.

>>> sort [1,6,4,3,2,5]
[1,2,3,4,5,6]

sortBy :: (a -> a -> Ordering) -> [a] -> [a] #

The sortBy function is the non-overloaded version of sort.

>>> sortBy (\(a,_) (b,_) -> compare a b) [(2, "world"), (4, "!"), (1, "Hello")]
[(1,"Hello"),(2,"world"),(4,"!")]

unfoldr :: (b -> Maybe (a, b)) -> b -> [a] #

The unfoldr function is a `dual' to foldr: while foldr reduces a list to a summary value, unfoldr builds a list from a seed value. The function takes the element and returns Nothing if it is done producing the list or returns Just (a,b), in which case, a is a prepended to the list and b is used as the next element in a recursive call. For example,

iterate f == unfoldr (\x -> Just (x, f x))

In some cases, unfoldr can undo a foldr operation:

unfoldr f' (foldr f z xs) == xs

if the following holds:

f' (f x y) = Just (x,y)
f' z       = Nothing

A simple use of unfoldr:

>>> unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
[10,9,8,7,6,5,4,3,2,1]

concatMap :: Foldable t => (a -> [b]) -> t a -> [b] #

Map a function over all the elements of a container and concatenate the resulting lists.

Examples

Expand

Basic usage:

>>> concatMap (take 3) [[1..], [10..], [100..], [1000..]]
[1,2,3,10,11,12,100,101,102,1000,1001,1002]

>>> concatMap (take 3) (Just [1..])
[1,2,3]

newtype Const a (b :: k) #

The Const functor.

Constructors

Const
Fields getConst :: a

Instances

Instances details

() :=> (Functor (Const a :: Type -> Type))
Instance details Defined in Data.Constraint Methods ins :: () :- Functor (Const a) #
Generic1 (Const a :: k -> Type)
Instance details Defined in Data.Functor.Const Associated Types type Rep1 (Const a) :: k -> Type # Methods from1 :: forall (a0 :: k0). Const a a0 -> Rep1 (Const a) a0 # to1 :: forall (a0 :: k0). Rep1 (Const a) a0 -> Const a a0 #
Unbox a => Vector Vector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> m (Vector (Const a b)) # basicUnsafeThaw :: PrimMonad m => Vector (Const a b) -> m (Mutable Vector (PrimState m) (Const a b)) # basicLength :: Vector (Const a b) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b) # basicUnsafeIndexM :: Monad m => Vector (Const a b) -> Int -> m (Const a b) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> Vector (Const a b) -> m () # elemseq :: Vector (Const a b) -> Const a b -> b0 -> b0 #
Unbox a => MVector MVector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Const a b) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Const a b) -> MVector s (Const a b) # basicOverlaps :: MVector s (Const a b) -> MVector s (Const a b) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Const a b)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Const a b) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Const a b -> m (MVector (PrimState m) (Const a b)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> m (Const a b) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> Const a b -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Const a b) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Const a b) -> Const a b -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Const a b) -> MVector (PrimState m) (Const a b) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Const a b) -> MVector (PrimState m) (Const a b) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> m (MVector (PrimState m) (Const a b)) #
Bifunctor (Const :: Type -> Type -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d # first :: (a -> b) -> Const a c -> Const b c # second :: (b -> c) -> Const a b -> Const a c #
NFData2 (Const :: Type -> Type -> Type)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> Const a b -> () #
Hashable2 (Const :: Type -> Type -> Type)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Const a b -> Int #
(Bits a) :=> (Bits (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Bits a :- Bits (Const a b) #
(Monoid a) :=> (Applicative (Const a :: Type -> Type))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Applicative (Const a) #
(Monoid a) :=> (Monoid (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Monoid (Const a b) #
(Semigroup a) :=> (Semigroup (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Semigroup a :- Semigroup (Const a b) #
(Bounded a) :=> (Bounded (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Bounded a :- Bounded (Const a b) #
(Enum a) :=> (Enum (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Enum a :- Enum (Const a b) #
(Floating a) :=> (Floating (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Floating a :- Floating (Const a b) #
(RealFloat a) :=> (RealFloat (Const a b))
Instance details Defined in Data.Constraint Methods ins :: RealFloat a :- RealFloat (Const a b) #
(Num a) :=> (Num (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Num a :- Num (Const a b) #
(Read a) :=> (Read (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Read a :- Read (Const a b) #
(Fractional a) :=> (Fractional (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Fractional a :- Fractional (Const a b) #
(Integral a) :=> (Integral (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Integral (Const a b) #
(Real a) :=> (Real (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Real a :- Real (Const a b) #
(RealFrac a) :=> (RealFrac (Const a b))
Instance details Defined in Data.Constraint Methods ins :: RealFrac a :- RealFrac (Const a b) #
(Show a) :=> (Show (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Show a :- Show (Const a b) #
(Eq a) :=> (Eq (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Eq a :- Eq (Const a b) #
(Ord a) :=> (Ord (Const a b))
Instance details Defined in Data.Constraint Methods ins :: Ord a :- Ord (Const a b) #
Foldable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b # foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # toList :: Const m a -> [a] # null :: Const m a -> Bool # length :: Const m a -> Int # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # sum :: Num a => Const m a -> a # product :: Num a => Const m a -> a #
Traversable (Const m :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) # sequenceA :: Applicative f => Const m (f a) -> f (Const m a) # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b) # sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a) #
Monoid m => Applicative (Const m :: Type -> Type)	Since: base-2.0.1
Instance details Defined in Data.Functor.Const Methods pure :: a -> Const m a # (<>) :: Const m (a -> b) -> Const m a -> Const m b # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c # (>) :: Const m a -> Const m b -> Const m b # (<*) :: Const m a -> Const m b -> Const m a #
Functor (Const m :: Type -> Type)	Since: base-2.1
Instance details Defined in Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b # (<$) :: a -> Const m b -> Const m a #
NFData a => NFData1 (Const a :: Type -> Type)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a0 -> ()) -> Const a a0 -> () #
Hashable a => Hashable1 (Const a :: Type -> Type)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a0 -> Int) -> Int -> Const a a0 -> Int #
PTraversable (Const m :: Type -> Type)
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable (Const m :: Type -> Type)
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: Const m a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: Const m (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m0 :: Type -> Type) b (t1 :: a ~> m0 b) (t2 :: Const m a). SMonad m0 => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m0 :: Type -> Type) a (t1 :: Const m (m0 a)). SMonad m0 => Sing t1 -> Sing (Apply SequenceSym0 t1) #
SuppressUnusedWarnings (Pure_6989586621680428781Sym0 :: TyFun a (Const m a) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SingI (GetConstSym0 :: TyFun (Const a b) a -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods sing :: Sing GetConstSym0 #
SingI (ConstSym0 :: TyFun a (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods sing :: Sing ConstSym0 #
SuppressUnusedWarnings (TFHelper_6989586621680428802Sym0 :: TyFun (Const m (a ~> b)) (Const m a ~> Const m b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Abs_6989586621680428667Sym0 :: TyFun (Const a b) (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Negate_6989586621680428660Sym0 :: TyFun (Const a b) (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pred_6989586621680428577Sym0 :: TyFun (Const a b) (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Signum_6989586621680428674Sym0 :: TyFun (Const a b) (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Succ_6989586621680428570Sym0 :: TyFun (Const a b) (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428628Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428639Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428650Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428689Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680428560Sym0 :: TyFun (Const a b) (Const a b ~> Ordering) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680428611Sym0 :: TyFun (Const a b) (Const a b ~> (Const a b ~> [Const a b])) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428549Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromTo_6989586621680428599Sym0 :: TyFun (Const a b) (Const a b ~> [Const a b]) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromEnum_6989586621680428591Sym0 :: TyFun (Const a b) Nat -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GetConstSym0 :: TyFun (Const a b) a -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680428763Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Const m a ~> b)) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621680428717Sym0 :: TyFun (a ~> b) (Const m a ~> Const m b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680478603Scrutinee_6989586621680478187Sym0 :: TyFun (a ~> b) (TyFun (t a) (Const b (t ())) -> Type) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680428747Sym0 :: TyFun (a ~> m1) (Const m2 a ~> m1) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromInteger_6989586621680428681Sym0 :: TyFun Nat (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ToEnum_6989586621680428584Sym0 :: TyFun Nat (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680428701Sym0 :: TyFun Nat (Const a b ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ConstSym0 :: TyFun a (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680478597MkConstSym0 :: TyFun k1 (TyFun k2 (TyFun m6989586621680478093 (Const m6989586621680478093 ()) -> Type) -> Type) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621680428717Sym1 a6989586621680428722 :: TyFun (Const m a) (Const m b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428802Sym1 a6989586621680428807 :: TyFun (Const m a) (Const m b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680428747Sym1 a6989586621680428752 :: TyFun (Const m2 a) m1 -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428628Sym1 a6989586621680428633 :: TyFun (Const a b) (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428639Sym1 a6989586621680428644 :: TyFun (Const a b) (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428650Sym1 a6989586621680428655 :: TyFun (Const a b) (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428689Sym1 a6989586621680428694 :: TyFun (Const a b) (Const a b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680428560Sym1 a6989586621680428565 :: TyFun (Const a b) Ordering -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680428611Sym1 a6989586621680428617 :: TyFun (Const a b) (Const a b ~> [Const a b]) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680428701Sym1 a6989586621680428709 :: TyFun (Const a b) (Symbol ~> Symbol) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428549Sym1 a6989586621680428554 :: TyFun (Const a b) Bool -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromTo_6989586621680428599Sym1 a6989586621680428604 :: TyFun (Const a b) [Const a b] -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621680428789Sym0 :: TyFun (a ~> (b ~> c)) (Const m a ~> (Const m b ~> Const m c)) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478758Sym0 :: TyFun (a ~> f b) (Const m a ~> f (Const m b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428732Sym0 :: TyFun a (Const m b ~> Const m a) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680428763Sym1 a6989586621680428769 :: TyFun b (Const m a ~> b) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680478597MkConstSym1 f6989586621680478595 :: TyFun k2 (TyFun m6989586621680478093 (Const m6989586621680478093 ()) -> Type) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680478603Scrutinee_6989586621680478187Sym1 f6989586621680478595 :: TyFun (t a) (Const b (t ())) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621680428789Sym1 a6989586621680428795 :: TyFun (Const m a) (Const m b ~> Const m c) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680428763Sym2 a6989586621680428769 a6989586621680428770 :: TyFun (Const m a) b -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478758Sym1 a6989586621680478763 :: TyFun (Const m a) (f (Const m b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680428611Sym2 a6989586621680428617 a6989586621680428618 :: TyFun (Const a b) [Const a b] -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680428732Sym1 a6989586621680428737 :: TyFun (Const m b) (Const m a) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680478597MkConstSym2 f6989586621680478595 x6989586621680478596 :: TyFun m6989586621680478093 (Const m6989586621680478093 ()) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621680428789Sym2 a6989586621680428795 a6989586621680428796 :: TyFun (Const m b) (Const m c) -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods suppressUnusedWarnings :: () #
Bits a => Bits (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b # (.\|.) :: Const a b -> Const a b -> Const a b # xor :: Const a b -> Const a b -> Const a b # complement :: Const a b -> Const a b # shift :: Const a b -> Int -> Const a b # rotate :: Const a b -> Int -> Const a b # zeroBits :: Const a b # bit :: Int -> Const a b # setBit :: Const a b -> Int -> Const a b # clearBit :: Const a b -> Int -> Const a b # complementBit :: Const a b -> Int -> Const a b # testBit :: Const a b -> Int -> Bool # bitSizeMaybe :: Const a b -> Maybe Int # bitSize :: Const a b -> Int # isSigned :: Const a b -> Bool # shiftL :: Const a b -> Int -> Const a b # unsafeShiftL :: Const a b -> Int -> Const a b # shiftR :: Const a b -> Int -> Const a b # unsafeShiftR :: Const a b -> Int -> Const a b # rotateL :: Const a b -> Int -> Const a b # rotateR :: Const a b -> Int -> Const a b # popCount :: Const a b -> Int #
FiniteBits a => FiniteBits (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods finiteBitSize :: Const a b -> Int # countLeadingZeros :: Const a b -> Int # countTrailingZeros :: Const a b -> Int #
IsString a => IsString (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Const a b #
Storable a => Storable (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods sizeOf :: Const a b -> Int # alignment :: Const a b -> Int # peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) # pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () # peekByteOff :: Ptr b0 -> Int -> IO (Const a b) # pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () # peek :: Ptr (Const a b) -> IO (Const a b) # poke :: Ptr (Const a b) -> Const a b -> IO () #
Monoid a => Monoid (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods mempty :: Const a b # mappend :: Const a b -> Const a b -> Const a b # mconcat :: [Const a b] -> Const a b #
Semigroup a => Semigroup (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (<>) :: Const a b -> Const a b -> Const a b # sconcat :: NonEmpty (Const a b) -> Const a b # stimes :: Integral b0 => b0 -> Const a b -> Const a b #
Bounded a => Bounded (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b # maxBound :: Const a b #
Enum a => Enum (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # toEnum :: Int -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] #
Floating a => Floating (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods pi :: Const a b # exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b # expm1 :: Const a b -> Const a b # log1pexp :: Const a b -> Const a b # log1mexp :: Const a b -> Const a b #
RealFloat a => RealFloat (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods floatRadix :: Const a b -> Integer # floatDigits :: Const a b -> Int # floatRange :: Const a b -> (Int, Int) # decodeFloat :: Const a b -> (Integer, Int) # encodeFloat :: Integer -> Int -> Const a b # exponent :: Const a b -> Int # significand :: Const a b -> Const a b # scaleFloat :: Int -> Const a b -> Const a b # isNaN :: Const a b -> Bool # isInfinite :: Const a b -> Bool # isDenormalized :: Const a b -> Bool # isNegativeZero :: Const a b -> Bool # isIEEE :: Const a b -> Bool # atan2 :: Const a b -> Const a b -> Const a b #
Generic (Const a b)
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type # Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Ix a => Ix (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods range :: (Const a b, Const a b) -> [Const a b] # index :: (Const a b, Const a b) -> Const a b -> Int # unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int # inRange :: (Const a b, Const a b) -> Const a b -> Bool # rangeSize :: (Const a b, Const a b) -> Int # unsafeRangeSize :: (Const a b, Const a b) -> Int #
Num a => Num (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (+) :: Const a b -> Const a b -> Const a b # (-) :: Const a b -> Const a b -> Const a b # (*) :: Const a b -> Const a b -> Const a b # negate :: Const a b -> Const a b # abs :: Const a b -> Const a b # signum :: Const a b -> Const a b # fromInteger :: Integer -> Const a b #
Read a => Read (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods readsPrec :: Int -> ReadS (Const a b) # readList :: ReadS [Const a b] # readPrec :: ReadPrec (Const a b) # readListPrec :: ReadPrec [Const a b] #
Fractional a => Fractional (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (/) :: Const a b -> Const a b -> Const a b # recip :: Const a b -> Const a b # fromRational :: Rational -> Const a b #
Integral a => Integral (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b # rem :: Const a b -> Const a b -> Const a b # div :: Const a b -> Const a b -> Const a b # mod :: Const a b -> Const a b -> Const a b # quotRem :: Const a b -> Const a b -> (Const a b, Const a b) # divMod :: Const a b -> Const a b -> (Const a b, Const a b) # toInteger :: Const a b -> Integer #
Real a => Real (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational #
RealFrac a => RealFrac (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods properFraction :: Integral b0 => Const a b -> (b0, Const a b) # truncate :: Integral b0 => Const a b -> b0 # round :: Integral b0 => Const a b -> b0 # ceiling :: Integral b0 => Const a b -> b0 # floor :: Integral b0 => Const a b -> b0 #
Show a => Show (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods showsPrec :: Int -> Const a b -> ShowS # show :: Const a b -> String # showList :: [Const a b] -> ShowS #
NFData a => NFData (Const a b)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Const a b -> () #
Eq a => Eq (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (==) :: Const a b -> Const a b -> Bool # (/=) :: Const a b -> Const a b -> Bool #
Ord a => Ord (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods compare :: Const a b -> Const a b -> Ordering # (<) :: Const a b -> Const a b -> Bool # (<=) :: Const a b -> Const a b -> Bool # (>) :: Const a b -> Const a b -> Bool # (>=) :: Const a b -> Const a b -> Bool # max :: Const a b -> Const a b -> Const a b # min :: Const a b -> Const a b -> Const a b #
Hashable a => Hashable (Const a b)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Const a b -> Int # hash :: Const a b -> Int #
Wrapped (Const a x)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Const a x) # Methods _Wrapped' :: Iso' (Const a x) (Unwrapped (Const a x)) #
Ring a => Ring (Const a b)
Instance details Defined in Data.Semiring Methods negate :: Const a b -> Const a b #
Semiring a => Semiring (Const a b)
Instance details Defined in Data.Semiring Methods plus :: Const a b -> Const a b -> Const a b # zero :: Const a b # times :: Const a b -> Const a b -> Const a b # one :: Const a b # fromNatural :: Natural -> Const a b #
Container (Const a b)
Instance details Defined in Universum.Container.Class Associated Types type Element (Const a b) # Methods toList :: Const a b -> [Element (Const a b)] # null :: Const a b -> Bool # foldr :: (Element (Const a b) -> b0 -> b0) -> b0 -> Const a b -> b0 # foldl :: (b0 -> Element (Const a b) -> b0) -> b0 -> Const a b -> b0 # foldl' :: (b0 -> Element (Const a b) -> b0) -> b0 -> Const a b -> b0 # length :: Const a b -> Int # elem :: Element (Const a b) -> Const a b -> Bool # foldMap :: Monoid m => (Element (Const a b) -> m) -> Const a b -> m # fold :: Const a b -> Element (Const a b) # foldr' :: (Element (Const a b) -> b0 -> b0) -> b0 -> Const a b -> b0 # notElem :: Element (Const a b) -> Const a b -> Bool # all :: (Element (Const a b) -> Bool) -> Const a b -> Bool # any :: (Element (Const a b) -> Bool) -> Const a b -> Bool # and :: Const a b -> Bool # or :: Const a b -> Bool # find :: (Element (Const a b) -> Bool) -> Const a b -> Maybe (Element (Const a b)) # safeHead :: Const a b -> Maybe (Element (Const a b)) # safeMaximum :: Const a b -> Maybe (Element (Const a b)) # safeMinimum :: Const a b -> Maybe (Element (Const a b)) # safeFoldr1 :: (Element (Const a b) -> Element (Const a b) -> Element (Const a b)) -> Const a b -> Maybe (Element (Const a b)) # safeFoldl1 :: (Element (Const a b) -> Element (Const a b) -> Element (Const a b)) -> Const a b -> Maybe (Element (Const a b)) #
Unbox a => Unbox (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base
t ~ Const a' x' => Rewrapped (Const a x) t
Instance details Defined in Control.Lens.Wrapped
SDecide a => TestCoercion (SConst :: Const a b -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods testCoercion :: forall (a0 :: k) (b0 :: k). SConst a0 -> SConst b0 -> Maybe (Coercion a0 b0) #
SDecide a => TestEquality (SConst :: Const a b -> Type)
Instance details Defined in Data.Functor.Const.Singletons Methods testEquality :: forall (a0 :: k) (b0 :: k). SConst a0 -> SConst b0 -> Maybe (a0 :~: b0) #
type MapM (arg1 :: a ~> m1 b) (arg2 :: Const m2 a)
Instance details Defined in Data.Traversable.Singletons type MapM (arg1 :: a ~> m1 b) (arg2 :: Const m2 a) = Apply (Apply (MapM_6989586621680471103Sym0 :: TyFun (a ~> m1 b) (Const m2 a ~> m1 (Const m2 b)) -> Type) arg1) arg2
type Traverse (a2 :: a1 ~> f b) (a3 :: Const m a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a2 :: a1 ~> f b) (a3 :: Const m a1) = Apply (Apply (Traverse_6989586621680478758Sym0 :: TyFun (a1 ~> f b) (Const m a1 ~> f (Const m b)) -> Type) a2) a3
type LiftA2 (a2 :: a1 ~> (b ~> c)) (a3 :: Const m a1) (a4 :: Const m b)
Instance details Defined in Data.Functor.Const.Singletons type LiftA2 (a2 :: a1 ~> (b ~> c)) (a3 :: Const m a1) (a4 :: Const m b) = Apply (Apply (Apply (LiftA2_6989586621680428789Sym0 :: TyFun (a1 ~> (b ~> c)) (Const m a1 ~> (Const m b ~> Const m c)) -> Type) a2) a3) a4
type Fmap (a2 :: a1 ~> b) (a3 :: Const m a1)
Instance details Defined in Data.Functor.Const.Singletons type Fmap (a2 :: a1 ~> b) (a3 :: Const m a1) = Apply (Apply (Fmap_6989586621680428717Sym0 :: TyFun (a1 ~> b) (Const m a1 ~> Const m b) -> Type) a2) a3
type FoldMap (a2 :: a1 ~> k2) (a3 :: Const m a1)
Instance details Defined in Data.Functor.Const.Singletons type FoldMap (a2 :: a1 ~> k2) (a3 :: Const m a1) = Apply (Apply (FoldMap_6989586621680428747Sym0 :: TyFun (a1 ~> k2) (Const m a1 ~> k2) -> Type) a2) a3
type Foldl (arg :: b ~> (a ~> b)) (arg1 :: b) (arg2 :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Foldl (arg :: b ~> (a ~> b)) (arg1 :: b) (arg2 :: Const m a) = Apply (Apply (Apply (Foldl_6989586621680193627Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Const m a ~> b)) -> Type) arg) arg1) arg2
type Foldl' (arg :: b ~> (a ~> b)) (arg1 :: b) (arg2 :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Foldl' (arg :: b ~> (a ~> b)) (arg1 :: b) (arg2 :: Const m a) = Apply (Apply (Apply (Foldl'_6989586621680193642Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Const m a ~> b)) -> Type) arg) arg1) arg2
type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Const m a1)
Instance details Defined in Data.Functor.Const.Singletons type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Const m a1) = Apply (Apply (Apply (Foldr_6989586621680428763Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Const m a1 ~> k2)) -> Type) a2) a3) a4
type Foldr' (arg :: a ~> (b ~> b)) (arg1 :: b) (arg2 :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Foldr' (arg :: a ~> (b ~> b)) (arg1 :: b) (arg2 :: Const m a) = Apply (Apply (Apply (Foldr'_6989586621680193604Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Const m a ~> b)) -> Type) arg) arg1) arg2
type Rep1 (Const a :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const type Rep1 (Const a :: k -> Type) = D1 ('MetaData "Const" "Data.Functor.Const" "base" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Pure (a :: k1)
Instance details Defined in Data.Functor.Const.Singletons type Pure (a :: k1) = Apply (Pure_6989586621680428781Sym0 :: TyFun k1 (Const m k1) -> Type) a
type Elem (arg :: a) (arg1 :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Elem (arg :: a) (arg1 :: Const m a) = Apply (Apply (Elem_6989586621680193750Sym0 :: TyFun a (Const m a ~> Bool) -> Type) arg) arg1
type Foldl1 (arg :: a ~> (a ~> a)) (arg1 :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Foldl1 (arg :: a ~> (a ~> a)) (arg1 :: Const m a) = Apply (Apply (Foldl1_6989586621680193685Sym0 :: TyFun (a ~> (a ~> a)) (Const m a ~> a) -> Type) arg) arg1
type Foldr1 (arg :: a ~> (a ~> a)) (arg1 :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Foldr1 (arg :: a ~> (a ~> a)) (arg1 :: Const m a) = Apply (Apply (Foldr1_6989586621680193664Sym0 :: TyFun (a ~> (a ~> a)) (Const m a ~> a) -> Type) arg) arg1
type (a1 :: k1) <$ (a2 :: Const m b)
Instance details Defined in Data.Functor.Const.Singletons type (a1 :: k1) <$ (a2 :: Const m b) = Apply (Apply (TFHelper_6989586621680428732Sym0 :: TyFun k1 (Const m b ~> Const m k1) -> Type) a1) a2
type Apply (ShowsPrec_6989586621680428701Sym0 :: TyFun Nat (Const a b ~> (Symbol ~> Symbol)) -> Type) (a6989586621680428709 :: Nat)
Instance details Defined in Data.Functor.Const.Singletons type Apply (ShowsPrec_6989586621680428701Sym0 :: TyFun Nat (Const a b ~> (Symbol ~> Symbol)) -> Type) (a6989586621680428709 :: Nat) = ShowsPrec_6989586621680428701Sym1 a6989586621680428709 :: TyFun (Const a b) (Symbol ~> Symbol) -> Type
type Apply (Let6989586621680478597MkConstSym0 :: TyFun k1 (TyFun k2 (TyFun m6989586621680478093 (Const m6989586621680478093 ()) -> Type) -> Type) -> Type) (f6989586621680478595 :: k1)
Instance details Defined in Data.Traversable.Singletons type Apply (Let6989586621680478597MkConstSym0 :: TyFun k1 (TyFun k2 (TyFun m6989586621680478093 (Const m6989586621680478093 ()) -> Type) -> Type) -> Type) (f6989586621680478595 :: k1) = Let6989586621680478597MkConstSym1 f6989586621680478595 :: TyFun k2 (TyFun m6989586621680478093 (Const m6989586621680478093 ()) -> Type) -> Type
type Apply (TFHelper_6989586621680428732Sym0 :: TyFun a (Const m b ~> Const m a) -> Type) (a6989586621680428737 :: a)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428732Sym0 :: TyFun a (Const m b ~> Const m a) -> Type) (a6989586621680428737 :: a) = TFHelper_6989586621680428732Sym1 a6989586621680428737 :: TyFun (Const m b) (Const m a) -> Type
type Apply (Foldr_6989586621680428763Sym1 a6989586621680428769 :: TyFun b (Const m a ~> b) -> Type) (a6989586621680428770 :: b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Foldr_6989586621680428763Sym1 a6989586621680428769 :: TyFun b (Const m a ~> b) -> Type) (a6989586621680428770 :: b) = Foldr_6989586621680428763Sym2 a6989586621680428769 a6989586621680428770 :: TyFun (Const m a) b -> Type
type Apply (Let6989586621680478597MkConstSym1 f6989586621680478595 :: TyFun k2 (TyFun m6989586621680478093 (Const m6989586621680478093 ()) -> Type) -> Type) (x6989586621680478596 :: k2)
Instance details Defined in Data.Traversable.Singletons type Apply (Let6989586621680478597MkConstSym1 f6989586621680478595 :: TyFun k2 (TyFun m6989586621680478093 (Const m6989586621680478093 ()) -> Type) -> Type) (x6989586621680478596 :: k2) = Let6989586621680478597MkConstSym2 f6989586621680478595 x6989586621680478596 :: TyFun m6989586621680478093 (Const m6989586621680478093 ()) -> Type
newtype MVector s (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Const a b) = MV_Const (MVector s a)
type Apply (Pure_6989586621680428781Sym0 :: TyFun a (Const m a) -> Type) (a6989586621680428785 :: a)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Pure_6989586621680428781Sym0 :: TyFun a (Const m a) -> Type) (a6989586621680428785 :: a) = Pure_6989586621680428781 a6989586621680428785 :: Const m a
type Apply (FromInteger_6989586621680428681Sym0 :: TyFun Nat (Const a b) -> Type) (a6989586621680428685 :: Nat)
Instance details Defined in Data.Functor.Const.Singletons type Apply (FromInteger_6989586621680428681Sym0 :: TyFun Nat (Const a b) -> Type) (a6989586621680428685 :: Nat) = FromInteger_6989586621680428681 a6989586621680428685 :: Const a b
type Apply (ToEnum_6989586621680428584Sym0 :: TyFun Nat (Const a b) -> Type) (a6989586621680428588 :: Nat)
Instance details Defined in Data.Functor.Const.Singletons type Apply (ToEnum_6989586621680428584Sym0 :: TyFun Nat (Const a b) -> Type) (a6989586621680428588 :: Nat) = ToEnum_6989586621680428584 a6989586621680428588 :: Const a b
type Apply (ConstSym0 :: TyFun a (Const a b) -> Type) (a6989586621680426752 :: a)
Instance details Defined in Data.Functor.Const.Singletons type Apply (ConstSym0 :: TyFun a (Const a b) -> Type) (a6989586621680426752 :: a) = 'Const a6989586621680426752 :: Const a b
type Apply (Let6989586621680478597MkConstSym2 f6989586621680478595 x6989586621680478596 :: TyFun m (Const m ()) -> Type) (a6989586621680478600 :: m)
Instance details Defined in Data.Traversable.Singletons type Apply (Let6989586621680478597MkConstSym2 f6989586621680478595 x6989586621680478596 :: TyFun m (Const m ()) -> Type) (a6989586621680478600 :: m) = Let6989586621680478597MkConst f6989586621680478595 x6989586621680478596 a6989586621680478600
type Apply (Let6989586621680478603Scrutinee_6989586621680478187Sym1 f6989586621680478595 :: TyFun (t a) (Const b (t ())) -> Type) (x6989586621680478596 :: t a)
Instance details Defined in Data.Traversable.Singletons type Apply (Let6989586621680478603Scrutinee_6989586621680478187Sym1 f6989586621680478595 :: TyFun (t a) (Const b (t ())) -> Type) (x6989586621680478596 :: t a) = Let6989586621680478603Scrutinee_6989586621680478187 f6989586621680478595 x6989586621680478596
type Fold (arg :: Const m1 m2)
Instance details Defined in Data.Functor.Const.Singletons type Fold (arg :: Const m1 m2) = Apply (Fold_6989586621680193565Sym0 :: TyFun (Const m1 m2) m2 -> Type) arg
type Length (arg :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Length (arg :: Const m a) = Apply (Length_6989586621680193731Sym0 :: TyFun (Const m a) Nat -> Type) arg
type Maximum (arg :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Maximum (arg :: Const m a) = Apply (Maximum_6989586621680193764Sym0 :: TyFun (Const m a) a -> Type) arg
type Minimum (arg :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Minimum (arg :: Const m a) = Apply (Minimum_6989586621680193779Sym0 :: TyFun (Const m a) a -> Type) arg
type Null (arg :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Null (arg :: Const m a) = Apply (Null_6989586621680193714Sym0 :: TyFun (Const m a) Bool -> Type) arg
type Product (arg :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Product (arg :: Const m a) = Apply (Product_6989586621680193803Sym0 :: TyFun (Const m a) a -> Type) arg
type Sum (arg :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Sum (arg :: Const m a) = Apply (Sum_6989586621680193794Sym0 :: TyFun (Const m a) a -> Type) arg
type ToList (arg :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type ToList (arg :: Const m a) = Apply (ToList_6989586621680193705Sym0 :: TyFun (Const m a) [a] -> Type) arg
type Sequence (arg :: Const m1 (m2 a))
Instance details Defined in Data.Traversable.Singletons type Sequence (arg :: Const m1 (m2 a)) = Apply (Sequence_6989586621680471117Sym0 :: TyFun (Const m1 (m2 a)) (m2 (Const m1 a)) -> Type) arg
type SequenceA (arg :: Const m (f a))
Instance details Defined in Data.Traversable.Singletons type SequenceA (arg :: Const m (f a)) = Apply (SequenceA_6989586621680471093Sym0 :: TyFun (Const m (f a)) (f (Const m a)) -> Type) arg
type (arg :: Const m a) *> (arg1 :: Const m b)
Instance details Defined in Data.Functor.Const.Singletons type (arg :: Const m a) *> (arg1 :: Const m b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (Const m a) (Const m b ~> Const m b) -> Type) arg) arg1
type (arg :: Const m a) <* (arg1 :: Const m b)
Instance details Defined in Data.Functor.Const.Singletons type (arg :: Const m a) <* (arg1 :: Const m b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (Const m a) (Const m b ~> Const m a) -> Type) arg) arg1
type (a2 :: Const m (a1 ~> b)) <*> (a3 :: Const m a1)
Instance details Defined in Data.Functor.Const.Singletons type (a2 :: Const m (a1 ~> b)) <*> (a3 :: Const m a1) = Apply (Apply (TFHelper_6989586621680428802Sym0 :: TyFun (Const m (a1 ~> b)) (Const m a1 ~> Const m b) -> Type) a2) a3
type Apply (Foldr_6989586621680428763Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Const m a ~> b)) -> Type) (a6989586621680428769 :: a ~> (b ~> b))
Instance details Defined in Data.Functor.Const.Singletons type Apply (Foldr_6989586621680428763Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Const m a ~> b)) -> Type) (a6989586621680428769 :: a ~> (b ~> b)) = Foldr_6989586621680428763Sym1 a6989586621680428769 :: TyFun b (Const m a ~> b) -> Type
type Apply (Fmap_6989586621680428717Sym0 :: TyFun (a ~> b) (Const m a ~> Const m b) -> Type) (a6989586621680428722 :: a ~> b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Fmap_6989586621680428717Sym0 :: TyFun (a ~> b) (Const m a ~> Const m b) -> Type) (a6989586621680428722 :: a ~> b) = Fmap_6989586621680428717Sym1 a6989586621680428722 :: TyFun (Const m a) (Const m b) -> Type
type Apply (Let6989586621680478603Scrutinee_6989586621680478187Sym0 :: TyFun (a ~> b) (TyFun (t a) (Const b (t ())) -> Type) -> Type) (f6989586621680478595 :: a ~> b)
Instance details Defined in Data.Traversable.Singletons type Apply (Let6989586621680478603Scrutinee_6989586621680478187Sym0 :: TyFun (a ~> b) (TyFun (t a) (Const b (t ())) -> Type) -> Type) (f6989586621680478595 :: a ~> b) = Let6989586621680478603Scrutinee_6989586621680478187Sym1 f6989586621680478595 :: TyFun (t a) (Const b (t ())) -> Type
type Apply (FoldMap_6989586621680428747Sym0 :: TyFun (a ~> m1) (Const m2 a ~> m1) -> Type) (a6989586621680428752 :: a ~> m1)
Instance details Defined in Data.Functor.Const.Singletons type Apply (FoldMap_6989586621680428747Sym0 :: TyFun (a ~> m1) (Const m2 a ~> m1) -> Type) (a6989586621680428752 :: a ~> m1) = FoldMap_6989586621680428747Sym1 a6989586621680428752 :: TyFun (Const m2 a) m1 -> Type
type Apply (LiftA2_6989586621680428789Sym0 :: TyFun (a ~> (b ~> c)) (Const m a ~> (Const m b ~> Const m c)) -> Type) (a6989586621680428795 :: a ~> (b ~> c))
Instance details Defined in Data.Functor.Const.Singletons type Apply (LiftA2_6989586621680428789Sym0 :: TyFun (a ~> (b ~> c)) (Const m a ~> (Const m b ~> Const m c)) -> Type) (a6989586621680428795 :: a ~> (b ~> c)) = LiftA2_6989586621680428789Sym1 a6989586621680428795 :: TyFun (Const m a) (Const m b ~> Const m c) -> Type
type Apply (Traverse_6989586621680478758Sym0 :: TyFun (a ~> f b) (Const m a ~> f (Const m b)) -> Type) (a6989586621680478763 :: a ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478758Sym0 :: TyFun (a ~> f b) (Const m a ~> f (Const m b)) -> Type) (a6989586621680478763 :: a ~> f b) = Traverse_6989586621680478758Sym1 a6989586621680478763 :: TyFun (Const m a) (f (Const m b)) -> Type
type Rep (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const type Rep (Const a b) = D1 ('MetaData "Const" "Data.Functor.Const" "base" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Unwrapped (Const a x)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Const a x) = a
type Demote (Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Demote (Const a b) = Const (Demote a) b
type Sing
Instance details Defined in Data.Functor.Const.Singletons type Sing = SConst :: Const a b -> Type
type Mempty
Instance details Defined in Data.Functor.Const.Singletons type Mempty = Mempty_6989586621680428623Sym0 :: Const a b
type MaxBound
Instance details Defined in Data.Functor.Const.Singletons type MaxBound = MaxBound_6989586621680428544Sym0 :: Const a b
type MinBound
Instance details Defined in Data.Functor.Const.Singletons type MinBound = MinBound_6989586621680428541Sym0 :: Const a b
type Element (Const a b)
Instance details Defined in Universum.Container.Class type Element (Const a b) = ElementDefault (Const a b)
newtype Vector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Const a b) = V_Const (Vector a)
type Mconcat (arg :: [Const a b])
Instance details Defined in Data.Functor.Const.Singletons type Mconcat (arg :: [Const a b]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [Const a b] (Const a b) -> Type) arg
type Sconcat (arg :: NonEmpty (Const a b))
Instance details Defined in Data.Functor.Const.Singletons type Sconcat (arg :: NonEmpty (Const a b)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (Const a b)) (Const a b) -> Type) arg
type FromEnum (a2 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type FromEnum (a2 :: Const a1 b) = Apply (FromEnum_6989586621680428591Sym0 :: TyFun (Const a1 b) Nat -> Type) a2
type Pred (a2 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type Pred (a2 :: Const a1 b) = Apply (Pred_6989586621680428577Sym0 :: TyFun (Const a1 b) (Const a1 b) -> Type) a2
type Succ (a2 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type Succ (a2 :: Const a1 b) = Apply (Succ_6989586621680428570Sym0 :: TyFun (Const a1 b) (Const a1 b) -> Type) a2
type ToEnum a2
Instance details Defined in Data.Functor.Const.Singletons type ToEnum a2 = Apply (ToEnum_6989586621680428584Sym0 :: TyFun Nat (Const a1 b) -> Type) a2
type Abs (a2 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type Abs (a2 :: Const a1 b) = Apply (Abs_6989586621680428667Sym0 :: TyFun (Const a1 b) (Const a1 b) -> Type) a2
type FromInteger a2
Instance details Defined in Data.Functor.Const.Singletons type FromInteger a2 = Apply (FromInteger_6989586621680428681Sym0 :: TyFun Nat (Const a1 b) -> Type) a2
type Negate (a2 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type Negate (a2 :: Const a1 b) = Apply (Negate_6989586621680428660Sym0 :: TyFun (Const a1 b) (Const a1 b) -> Type) a2
type Signum (a2 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type Signum (a2 :: Const a1 b) = Apply (Signum_6989586621680428674Sym0 :: TyFun (Const a1 b) (Const a1 b) -> Type) a2
type Show_ (arg :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Show_ (arg :: Const a b) = Apply (Show__6989586621680047550Sym0 :: TyFun (Const a b) Symbol -> Type) arg
type (arg :: Const a b) /= (arg1 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type (arg :: Const a b) /= (arg1 :: Const a b) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type) arg) arg1
type (a2 :: Const a1 b) == (a3 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type (a2 :: Const a1 b) == (a3 :: Const a1 b) = Apply (Apply (TFHelper_6989586621680428549Sym0 :: TyFun (Const a1 b) (Const a1 b ~> Bool) -> Type) a2) a3
type Mappend (arg :: Const a b) (arg1 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Mappend (arg :: Const a b) (arg1 :: Const a b) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) arg) arg1
type (arg :: Const a b) < (arg1 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type (arg :: Const a b) < (arg1 :: Const a b) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type) arg) arg1
type (arg :: Const a b) <= (arg1 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type (arg :: Const a b) <= (arg1 :: Const a b) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type) arg) arg1
type (arg :: Const a b) > (arg1 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type (arg :: Const a b) > (arg1 :: Const a b) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type) arg) arg1
type (arg :: Const a b) >= (arg1 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type (arg :: Const a b) >= (arg1 :: Const a b) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type) arg) arg1
type Compare (a2 :: Const a1 b) (a3 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type Compare (a2 :: Const a1 b) (a3 :: Const a1 b) = Apply (Apply (Compare_6989586621680428560Sym0 :: TyFun (Const a1 b) (Const a1 b ~> Ordering) -> Type) a2) a3
type Max (arg :: Const a b) (arg1 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Max (arg :: Const a b) (arg1 :: Const a b) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) arg) arg1
type Min (arg :: Const a b) (arg1 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Min (arg :: Const a b) (arg1 :: Const a b) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) arg) arg1
type (a2 :: Const a1 b) <> (a3 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type (a2 :: Const a1 b) <> (a3 :: Const a1 b) = Apply (Apply (TFHelper_6989586621680428689Sym0 :: TyFun (Const a1 b) (Const a1 b ~> Const a1 b) -> Type) a2) a3
type EnumFromTo (a2 :: Const a1 b) (a3 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type EnumFromTo (a2 :: Const a1 b) (a3 :: Const a1 b) = Apply (Apply (EnumFromTo_6989586621680428599Sym0 :: TyFun (Const a1 b) (Const a1 b ~> [Const a1 b]) -> Type) a2) a3
type (a2 :: Const a1 b) * (a3 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type (a2 :: Const a1 b) * (a3 :: Const a1 b) = Apply (Apply (TFHelper_6989586621680428650Sym0 :: TyFun (Const a1 b) (Const a1 b ~> Const a1 b) -> Type) a2) a3
type (a2 :: Const a1 b) + (a3 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type (a2 :: Const a1 b) + (a3 :: Const a1 b) = Apply (Apply (TFHelper_6989586621680428628Sym0 :: TyFun (Const a1 b) (Const a1 b ~> Const a1 b) -> Type) a2) a3
type (a2 :: Const a1 b) - (a3 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type (a2 :: Const a1 b) - (a3 :: Const a1 b) = Apply (Apply (TFHelper_6989586621680428639Sym0 :: TyFun (Const a1 b) (Const a1 b ~> Const a1 b) -> Type) a2) a3
type ShowList (arg :: [Const a b]) arg1
Instance details Defined in Data.Functor.Const.Singletons type ShowList (arg :: [Const a b]) arg1 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Const a b] (Symbol ~> Symbol) -> Type) arg) arg1
type EnumFromThenTo (a2 :: Const a1 b) (a3 :: Const a1 b) (a4 :: Const a1 b)
Instance details Defined in Data.Functor.Const.Singletons type EnumFromThenTo (a2 :: Const a1 b) (a3 :: Const a1 b) (a4 :: Const a1 b) = Apply (Apply (Apply (EnumFromThenTo_6989586621680428611Sym0 :: TyFun (Const a1 b) (Const a1 b ~> (Const a1 b ~> [Const a1 b])) -> Type) a2) a3) a4
type ShowsPrec a2 (a3 :: Const a1 b) a4
Instance details Defined in Data.Functor.Const.Singletons type ShowsPrec a2 (a3 :: Const a1 b) a4 = Apply (Apply (Apply (ShowsPrec_6989586621680428701Sym0 :: TyFun Nat (Const a1 b ~> (Symbol ~> Symbol)) -> Type) a2) a3) a4
type Apply (FromEnum_6989586621680428591Sym0 :: TyFun (Const a b) Nat -> Type) (a6989586621680428595 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (FromEnum_6989586621680428591Sym0 :: TyFun (Const a b) Nat -> Type) (a6989586621680428595 :: Const a b) = FromEnum_6989586621680428591 a6989586621680428595
type Apply (GetConstSym0 :: TyFun (Const a b) a -> Type) (a6989586621680428539 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (GetConstSym0 :: TyFun (Const a b) a -> Type) (a6989586621680428539 :: Const a b) = GetConst a6989586621680428539
type Apply (FoldMap_6989586621680428747Sym1 a6989586621680428752 :: TyFun (Const m2 a) m1 -> Type) (a6989586621680428753 :: Const m2 a)
Instance details Defined in Data.Functor.Const.Singletons type Apply (FoldMap_6989586621680428747Sym1 a6989586621680428752 :: TyFun (Const m2 a) m1 -> Type) (a6989586621680428753 :: Const m2 a) = FoldMap_6989586621680428747 a6989586621680428752 a6989586621680428753
type Apply (Compare_6989586621680428560Sym1 a6989586621680428565 :: TyFun (Const a b) Ordering -> Type) (a6989586621680428566 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Compare_6989586621680428560Sym1 a6989586621680428565 :: TyFun (Const a b) Ordering -> Type) (a6989586621680428566 :: Const a b) = Compare_6989586621680428560 a6989586621680428565 a6989586621680428566
type Apply (TFHelper_6989586621680428549Sym1 a6989586621680428554 :: TyFun (Const a b) Bool -> Type) (a6989586621680428555 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428549Sym1 a6989586621680428554 :: TyFun (Const a b) Bool -> Type) (a6989586621680428555 :: Const a b) = TFHelper_6989586621680428549 a6989586621680428554 a6989586621680428555
type Apply (Foldr_6989586621680428763Sym2 a6989586621680428769 a6989586621680428770 :: TyFun (Const m a) b -> Type) (a6989586621680428771 :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Foldr_6989586621680428763Sym2 a6989586621680428769 a6989586621680428770 :: TyFun (Const m a) b -> Type) (a6989586621680428771 :: Const m a) = Foldr_6989586621680428763 a6989586621680428769 a6989586621680428770 a6989586621680428771
type Apply (EnumFromTo_6989586621680428599Sym1 a6989586621680428604 :: TyFun (Const a b) [Const a b] -> Type) (a6989586621680428605 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (EnumFromTo_6989586621680428599Sym1 a6989586621680428604 :: TyFun (Const a b) [Const a b] -> Type) (a6989586621680428605 :: Const a b) = EnumFromTo_6989586621680428599 a6989586621680428604 a6989586621680428605
type Apply (Traverse_6989586621680478758Sym1 a6989586621680478763 :: TyFun (Const m a) (f (Const m b)) -> Type) (a6989586621680478764 :: Const m a)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478758Sym1 a6989586621680478763 :: TyFun (Const m a) (f (Const m b)) -> Type) (a6989586621680478764 :: Const m a) = Traverse_6989586621680478758 a6989586621680478763 a6989586621680478764
type Apply (EnumFromThenTo_6989586621680428611Sym2 a6989586621680428617 a6989586621680428618 :: TyFun (Const a b) [Const a b] -> Type) (a6989586621680428619 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (EnumFromThenTo_6989586621680428611Sym2 a6989586621680428617 a6989586621680428618 :: TyFun (Const a b) [Const a b] -> Type) (a6989586621680428619 :: Const a b) = EnumFromThenTo_6989586621680428611 a6989586621680428617 a6989586621680428618 a6989586621680428619
type Apply (TFHelper_6989586621680428802Sym0 :: TyFun (Const m (a ~> b)) (Const m a ~> Const m b) -> Type) (a6989586621680428807 :: Const m (a ~> b))
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428802Sym0 :: TyFun (Const m (a ~> b)) (Const m a ~> Const m b) -> Type) (a6989586621680428807 :: Const m (a ~> b)) = TFHelper_6989586621680428802Sym1 a6989586621680428807
type Apply (TFHelper_6989586621680428628Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) (a6989586621680428633 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428628Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) (a6989586621680428633 :: Const a b) = TFHelper_6989586621680428628Sym1 a6989586621680428633
type Apply (TFHelper_6989586621680428639Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) (a6989586621680428644 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428639Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) (a6989586621680428644 :: Const a b) = TFHelper_6989586621680428639Sym1 a6989586621680428644
type Apply (TFHelper_6989586621680428650Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) (a6989586621680428655 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428650Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) (a6989586621680428655 :: Const a b) = TFHelper_6989586621680428650Sym1 a6989586621680428655
type Apply (TFHelper_6989586621680428689Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) (a6989586621680428694 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428689Sym0 :: TyFun (Const a b) (Const a b ~> Const a b) -> Type) (a6989586621680428694 :: Const a b) = TFHelper_6989586621680428689Sym1 a6989586621680428694
type Apply (Compare_6989586621680428560Sym0 :: TyFun (Const a b) (Const a b ~> Ordering) -> Type) (a6989586621680428565 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Compare_6989586621680428560Sym0 :: TyFun (Const a b) (Const a b ~> Ordering) -> Type) (a6989586621680428565 :: Const a b) = Compare_6989586621680428560Sym1 a6989586621680428565
type Apply (EnumFromThenTo_6989586621680428611Sym0 :: TyFun (Const a b) (Const a b ~> (Const a b ~> [Const a b])) -> Type) (a6989586621680428617 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (EnumFromThenTo_6989586621680428611Sym0 :: TyFun (Const a b) (Const a b ~> (Const a b ~> [Const a b])) -> Type) (a6989586621680428617 :: Const a b) = EnumFromThenTo_6989586621680428611Sym1 a6989586621680428617
type Apply (TFHelper_6989586621680428549Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type) (a6989586621680428554 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428549Sym0 :: TyFun (Const a b) (Const a b ~> Bool) -> Type) (a6989586621680428554 :: Const a b) = TFHelper_6989586621680428549Sym1 a6989586621680428554
type Apply (EnumFromTo_6989586621680428599Sym0 :: TyFun (Const a b) (Const a b ~> [Const a b]) -> Type) (a6989586621680428604 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (EnumFromTo_6989586621680428599Sym0 :: TyFun (Const a b) (Const a b ~> [Const a b]) -> Type) (a6989586621680428604 :: Const a b) = EnumFromTo_6989586621680428599Sym1 a6989586621680428604
type Apply (EnumFromThenTo_6989586621680428611Sym1 a6989586621680428617 :: TyFun (Const a b) (Const a b ~> [Const a b]) -> Type) (a6989586621680428618 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (EnumFromThenTo_6989586621680428611Sym1 a6989586621680428617 :: TyFun (Const a b) (Const a b ~> [Const a b]) -> Type) (a6989586621680428618 :: Const a b) = EnumFromThenTo_6989586621680428611Sym2 a6989586621680428617 a6989586621680428618
type Apply (ShowsPrec_6989586621680428701Sym1 a6989586621680428709 :: TyFun (Const a b) (Symbol ~> Symbol) -> Type) (a6989586621680428710 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (ShowsPrec_6989586621680428701Sym1 a6989586621680428709 :: TyFun (Const a b) (Symbol ~> Symbol) -> Type) (a6989586621680428710 :: Const a b) = ShowsPrec_6989586621680428701Sym2 a6989586621680428709 a6989586621680428710
type Apply (LiftA2_6989586621680428789Sym1 a6989586621680428795 :: TyFun (Const m a) (Const m b ~> Const m c) -> Type) (a6989586621680428796 :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Apply (LiftA2_6989586621680428789Sym1 a6989586621680428795 :: TyFun (Const m a) (Const m b ~> Const m c) -> Type) (a6989586621680428796 :: Const m a) = LiftA2_6989586621680428789Sym2 a6989586621680428795 a6989586621680428796
type Apply (Abs_6989586621680428667Sym0 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428671 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Abs_6989586621680428667Sym0 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428671 :: Const a b) = Abs_6989586621680428667 a6989586621680428671
type Apply (Negate_6989586621680428660Sym0 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428664 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Negate_6989586621680428660Sym0 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428664 :: Const a b) = Negate_6989586621680428660 a6989586621680428664
type Apply (Pred_6989586621680428577Sym0 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428581 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Pred_6989586621680428577Sym0 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428581 :: Const a b) = Pred_6989586621680428577 a6989586621680428581
type Apply (Signum_6989586621680428674Sym0 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428678 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Signum_6989586621680428674Sym0 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428678 :: Const a b) = Signum_6989586621680428674 a6989586621680428678
type Apply (Succ_6989586621680428570Sym0 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428574 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Succ_6989586621680428570Sym0 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428574 :: Const a b) = Succ_6989586621680428570 a6989586621680428574
type Apply (Fmap_6989586621680428717Sym1 a6989586621680428722 :: TyFun (Const m a) (Const m b) -> Type) (a6989586621680428723 :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Apply (Fmap_6989586621680428717Sym1 a6989586621680428722 :: TyFun (Const m a) (Const m b) -> Type) (a6989586621680428723 :: Const m a) = Fmap_6989586621680428717 a6989586621680428722 a6989586621680428723
type Apply (TFHelper_6989586621680428802Sym1 a6989586621680428807 :: TyFun (Const m a) (Const m b) -> Type) (a6989586621680428808 :: Const m a)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428802Sym1 a6989586621680428807 :: TyFun (Const m a) (Const m b) -> Type) (a6989586621680428808 :: Const m a) = TFHelper_6989586621680428802 a6989586621680428807 a6989586621680428808
type Apply (TFHelper_6989586621680428628Sym1 a6989586621680428633 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428634 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428628Sym1 a6989586621680428633 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428634 :: Const a b) = TFHelper_6989586621680428628 a6989586621680428633 a6989586621680428634
type Apply (TFHelper_6989586621680428639Sym1 a6989586621680428644 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428645 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428639Sym1 a6989586621680428644 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428645 :: Const a b) = TFHelper_6989586621680428639 a6989586621680428644 a6989586621680428645
type Apply (TFHelper_6989586621680428650Sym1 a6989586621680428655 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428656 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428650Sym1 a6989586621680428655 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428656 :: Const a b) = TFHelper_6989586621680428650 a6989586621680428655 a6989586621680428656
type Apply (TFHelper_6989586621680428689Sym1 a6989586621680428694 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428695 :: Const a b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428689Sym1 a6989586621680428694 :: TyFun (Const a b) (Const a b) -> Type) (a6989586621680428695 :: Const a b) = TFHelper_6989586621680428689 a6989586621680428694 a6989586621680428695
type Apply (TFHelper_6989586621680428732Sym1 a6989586621680428737 :: TyFun (Const m b) (Const m a) -> Type) (a6989586621680428738 :: Const m b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (TFHelper_6989586621680428732Sym1 a6989586621680428737 :: TyFun (Const m b) (Const m a) -> Type) (a6989586621680428738 :: Const m b) = TFHelper_6989586621680428732 a6989586621680428737 a6989586621680428738
type Apply (LiftA2_6989586621680428789Sym2 a6989586621680428795 a6989586621680428796 :: TyFun (Const m b) (Const m c) -> Type) (a6989586621680428797 :: Const m b)
Instance details Defined in Data.Functor.Const.Singletons type Apply (LiftA2_6989586621680428789Sym2 a6989586621680428795 a6989586621680428796 :: TyFun (Const m b) (Const m c) -> Type) (a6989586621680428797 :: Const m b) = LiftA2_6989586621680428789 a6989586621680428795 a6989586621680428796 a6989586621680428797

class (Typeable e, Show e) => Exception e where #

Any type that you wish to throw or catch as an exception must be an instance of the Exception class. The simplest case is a new exception type directly below the root:

data MyException = ThisException | ThatException
    deriving Show

instance Exception MyException

The default method definitions in the Exception class do what we need in this case. You can now throw and catch ThisException and ThatException as exceptions:

*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException

In more complicated examples, you may wish to define a whole hierarchy of exceptions:

---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler

data SomeCompilerException = forall e . Exception e => SomeCompilerException e

instance Show SomeCompilerException where
    show (SomeCompilerException e) = show e

instance Exception SomeCompilerException

compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException

compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
    SomeCompilerException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler

data SomeFrontendException = forall e . Exception e => SomeFrontendException e

instance Show SomeFrontendException where
    show (SomeFrontendException e) = show e

instance Exception SomeFrontendException where
    toException = compilerExceptionToException
    fromException = compilerExceptionFromException

frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException

frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
    SomeFrontendException a <- fromException x
    cast a

---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception

data MismatchedParentheses = MismatchedParentheses
    deriving Show

instance Exception MismatchedParentheses where
    toException   = frontendExceptionToException
    fromException = frontendExceptionFromException

We can now catch a MismatchedParentheses exception as MismatchedParentheses, SomeFrontendException or SomeCompilerException, but not other types, e.g. IOException:

*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException #

fromException :: SomeException -> Maybe e #

displayException :: e -> String #

Render this exception value in a human-friendly manner.

Default implementation: show.

Since: base-4.8.0.0

Instances

Instances details

Exception Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String #
Exception ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods toException :: ErrorCall -> SomeException # fromException :: SomeException -> Maybe ErrorCall # displayException :: ErrorCall -> String #
Exception ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String #
Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Exception AllocationLimitExceeded	Since: base-4.8.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String #
Exception ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String #
Exception AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String #
Exception AsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String #
Exception BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String #
Exception BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String #
Exception CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String #
Exception Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String #
Exception ExitCode	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String #
Exception FixIOException	Since: base-4.11.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: FixIOException -> SomeException # fromException :: SomeException -> Maybe FixIOException # displayException :: FixIOException -> String #
Exception IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String #
Exception SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String #
Exception ASCII7_Invalid
Instance details Defined in Basement.String.Encoding.ASCII7 Methods toException :: ASCII7_Invalid -> SomeException # fromException :: SomeException -> Maybe ASCII7_Invalid # displayException :: ASCII7_Invalid -> String #
Exception ISO_8859_1_Invalid
Instance details Defined in Basement.String.Encoding.ISO_8859_1 Methods toException :: ISO_8859_1_Invalid -> SomeException # fromException :: SomeException -> Maybe ISO_8859_1_Invalid # displayException :: ISO_8859_1_Invalid -> String #
Exception UTF16_Invalid
Instance details Defined in Basement.String.Encoding.UTF16 Methods toException :: UTF16_Invalid -> SomeException # fromException :: SomeException -> Maybe UTF16_Invalid # displayException :: UTF16_Invalid -> String #
Exception UTF32_Invalid
Instance details Defined in Basement.String.Encoding.UTF32 Methods toException :: UTF32_Invalid -> SomeException # fromException :: SomeException -> Maybe UTF32_Invalid # displayException :: UTF32_Invalid -> String #
Exception BimapException
Instance details Defined in Data.Bimap Methods toException :: BimapException -> SomeException # fromException :: SomeException -> Maybe BimapException # displayException :: BimapException -> String #
Exception CryptoError
Instance details Defined in Crypto.Error.Types Methods toException :: CryptoError -> SomeException # fromException :: SomeException -> Maybe CryptoError # displayException :: CryptoError -> String #
Exception BlstError
Instance details Defined in Crypto.BLST.Internal.Bindings Methods toException :: BlstError -> SomeException # fromException :: SomeException -> Maybe BlstError # displayException :: BlstError -> String #
Exception ViewInterfaceMatchError
Instance details Defined in Lorentz.ViewBase Methods toException :: ViewInterfaceMatchError -> SomeException # fromException :: SomeException -> Maybe ViewInterfaceMatchError # displayException :: ViewInterfaceMatchError -> String #
Exception InvalidPosException
Instance details Defined in Text.Megaparsec.Pos Methods toException :: InvalidPosException -> SomeException # fromException :: SomeException -> Maybe InvalidPosException # displayException :: InvalidPosException -> String #
Exception ParserException
Instance details Defined in Morley.Michelson.Parser.Error Methods toException :: ParserException -> SomeException # fromException :: SomeException -> Maybe ParserException # displayException :: ParserException -> String #
Exception GStateParseError
Instance details Defined in Morley.Michelson.Runtime.GState Methods toException :: GStateParseError -> SomeException # fromException :: SomeException -> Maybe GStateParseError # displayException :: GStateParseError -> String #
Exception TcError
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods toException :: TcError -> SomeException # fromException :: SomeException -> Maybe TcError # displayException :: TcError -> String #
Exception TcTypeError
Instance details Defined in Morley.Michelson.TypeCheck.Error Methods toException :: TcTypeError -> SomeException # fromException :: SomeException -> Maybe TcTypeError # displayException :: TcTypeError -> String #
Exception ParseChainIdError
Instance details Defined in Morley.Tezos.Core Methods toException :: ParseChainIdError -> SomeException # fromException :: SomeException -> Maybe ParseChainIdError # displayException :: ParseChainIdError -> String #
Exception UnpackError
Instance details Defined in Morley.Util.Binary Methods toException :: UnpackError -> SomeException # fromException :: SomeException -> Maybe UnpackError # displayException :: UnpackError -> String #
Exception AsyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods toException :: AsyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe AsyncExceptionWrapper # displayException :: AsyncExceptionWrapper -> String #
Exception StringException
Instance details Defined in Control.Exception.Safe Methods toException :: StringException -> SomeException # fromException :: SomeException -> Maybe StringException # displayException :: StringException -> String #
Exception SyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods toException :: SyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe SyncExceptionWrapper # displayException :: SyncExceptionWrapper -> String #
Exception ResourceError
Instance details Defined in Test.Tasty.Core Methods toException :: ResourceError -> SomeException # fromException :: SomeException -> Maybe ResourceError # displayException :: ResourceError -> String #
Exception UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods toException :: UnicodeException -> SomeException # fromException :: SomeException -> Maybe UnicodeException # displayException :: UnicodeException -> String #
Exception Bug
Instance details Defined in Universum.Exception Methods toException :: Bug -> SomeException # fromException :: SomeException -> Maybe Bug # displayException :: Bug -> String #
(Show s, Show (Token s), Show e, ShowErrorComponent e, VisualStream s, Typeable s, Typeable e) => Exception (ParseError s e)
Instance details Defined in Text.Megaparsec.Error Methods toException :: ParseError s e -> SomeException # fromException :: SomeException -> Maybe (ParseError s e) # displayException :: ParseError s e -> String #
(Show s, Show (Token s), Show e, ShowErrorComponent e, VisualStream s, TraversableStream s, Typeable s, Typeable e) => Exception (ParseErrorBundle s e)
Instance details Defined in Text.Megaparsec.Error Methods toException :: ParseErrorBundle s e -> SomeException # fromException :: SomeException -> Maybe (ParseErrorBundle s e) # displayException :: ParseErrorBundle s e -> String #

prettyCallStack :: CallStack -> String #

Pretty print a CallStack.

Since: base-4.9.0.0

type FilePath = String #

File and directory names are values of type String, whose precise meaning is operating system dependent. Files can be opened, yielding a handle which can then be used to operate on the contents of that file.

callStack :: HasCallStack => CallStack #

Return the current CallStack.

Does *not* include the call-site of callStack.

Since: base-4.9.0.0

withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a #

Perform some computation without adding new entries to the CallStack.

Since: base-4.9.0.0

newtype Identity a #

Identity functor and monad. (a non-strict monad)

Since: base-4.8.0.0

Constructors

Identity
Fields runIdentity :: a

Instances

Instances details

Representable Identity
Instance details Defined in Data.Functor.Rep Associated Types type Rep Identity # Methods tabulate :: (Rep Identity -> a) -> Identity a # index :: Identity a -> Rep Identity -> a #
MonadFix Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods mfix :: (a -> Identity a) -> Identity a #
Foldable Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] # null :: Identity a -> Bool # length :: Identity a -> Int # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # sum :: Num a => Identity a -> a # product :: Num a => Identity a -> a #
Traversable Identity	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) # sequence :: Monad m => Identity (m a) -> m (Identity a) #
Applicative Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods pure :: a -> Identity a # (<>) :: Identity (a -> b) -> Identity a -> Identity b # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c # (>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Functor Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
Monad Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a #
NFData1 Identity	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Identity a -> () #
Hashable1 Identity
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Identity a -> Int #
KnownNamedFunctor Identity
Instance details Defined in Morley.Util.Named Methods namedL :: forall (name :: Symbol) a. Label name -> Iso' (NamedF Identity a name) (ApplyNamedFunctor Identity a) #
InjValue Identity
Instance details Defined in Named.Internal Methods injValue :: a -> Identity a #
PTraversable Identity
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable Identity
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: Identity a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: Identity (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: Identity a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: Identity (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) #
Cosieve ReifiedGetter Identity
Instance details Defined in Control.Lens.Reified Methods cosieve :: ReifiedGetter a b -> Identity a -> b #
Sieve ReifiedGetter Identity
Instance details Defined in Control.Lens.Reified Methods sieve :: ReifiedGetter a b -> a -> Identity b #
() :=> (Functor Identity)
Instance details Defined in Data.Constraint Methods ins :: () :- Functor Identity #
() :=> (Monad Identity)
Instance details Defined in Data.Constraint Methods ins :: () :- Monad Identity #
Unbox a => Vector Vector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Identity a) -> m (Vector (Identity a)) # basicUnsafeThaw :: PrimMonad m => Vector (Identity a) -> m (Mutable Vector (PrimState m) (Identity a)) # basicLength :: Vector (Identity a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Identity a) -> Vector (Identity a) # basicUnsafeIndexM :: Monad m => Vector (Identity a) -> Int -> m (Identity a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Identity a) -> Vector (Identity a) -> m () # elemseq :: Vector (Identity a) -> Identity a -> b -> b #
Unbox a => MVector MVector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Identity a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Identity a) -> MVector s (Identity a) # basicOverlaps :: MVector s (Identity a) -> MVector s (Identity a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Identity a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Identity a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Identity a -> m (MVector (PrimState m) (Identity a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Identity a) -> Int -> m (Identity a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Identity a) -> Int -> Identity a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Identity a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Identity a) -> Identity a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Identity a) -> MVector (PrimState m) (Identity a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Identity a) -> MVector (PrimState m) (Identity a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Identity a) -> Int -> m (MVector (PrimState m) (Identity a)) #
Bits a => Bits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (.&.) :: Identity a -> Identity a -> Identity a # (.\|.) :: Identity a -> Identity a -> Identity a # xor :: Identity a -> Identity a -> Identity a # complement :: Identity a -> Identity a # shift :: Identity a -> Int -> Identity a # rotate :: Identity a -> Int -> Identity a # zeroBits :: Identity a # bit :: Int -> Identity a # setBit :: Identity a -> Int -> Identity a # clearBit :: Identity a -> Int -> Identity a # complementBit :: Identity a -> Int -> Identity a # testBit :: Identity a -> Int -> Bool # bitSizeMaybe :: Identity a -> Maybe Int # bitSize :: Identity a -> Int # isSigned :: Identity a -> Bool # shiftL :: Identity a -> Int -> Identity a # unsafeShiftL :: Identity a -> Int -> Identity a # shiftR :: Identity a -> Int -> Identity a # unsafeShiftR :: Identity a -> Int -> Identity a # rotateL :: Identity a -> Int -> Identity a # rotateR :: Identity a -> Int -> Identity a # popCount :: Identity a -> Int #
FiniteBits a => FiniteBits (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods finiteBitSize :: Identity a -> Int # countLeadingZeros :: Identity a -> Int # countTrailingZeros :: Identity a -> Int #
IsString a => IsString (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Identity a #
Storable a => Storable (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods sizeOf :: Identity a -> Int # alignment :: Identity a -> Int # peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) # pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Identity a) # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () # peek :: Ptr (Identity a) -> IO (Identity a) # poke :: Ptr (Identity a) -> Identity a -> IO () #
Monoid a => Monoid (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Semigroup a => Semigroup (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Bounded a => Bounded (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a # maxBound :: Identity a #
Enum a => Enum (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] #
Floating a => Floating (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods pi :: Identity a # exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a # expm1 :: Identity a -> Identity a # log1pexp :: Identity a -> Identity a # log1mexp :: Identity a -> Identity a #
RealFloat a => RealFloat (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer # floatDigits :: Identity a -> Int # floatRange :: Identity a -> (Int, Int) # decodeFloat :: Identity a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Identity a # exponent :: Identity a -> Int # significand :: Identity a -> Identity a # scaleFloat :: Int -> Identity a -> Identity a # isNaN :: Identity a -> Bool # isInfinite :: Identity a -> Bool # isDenormalized :: Identity a -> Bool # isNegativeZero :: Identity a -> Bool # isIEEE :: Identity a -> Bool # atan2 :: Identity a -> Identity a -> Identity a #
Generic (Identity a)
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Ix a => Ix (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods range :: (Identity a, Identity a) -> [Identity a] # index :: (Identity a, Identity a) -> Identity a -> Int # unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int # inRange :: (Identity a, Identity a) -> Identity a -> Bool # rangeSize :: (Identity a, Identity a) -> Int # unsafeRangeSize :: (Identity a, Identity a) -> Int #
Num a => Num (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (+) :: Identity a -> Identity a -> Identity a # (-) :: Identity a -> Identity a -> Identity a # (*) :: Identity a -> Identity a -> Identity a # negate :: Identity a -> Identity a # abs :: Identity a -> Identity a # signum :: Identity a -> Identity a # fromInteger :: Integer -> Identity a #
Read a => Read (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods readsPrec :: Int -> ReadS (Identity a) # readList :: ReadS [Identity a] # readPrec :: ReadPrec (Identity a) # readListPrec :: ReadPrec [Identity a] #
Fractional a => Fractional (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods (/) :: Identity a -> Identity a -> Identity a # recip :: Identity a -> Identity a # fromRational :: Rational -> Identity a #
Integral a => Integral (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # toInteger :: Identity a -> Integer #
Real a => Real (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational #
RealFrac a => RealFrac (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods properFraction :: Integral b => Identity a -> (b, Identity a) # truncate :: Integral b => Identity a -> b # round :: Integral b => Identity a -> b # ceiling :: Integral b => Identity a -> b # floor :: Integral b => Identity a -> b #
Show a => Show (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
NFData a => NFData (Identity a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Identity a -> () #
Eq a => Eq (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Ord a => Ord (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods compare :: Identity a -> Identity a -> Ordering # (<) :: Identity a -> Identity a -> Bool # (<=) :: Identity a -> Identity a -> Bool # (>) :: Identity a -> Identity a -> Bool # (>=) :: Identity a -> Identity a -> Bool # max :: Identity a -> Identity a -> Identity a # min :: Identity a -> Identity a -> Identity a #
Hashable a => Hashable (Identity a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Identity a -> Int # hash :: Identity a -> Int #
Ixed (Identity a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Identity a) -> Traversal' (Identity a) (IxValue (Identity a)) #
Wrapped (Identity a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Identity a) # Methods _Wrapped' :: Iso' (Identity a) (Unwrapped (Identity a)) #
HasRPCRepr a => HasRPCRepr (Identity a)
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (Identity a) #
IsoValue a => IsoValue (Identity a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Identity a) :: T # Methods toVal :: Identity a -> Value (ToT (Identity a)) # fromVal :: Value (ToT (Identity a)) -> Identity a #
Ring a => Ring (Identity a)
Instance details Defined in Data.Semiring Methods negate :: Identity a -> Identity a #
Semiring a => Semiring (Identity a)
Instance details Defined in Data.Semiring Methods plus :: Identity a -> Identity a -> Identity a # zero :: Identity a # times :: Identity a -> Identity a -> Identity a # one :: Identity a # fromNatural :: Natural -> Identity a #
PEq (Identity a)
Instance details Defined in Data.Eq.Singletons Associated Types type arg == arg1 :: Bool # type arg /= arg1 :: Bool #
SEq a => SEq (Identity a)
Instance details Defined in Data.Eq.Singletons Methods (%==) :: forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (==@#@$) t1) t2) # (%/=) :: forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (/=@#@$) t1) t2) #
POrd (Identity a)
Instance details Defined in Data.Ord.Singletons Associated Types type Compare arg arg1 :: Ordering # type arg < arg1 :: Bool # type arg <= arg1 :: Bool # type arg > arg1 :: Bool # type arg >= arg1 :: Bool # type Max arg arg1 :: a # type Min arg arg1 :: a #
SOrd a => SOrd (Identity a)
Instance details Defined in Data.Ord.Singletons Methods sCompare :: forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2) # (%<) :: forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) # (%<=) :: forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2) # (%>) :: forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%>=) :: forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2) # sMax :: forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2) # sMin :: forall (t1 :: Identity a) (t2 :: Identity a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2) #
PBounded (Identity a)
Instance details Defined in Data.Singletons.Base.Enum Associated Types type MinBound :: a # type MaxBound :: a #
SBounded a => SBounded (Identity a)
Instance details Defined in Data.Singletons.Base.Enum Methods sMinBound :: Sing MinBoundSym0 # sMaxBound :: Sing MaxBoundSym0 #
(TypeError (DisallowInstance "Identity") :: Constraint) => Container (Identity a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Identity a) # Methods toList :: Identity a -> [Element (Identity a)] # null :: Identity a -> Bool # foldr :: (Element (Identity a) -> b -> b) -> b -> Identity a -> b # foldl :: (b -> Element (Identity a) -> b) -> b -> Identity a -> b # foldl' :: (b -> Element (Identity a) -> b) -> b -> Identity a -> b # length :: Identity a -> Int # elem :: Element (Identity a) -> Identity a -> Bool # foldMap :: Monoid m => (Element (Identity a) -> m) -> Identity a -> m # fold :: Identity a -> Element (Identity a) # foldr' :: (Element (Identity a) -> b -> b) -> b -> Identity a -> b # notElem :: Element (Identity a) -> Identity a -> Bool # all :: (Element (Identity a) -> Bool) -> Identity a -> Bool # any :: (Element (Identity a) -> Bool) -> Identity a -> Bool # and :: Identity a -> Bool # or :: Identity a -> Bool # find :: (Element (Identity a) -> Bool) -> Identity a -> Maybe (Element (Identity a)) # safeHead :: Identity a -> Maybe (Element (Identity a)) # safeMaximum :: Identity a -> Maybe (Element (Identity a)) # safeMinimum :: Identity a -> Maybe (Element (Identity a)) # safeFoldr1 :: (Element (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Maybe (Element (Identity a)) # safeFoldl1 :: (Element (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Maybe (Element (Identity a)) #
Unbox a => Unbox (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Identity
Instance details Defined in Data.Functor.Identity Associated Types type Rep1 Identity :: k -> Type # Methods from1 :: forall (a :: k). Identity a -> Rep1 Identity a # to1 :: forall (a :: k). Rep1 Identity a -> Identity a #
t ~ Identity b => Rewrapped (Identity a) t
Instance details Defined in Control.Lens.Wrapped
SDecide a => TestCoercion (SIdentity :: Identity a -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods testCoercion :: forall (a0 :: k) (b :: k). SIdentity a0 -> SIdentity b -> Maybe (Coercion a0 b) #
SDecide a => TestEquality (SIdentity :: Identity a -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods testEquality :: forall (a0 :: k) (b :: k). SIdentity a0 -> SIdentity b -> Maybe (a0 :~: b) #
(Bits a) :=> (Bits (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Bits a :- Bits (Identity a) #
(Monoid a) :=> (Monoid (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Monoid a :- Monoid (Identity a) #
(Semigroup a) :=> (Semigroup (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Semigroup a :- Semigroup (Identity a) #
(Bounded a) :=> (Bounded (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Bounded a :- Bounded (Identity a) #
(Enum a) :=> (Enum (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Enum a :- Enum (Identity a) #
(Floating a) :=> (Floating (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Floating a :- Floating (Identity a) #
(RealFloat a) :=> (RealFloat (Identity a))
Instance details Defined in Data.Constraint Methods ins :: RealFloat a :- RealFloat (Identity a) #
(Num a) :=> (Num (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Num a :- Num (Identity a) #
(Read a) :=> (Read (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Read a :- Read (Identity a) #
(Fractional a) :=> (Fractional (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Fractional a :- Fractional (Identity a) #
(Integral a) :=> (Integral (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Integral a :- Integral (Identity a) #
(Real a) :=> (Real (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Real a :- Real (Identity a) #
(RealFrac a) :=> (RealFrac (Identity a))
Instance details Defined in Data.Constraint Methods ins :: RealFrac a :- RealFrac (Identity a) #
(Show a) :=> (Show (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Show a :- Show (Identity a) #
(Eq a) :=> (Eq (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Eq a :- Eq (Identity a) #
(Ord a) :=> (Ord (Identity a))
Instance details Defined in Data.Constraint Methods ins :: Ord a :- Ord (Identity a) #
Field1 (Identity a) (Identity b) a b
Instance details Defined in Control.Lens.Tuple Methods _1 :: Lens (Identity a) (Identity b) a b #
SingI (RunIdentitySym0 :: TyFun (Identity a) a -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing RunIdentitySym0 #
SingI (IdentitySym0 :: TyFun a (Identity a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods sing :: Sing IdentitySym0 #
SuppressUnusedWarnings (Abs_6989586621680390860Sym0 :: TyFun (Identity a) (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Negate_6989586621680390853Sym0 :: TyFun (Identity a) (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pred_6989586621680390662Sym0 :: TyFun (Identity a) (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Signum_6989586621680390867Sym0 :: TyFun (Identity a) (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Succ_6989586621680390655Sym0 :: TyFun (Identity a) (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680390821Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680390832Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680390843Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680390915Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181827Sym0 :: TyFun (Identity a) (Identity a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680390696Sym0 :: TyFun (Identity a) (Identity a ~> (Identity a ~> [Identity a])) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679131006Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromTo_6989586621680390684Sym0 :: TyFun (Identity a) (Identity a ~> [Identity a]) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680392273Sym0 :: TyFun (Identity a) Bool -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromEnum_6989586621680390676Sym0 :: TyFun (Identity a) Nat -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Length_6989586621680392253Sym0 :: TyFun (Identity a) Nat -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ToList_6989586621680392293Sym0 :: TyFun (Identity a) [a] -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Maximum_6989586621680392259Sym0 :: TyFun (Identity a) a -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Minimum_6989586621680392266Sym0 :: TyFun (Identity a) a -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Product_6989586621680392279Sym0 :: TyFun (Identity a) a -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Sum_6989586621680392286Sym0 :: TyFun (Identity a) a -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (RunIdentitySym0 :: TyFun (Identity a) a -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680392198Sym0 :: TyFun (a ~> (a ~> a)) (Identity a ~> a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680392244Sym0 :: TyFun (a ~> (a ~> a)) (Identity a ~> a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromInteger_6989586621680390874Sym0 :: TyFun Nat (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ToEnum_6989586621680390669Sym0 :: TyFun Nat (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680390927Sym0 :: TyFun Nat (Identity a ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621680392300Sym0 :: TyFun a (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (IdentitySym0 :: TyFun a (Identity a) -> Type)
Instance details Defined in Data.Singletons.Base.Instances Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680392157Sym0 :: TyFun a (Identity a ~> Bool) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680392310Sym0 :: TyFun (Identity (a ~> b)) (Identity a ~> Identity b) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680390821Sym1 a6989586621680390826 :: TyFun (Identity a) (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680390832Sym1 a6989586621680390837 :: TyFun (Identity a) (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680390843Sym1 a6989586621680390848 :: TyFun (Identity a) (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680390915Sym1 a6989586621680390920 :: TyFun (Identity a) (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181827Sym1 a6989586621679181832 :: TyFun (Identity a) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680390696Sym1 a6989586621680390702 :: TyFun (Identity a) (Identity a ~> [Identity a]) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680392336Sym0 :: TyFun (Identity a) ((a ~> Identity b) ~> Identity b) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680390927Sym1 a6989586621680390935 :: TyFun (Identity a) (Symbol ~> Symbol) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679131006Sym1 a6989586621679131011 :: TyFun (Identity a) Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680392157Sym1 a6989586621680392162 :: TyFun (Identity a) Bool -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromTo_6989586621680390684Sym1 a6989586621680390689 :: TyFun (Identity a) [Identity a] -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680392198Sym1 a6989586621680392203 :: TyFun (Identity a) a -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680392244Sym1 a6989586621680392249 :: TyFun (Identity a) a -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680392224Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Identity a ~> b)) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680392209Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Identity a ~> b)) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621680390943Sym0 :: TyFun (a ~> b) (Identity a ~> Identity b) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680392146Sym0 :: TyFun (a ~> m) (Identity a ~> m) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680392184Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Identity a ~> b)) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680392169Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Identity a ~> b)) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680390954Sym0 :: TyFun a (Identity b ~> Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621680390943Sym1 a6989586621680390948 :: TyFun (Identity a) (Identity b) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680392310Sym1 a6989586621680392315 :: TyFun (Identity a) (Identity b) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680390696Sym2 a6989586621680390702 a6989586621680390703 :: TyFun (Identity a) [Identity a] -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680392146Sym1 a6989586621680392151 :: TyFun (Identity a) m -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680390954Sym1 a6989586621680390959 :: TyFun (Identity b) (Identity a) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680392336Sym1 a6989586621680392341 :: TyFun (a ~> Identity b) (Identity b) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621680392322Sym0 :: TyFun (a ~> (b ~> c)) (Identity a ~> (Identity b ~> Identity c)) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680478616Scrutinee_6989586621680478184Sym0 :: TyFun (a ~> b) (TyFun (t a) (Identity (t b)) -> Type) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478824Sym0 :: TyFun (a ~> f b) (Identity a ~> f (Identity b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680392184Sym1 a6989586621680392190 :: TyFun b (Identity a ~> b) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680392169Sym1 a6989586621680392175 :: TyFun b (Identity a ~> b) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680392224Sym1 a6989586621680392236 :: TyFun b (Identity a ~> b) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680392209Sym1 a6989586621680392215 :: TyFun b (Identity a ~> b) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621680392322Sym1 a6989586621680392328 :: TyFun (Identity a) (Identity b ~> Identity c) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680392184Sym2 a6989586621680392190 a6989586621680392191 :: TyFun (Identity a) b -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680392169Sym2 a6989586621680392175 a6989586621680392176 :: TyFun (Identity a) b -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680392224Sym2 a6989586621680392236 a6989586621680392237 :: TyFun (Identity a) b -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680392209Sym2 a6989586621680392215 a6989586621680392216 :: TyFun (Identity a) b -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478824Sym1 a6989586621680478829 :: TyFun (Identity a) (f (Identity b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680478616Scrutinee_6989586621680478184Sym1 f6989586621680478614 :: TyFun (t a) (Identity (t b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LiftA2_6989586621680392322Sym2 a6989586621680392328 a6989586621680392329 :: TyFun (Identity b) (Identity c) -> Type)
Instance details Defined in Data.Functor.Identity.Singletons Methods suppressUnusedWarnings :: () #
(HasAnnotation a, KnownSymbol name) => HasAnnotation (NamedF Identity a name)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (NamedF Identity a name)) # annOptions :: Maybe AnnOptions #
Unwrappable (NamedF Identity a name)
Instance details Defined in Lorentz.Wrappable Associated Types type Unwrappabled (NamedF Identity a name) #
Wrappable (NamedF Identity a name)
Instance details Defined in Lorentz.Wrappable
HasRPCRepr a => HasRPCRepr (NamedF Identity a name)
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (NamedF Identity a name) #
IsoValue a => IsoValue (NamedF Identity a name)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (NamedF Identity a name) :: T # Methods toVal :: NamedF Identity a name -> Value (ToT (NamedF Identity a name)) # fromVal :: Value (ToT (NamedF Identity a name)) -> NamedF Identity a name #
type Rep Identity
Instance details Defined in Data.Functor.Rep type Rep Identity = ()
type Pure (a :: k1)
Instance details Defined in Data.Functor.Identity.Singletons type Pure (a :: k1) = Apply (Pure_6989586621680392300Sym0 :: TyFun k1 (Identity k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Data.Functor.Identity.Singletons type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (Identity a) -> Type) arg
type Fold (arg :: Identity m)
Instance details Defined in Data.Functor.Identity.Singletons type Fold (arg :: Identity m) = Apply (Fold_6989586621680193565Sym0 :: TyFun (Identity m) m -> Type) arg
type Length (a2 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Length (a2 :: Identity a1) = Apply (Length_6989586621680392253Sym0 :: TyFun (Identity a1) Nat -> Type) a2
type Maximum (a :: Identity k2)
Instance details Defined in Data.Functor.Identity.Singletons type Maximum (a :: Identity k2) = Apply (Maximum_6989586621680392259Sym0 :: TyFun (Identity k2) k2 -> Type) a
type Minimum (a :: Identity k2)
Instance details Defined in Data.Functor.Identity.Singletons type Minimum (a :: Identity k2) = Apply (Minimum_6989586621680392266Sym0 :: TyFun (Identity k2) k2 -> Type) a
type Null (a2 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Null (a2 :: Identity a1) = Apply (Null_6989586621680392273Sym0 :: TyFun (Identity a1) Bool -> Type) a2
type Product (a :: Identity k2)
Instance details Defined in Data.Functor.Identity.Singletons type Product (a :: Identity k2) = Apply (Product_6989586621680392279Sym0 :: TyFun (Identity k2) k2 -> Type) a
type Sum (a :: Identity k2)
Instance details Defined in Data.Functor.Identity.Singletons type Sum (a :: Identity k2) = Apply (Sum_6989586621680392286Sym0 :: TyFun (Identity k2) k2 -> Type) a
type ToList (a2 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type ToList (a2 :: Identity a1) = Apply (ToList_6989586621680392293Sym0 :: TyFun (Identity a1) [a1] -> Type) a2
type Elem (a1 :: k1) (a2 :: Identity k1)
Instance details Defined in Data.Functor.Identity.Singletons type Elem (a1 :: k1) (a2 :: Identity k1) = Apply (Apply (Elem_6989586621680392157Sym0 :: TyFun k1 (Identity k1 ~> Bool) -> Type) a1) a2
type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Identity k2)
Instance details Defined in Data.Functor.Identity.Singletons type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Identity k2) = Apply (Apply (Foldl1_6989586621680392198Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (Identity k2 ~> k2) -> Type) a1) a2
type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Identity k2)
Instance details Defined in Data.Functor.Identity.Singletons type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Identity k2) = Apply (Apply (Foldr1_6989586621680392244Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (Identity k2 ~> k2) -> Type) a1) a2
type Sequence (arg :: Identity (m a))
Instance details Defined in Data.Traversable.Singletons type Sequence (arg :: Identity (m a)) = Apply (Sequence_6989586621680471117Sym0 :: TyFun (Identity (m a)) (m (Identity a)) -> Type) arg
type SequenceA (arg :: Identity (f a))
Instance details Defined in Data.Traversable.Singletons type SequenceA (arg :: Identity (f a)) = Apply (SequenceA_6989586621680471093Sym0 :: TyFun (Identity (f a)) (f (Identity a)) -> Type) arg
type (arg :: Identity a) *> (arg1 :: Identity b)
Instance details Defined in Data.Functor.Identity.Singletons type (arg :: Identity a) *> (arg1 :: Identity b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (Identity a) (Identity b ~> Identity b) -> Type) arg) arg1
type (a1 :: k1) <$ (a2 :: Identity b)
Instance details Defined in Data.Functor.Identity.Singletons type (a1 :: k1) <$ (a2 :: Identity b) = Apply (Apply (TFHelper_6989586621680390954Sym0 :: TyFun k1 (Identity b ~> Identity k1) -> Type) a1) a2
type (arg :: Identity a) <* (arg1 :: Identity b)
Instance details Defined in Data.Functor.Identity.Singletons type (arg :: Identity a) <* (arg1 :: Identity b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (Identity a) (Identity b ~> Identity a) -> Type) arg) arg1
type (a2 :: Identity (a1 ~> b)) <*> (a3 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type (a2 :: Identity (a1 ~> b)) <*> (a3 :: Identity a1) = Apply (Apply (TFHelper_6989586621680392310Sym0 :: TyFun (Identity (a1 ~> b)) (Identity a1 ~> Identity b) -> Type) a2) a3
type (arg :: Identity a) >> (arg1 :: Identity b)
Instance details Defined in Data.Functor.Identity.Singletons type (arg :: Identity a) >> (arg1 :: Identity b) = Apply (Apply (TFHelper_6989586621679287148Sym0 :: TyFun (Identity a) (Identity b ~> Identity b) -> Type) arg) arg1
type (a2 :: Identity a1) >>= (a3 :: a1 ~> Identity b)
Instance details Defined in Data.Functor.Identity.Singletons type (a2 :: Identity a1) >>= (a3 :: a1 ~> Identity b) = Apply (Apply (TFHelper_6989586621680392336Sym0 :: TyFun (Identity a1) ((a1 ~> Identity b) ~> Identity b) -> Type) a2) a3
type Fmap (a2 :: a1 ~> b) (a3 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Fmap (a2 :: a1 ~> b) (a3 :: Identity a1) = Apply (Apply (Fmap_6989586621680390943Sym0 :: TyFun (a1 ~> b) (Identity a1 ~> Identity b) -> Type) a2) a3
type FoldMap (a2 :: a1 ~> k2) (a3 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type FoldMap (a2 :: a1 ~> k2) (a3 :: Identity a1) = Apply (Apply (FoldMap_6989586621680392146Sym0 :: TyFun (a1 ~> k2) (Identity a1 ~> k2) -> Type) a2) a3
type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Identity a1) = Apply (Apply (Apply (Foldl_6989586621680392169Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (Identity a1 ~> k2)) -> Type) a2) a3) a4
type Foldl' (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Foldl' (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Identity a1) = Apply (Apply (Apply (Foldl'_6989586621680392184Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (Identity a1 ~> k2)) -> Type) a2) a3) a4
type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Identity a1) = Apply (Apply (Apply (Foldr_6989586621680392209Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Identity a1 ~> k2)) -> Type) a2) a3) a4
type Foldr' (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Foldr' (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Identity a1) = Apply (Apply (Apply (Foldr'_6989586621680392224Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Identity a1 ~> k2)) -> Type) a2) a3) a4
type MapM (arg1 :: a ~> m b) (arg2 :: Identity a)
Instance details Defined in Data.Traversable.Singletons type MapM (arg1 :: a ~> m b) (arg2 :: Identity a) = Apply (Apply (MapM_6989586621680471103Sym0 :: TyFun (a ~> m b) (Identity a ~> m (Identity b)) -> Type) arg1) arg2
type Traverse (a2 :: a1 ~> f b) (a3 :: Identity a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a2 :: a1 ~> f b) (a3 :: Identity a1) = Apply (Apply (Traverse_6989586621680478824Sym0 :: TyFun (a1 ~> f b) (Identity a1 ~> f (Identity b)) -> Type) a2) a3
type LiftA2 (a2 :: a1 ~> (b ~> c)) (a3 :: Identity a1) (a4 :: Identity b)
Instance details Defined in Data.Functor.Identity.Singletons type LiftA2 (a2 :: a1 ~> (b ~> c)) (a3 :: Identity a1) (a4 :: Identity b) = Apply (Apply (Apply (LiftA2_6989586621680392322Sym0 :: TyFun (a1 ~> (b ~> c)) (Identity a1 ~> (Identity b ~> Identity c)) -> Type) a2) a3) a4
newtype MVector s (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Identity a) = MV_Identity (MVector s a)
type Apply (FromInteger_6989586621680390874Sym0 :: TyFun Nat (Identity a) -> Type) (a6989586621680390878 :: Nat)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (FromInteger_6989586621680390874Sym0 :: TyFun Nat (Identity a) -> Type) (a6989586621680390878 :: Nat) = FromInteger_6989586621680390874 a6989586621680390878 :: Identity a
type Apply (ToEnum_6989586621680390669Sym0 :: TyFun Nat (Identity a) -> Type) (a6989586621680390673 :: Nat)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (ToEnum_6989586621680390669Sym0 :: TyFun Nat (Identity a) -> Type) (a6989586621680390673 :: Nat) = ToEnum_6989586621680390669 a6989586621680390673 :: Identity a
type Apply (Pure_6989586621680392300Sym0 :: TyFun a (Identity a) -> Type) (a6989586621680392306 :: a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Pure_6989586621680392300Sym0 :: TyFun a (Identity a) -> Type) (a6989586621680392306 :: a) = Pure_6989586621680392300 a6989586621680392306
type Apply (IdentitySym0 :: TyFun a (Identity a) -> Type) (a6989586621679029145 :: a)
Instance details Defined in Data.Singletons.Base.Instances type Apply (IdentitySym0 :: TyFun a (Identity a) -> Type) (a6989586621679029145 :: a) = 'Identity a6989586621679029145
type Apply (ShowsPrec_6989586621680390927Sym0 :: TyFun Nat (Identity a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680390935 :: Nat)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (ShowsPrec_6989586621680390927Sym0 :: TyFun Nat (Identity a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680390935 :: Nat) = ShowsPrec_6989586621680390927Sym1 a6989586621680390935 :: TyFun (Identity a) (Symbol ~> Symbol) -> Type
type Apply (Elem_6989586621680392157Sym0 :: TyFun a (Identity a ~> Bool) -> Type) (a6989586621680392162 :: a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Elem_6989586621680392157Sym0 :: TyFun a (Identity a ~> Bool) -> Type) (a6989586621680392162 :: a) = Elem_6989586621680392157Sym1 a6989586621680392162
type Apply (TFHelper_6989586621680390954Sym0 :: TyFun a (Identity b ~> Identity a) -> Type) (a6989586621680390959 :: a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680390954Sym0 :: TyFun a (Identity b ~> Identity a) -> Type) (a6989586621680390959 :: a) = TFHelper_6989586621680390954Sym1 a6989586621680390959 :: TyFun (Identity b) (Identity a) -> Type
type Apply (Foldl'_6989586621680392184Sym1 a6989586621680392190 :: TyFun b (Identity a ~> b) -> Type) (a6989586621680392191 :: b)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldl'_6989586621680392184Sym1 a6989586621680392190 :: TyFun b (Identity a ~> b) -> Type) (a6989586621680392191 :: b) = Foldl'_6989586621680392184Sym2 a6989586621680392190 a6989586621680392191
type Apply (Foldl_6989586621680392169Sym1 a6989586621680392175 :: TyFun b (Identity a ~> b) -> Type) (a6989586621680392176 :: b)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldl_6989586621680392169Sym1 a6989586621680392175 :: TyFun b (Identity a ~> b) -> Type) (a6989586621680392176 :: b) = Foldl_6989586621680392169Sym2 a6989586621680392175 a6989586621680392176
type Apply (Foldr'_6989586621680392224Sym1 a6989586621680392236 :: TyFun b (Identity a ~> b) -> Type) (a6989586621680392237 :: b)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldr'_6989586621680392224Sym1 a6989586621680392236 :: TyFun b (Identity a ~> b) -> Type) (a6989586621680392237 :: b) = Foldr'_6989586621680392224Sym2 a6989586621680392236 a6989586621680392237
type Apply (Foldr_6989586621680392209Sym1 a6989586621680392215 :: TyFun b (Identity a ~> b) -> Type) (a6989586621680392216 :: b)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldr_6989586621680392209Sym1 a6989586621680392215 :: TyFun b (Identity a ~> b) -> Type) (a6989586621680392216 :: b) = Foldr_6989586621680392209Sym2 a6989586621680392215 a6989586621680392216
type Rep (Identity a)	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep (Identity a) = D1 ('MetaData "Identity" "Data.Functor.Identity" "base" 'True) (C1 ('MetaCons "Identity" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Index (Identity a)
Instance details Defined in Control.Lens.At type Index (Identity a) = ()
type IxValue (Identity a)
Instance details Defined in Control.Lens.At type IxValue (Identity a) = a
type Unwrapped (Identity a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Identity a) = a
type AsRPC (Identity a)
Instance details Defined in Morley.AsRPC type AsRPC (Identity a) = Identity (AsRPC a)
type ToT (Identity a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Identity a) = ToT a
type Demote (Identity a)
Instance details Defined in Data.Singletons.Base.Instances type Demote (Identity a) = Identity (Demote a)
type Sing
Instance details Defined in Data.Singletons.Base.Instances type Sing = SIdentity :: Identity a -> Type
type Mempty
Instance details Defined in Data.Functor.Identity.Singletons type Mempty = Mempty_6989586621680390738Sym0 :: Identity a
type MaxBound
Instance details Defined in Data.Singletons.Base.Enum type MaxBound = MaxBound_6989586621679509881Sym0 :: Identity a
type MinBound
Instance details Defined in Data.Singletons.Base.Enum type MinBound = MinBound_6989586621679509878Sym0 :: Identity a
type Element (Identity a)
Instance details Defined in Universum.Container.Class type Element (Identity a) = ElementDefault (Identity a)
newtype Vector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Identity a) = V_Identity (Vector a)
type Rep1 Identity	Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity type Rep1 Identity = D1 ('MetaData "Identity" "Data.Functor.Identity" "base" 'True) (C1 ('MetaCons "Identity" 'PrefixI 'True) (S1 ('MetaSel ('Just "runIdentity") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type Mconcat (arg :: [Identity a])
Instance details Defined in Data.Functor.Identity.Singletons type Mconcat (arg :: [Identity a]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [Identity a] (Identity a) -> Type) arg
type Sconcat (arg :: NonEmpty (Identity a))
Instance details Defined in Data.Functor.Identity.Singletons type Sconcat (arg :: NonEmpty (Identity a)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (Identity a)) (Identity a) -> Type) arg
type FromEnum (a2 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type FromEnum (a2 :: Identity a1) = Apply (FromEnum_6989586621680390676Sym0 :: TyFun (Identity a1) Nat -> Type) a2
type Pred (a2 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Pred (a2 :: Identity a1) = Apply (Pred_6989586621680390662Sym0 :: TyFun (Identity a1) (Identity a1) -> Type) a2
type Succ (a2 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Succ (a2 :: Identity a1) = Apply (Succ_6989586621680390655Sym0 :: TyFun (Identity a1) (Identity a1) -> Type) a2
type ToEnum a2
Instance details Defined in Data.Functor.Identity.Singletons type ToEnum a2 = Apply (ToEnum_6989586621680390669Sym0 :: TyFun Nat (Identity a1) -> Type) a2
type Abs (a2 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Abs (a2 :: Identity a1) = Apply (Abs_6989586621680390860Sym0 :: TyFun (Identity a1) (Identity a1) -> Type) a2
type FromInteger a2
Instance details Defined in Data.Functor.Identity.Singletons type FromInteger a2 = Apply (FromInteger_6989586621680390874Sym0 :: TyFun Nat (Identity a1) -> Type) a2
type Negate (a2 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Negate (a2 :: Identity a1) = Apply (Negate_6989586621680390853Sym0 :: TyFun (Identity a1) (Identity a1) -> Type) a2
type Signum (a2 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type Signum (a2 :: Identity a1) = Apply (Signum_6989586621680390867Sym0 :: TyFun (Identity a1) (Identity a1) -> Type) a2
type Show_ (arg :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Show_ (arg :: Identity a) = Apply (Show__6989586621680047550Sym0 :: TyFun (Identity a) Symbol -> Type) arg
type (arg1 :: Identity a) /= (arg2 :: Identity a)
Instance details Defined in Data.Eq.Singletons type (arg1 :: Identity a) /= (arg2 :: Identity a) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type) arg1) arg2
type (a2 :: Identity a1) == (a3 :: Identity a1)
Instance details Defined in Data.Eq.Singletons type (a2 :: Identity a1) == (a3 :: Identity a1) = Apply (Apply (TFHelper_6989586621679131006Sym0 :: TyFun (Identity a1) (Identity a1 ~> Bool) -> Type) a2) a3
type Mappend (arg :: Identity a) (arg1 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Mappend (arg :: Identity a) (arg1 :: Identity a) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) arg) arg1
type (arg1 :: Identity a) < (arg2 :: Identity a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Identity a) < (arg2 :: Identity a) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type) arg1) arg2
type (arg1 :: Identity a) <= (arg2 :: Identity a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Identity a) <= (arg2 :: Identity a) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type) arg1) arg2
type (arg1 :: Identity a) > (arg2 :: Identity a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Identity a) > (arg2 :: Identity a) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type) arg1) arg2
type (arg1 :: Identity a) >= (arg2 :: Identity a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Identity a) >= (arg2 :: Identity a) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type) arg1) arg2
type Compare (a2 :: Identity a1) (a3 :: Identity a1)
Instance details Defined in Data.Ord.Singletons type Compare (a2 :: Identity a1) (a3 :: Identity a1) = Apply (Apply (Compare_6989586621679181827Sym0 :: TyFun (Identity a1) (Identity a1 ~> Ordering) -> Type) a2) a3
type Max (arg1 :: Identity a) (arg2 :: Identity a)
Instance details Defined in Data.Ord.Singletons type Max (arg1 :: Identity a) (arg2 :: Identity a) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) arg1) arg2
type Min (arg1 :: Identity a) (arg2 :: Identity a)
Instance details Defined in Data.Ord.Singletons type Min (arg1 :: Identity a) (arg2 :: Identity a) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) arg1) arg2
type (a2 :: Identity a1) <> (a3 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type (a2 :: Identity a1) <> (a3 :: Identity a1) = Apply (Apply (TFHelper_6989586621680390915Sym0 :: TyFun (Identity a1) (Identity a1 ~> Identity a1) -> Type) a2) a3
type EnumFromTo (a2 :: Identity a1) (a3 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type EnumFromTo (a2 :: Identity a1) (a3 :: Identity a1) = Apply (Apply (EnumFromTo_6989586621680390684Sym0 :: TyFun (Identity a1) (Identity a1 ~> [Identity a1]) -> Type) a2) a3
type (a2 :: Identity a1) * (a3 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type (a2 :: Identity a1) * (a3 :: Identity a1) = Apply (Apply (TFHelper_6989586621680390843Sym0 :: TyFun (Identity a1) (Identity a1 ~> Identity a1) -> Type) a2) a3
type (a2 :: Identity a1) + (a3 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type (a2 :: Identity a1) + (a3 :: Identity a1) = Apply (Apply (TFHelper_6989586621680390821Sym0 :: TyFun (Identity a1) (Identity a1 ~> Identity a1) -> Type) a2) a3
type (a2 :: Identity a1) - (a3 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type (a2 :: Identity a1) - (a3 :: Identity a1) = Apply (Apply (TFHelper_6989586621680390832Sym0 :: TyFun (Identity a1) (Identity a1 ~> Identity a1) -> Type) a2) a3
type ShowList (arg :: [Identity a]) arg1
Instance details Defined in Data.Functor.Identity.Singletons type ShowList (arg :: [Identity a]) arg1 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Identity a] (Symbol ~> Symbol) -> Type) arg) arg1
type EnumFromThenTo (a2 :: Identity a1) (a3 :: Identity a1) (a4 :: Identity a1)
Instance details Defined in Data.Functor.Identity.Singletons type EnumFromThenTo (a2 :: Identity a1) (a3 :: Identity a1) (a4 :: Identity a1) = Apply (Apply (Apply (EnumFromThenTo_6989586621680390696Sym0 :: TyFun (Identity a1) (Identity a1 ~> (Identity a1 ~> [Identity a1])) -> Type) a2) a3) a4
type ShowsPrec a2 (a3 :: Identity a1) a4
Instance details Defined in Data.Functor.Identity.Singletons type ShowsPrec a2 (a3 :: Identity a1) a4 = Apply (Apply (Apply (ShowsPrec_6989586621680390927Sym0 :: TyFun Nat (Identity a1 ~> (Symbol ~> Symbol)) -> Type) a2) a3) a4
type Apply (Null_6989586621680392273Sym0 :: TyFun (Identity a) Bool -> Type) (a6989586621680392277 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Null_6989586621680392273Sym0 :: TyFun (Identity a) Bool -> Type) (a6989586621680392277 :: Identity a) = Null_6989586621680392273 a6989586621680392277
type Apply (FromEnum_6989586621680390676Sym0 :: TyFun (Identity a) Nat -> Type) (a6989586621680390680 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (FromEnum_6989586621680390676Sym0 :: TyFun (Identity a) Nat -> Type) (a6989586621680390680 :: Identity a) = FromEnum_6989586621680390676 a6989586621680390680
type Apply (Length_6989586621680392253Sym0 :: TyFun (Identity a) Nat -> Type) (a6989586621680392257 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Length_6989586621680392253Sym0 :: TyFun (Identity a) Nat -> Type) (a6989586621680392257 :: Identity a) = Length_6989586621680392253 a6989586621680392257
type Apply (Maximum_6989586621680392259Sym0 :: TyFun (Identity a) a -> Type) (a6989586621680392263 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Maximum_6989586621680392259Sym0 :: TyFun (Identity a) a -> Type) (a6989586621680392263 :: Identity a) = Maximum_6989586621680392259 a6989586621680392263
type Apply (Minimum_6989586621680392266Sym0 :: TyFun (Identity a) a -> Type) (a6989586621680392270 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Minimum_6989586621680392266Sym0 :: TyFun (Identity a) a -> Type) (a6989586621680392270 :: Identity a) = Minimum_6989586621680392266 a6989586621680392270
type Apply (Product_6989586621680392279Sym0 :: TyFun (Identity a) a -> Type) (a6989586621680392283 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Product_6989586621680392279Sym0 :: TyFun (Identity a) a -> Type) (a6989586621680392283 :: Identity a) = Product_6989586621680392279 a6989586621680392283
type Apply (Sum_6989586621680392286Sym0 :: TyFun (Identity a) a -> Type) (a6989586621680392290 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Sum_6989586621680392286Sym0 :: TyFun (Identity a) a -> Type) (a6989586621680392290 :: Identity a) = Sum_6989586621680392286 a6989586621680392290
type Apply (RunIdentitySym0 :: TyFun (Identity a) a -> Type) (a6989586621679029148 :: Identity a)
Instance details Defined in Data.Singletons.Base.Instances type Apply (RunIdentitySym0 :: TyFun (Identity a) a -> Type) (a6989586621679029148 :: Identity a) = RunIdentity a6989586621679029148
type Apply (Compare_6989586621679181827Sym1 a6989586621679181832 :: TyFun (Identity a) Ordering -> Type) (a6989586621679181833 :: Identity a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181827Sym1 a6989586621679181832 :: TyFun (Identity a) Ordering -> Type) (a6989586621679181833 :: Identity a) = Compare_6989586621679181827 a6989586621679181832 a6989586621679181833
type Apply (TFHelper_6989586621679131006Sym1 a6989586621679131011 :: TyFun (Identity a) Bool -> Type) (a6989586621679131012 :: Identity a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679131006Sym1 a6989586621679131011 :: TyFun (Identity a) Bool -> Type) (a6989586621679131012 :: Identity a) = TFHelper_6989586621679131006 a6989586621679131011 a6989586621679131012
type Apply (Elem_6989586621680392157Sym1 a6989586621680392162 :: TyFun (Identity a) Bool -> Type) (a6989586621680392163 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Elem_6989586621680392157Sym1 a6989586621680392162 :: TyFun (Identity a) Bool -> Type) (a6989586621680392163 :: Identity a) = Elem_6989586621680392157 a6989586621680392162 a6989586621680392163
type Apply (Foldl1_6989586621680392198Sym1 a6989586621680392203 :: TyFun (Identity a) a -> Type) (a6989586621680392204 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldl1_6989586621680392198Sym1 a6989586621680392203 :: TyFun (Identity a) a -> Type) (a6989586621680392204 :: Identity a) = Foldl1_6989586621680392198 a6989586621680392203 a6989586621680392204
type Apply (Foldr1_6989586621680392244Sym1 a6989586621680392249 :: TyFun (Identity a) a -> Type) (a6989586621680392250 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldr1_6989586621680392244Sym1 a6989586621680392249 :: TyFun (Identity a) a -> Type) (a6989586621680392250 :: Identity a) = Foldr1_6989586621680392244 a6989586621680392249 a6989586621680392250
type Apply (FoldMap_6989586621680392146Sym1 a6989586621680392151 :: TyFun (Identity a) m -> Type) (a6989586621680392152 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (FoldMap_6989586621680392146Sym1 a6989586621680392151 :: TyFun (Identity a) m -> Type) (a6989586621680392152 :: Identity a) = FoldMap_6989586621680392146 a6989586621680392151 a6989586621680392152
type Apply (Foldl'_6989586621680392184Sym2 a6989586621680392190 a6989586621680392191 :: TyFun (Identity a) b -> Type) (a6989586621680392192 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldl'_6989586621680392184Sym2 a6989586621680392190 a6989586621680392191 :: TyFun (Identity a) b -> Type) (a6989586621680392192 :: Identity a) = Foldl'_6989586621680392184 a6989586621680392190 a6989586621680392191 a6989586621680392192
type Apply (Foldl_6989586621680392169Sym2 a6989586621680392175 a6989586621680392176 :: TyFun (Identity a) b -> Type) (a6989586621680392177 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldl_6989586621680392169Sym2 a6989586621680392175 a6989586621680392176 :: TyFun (Identity a) b -> Type) (a6989586621680392177 :: Identity a) = Foldl_6989586621680392169 a6989586621680392175 a6989586621680392176 a6989586621680392177
type Apply (Foldr'_6989586621680392224Sym2 a6989586621680392236 a6989586621680392237 :: TyFun (Identity a) b -> Type) (a6989586621680392238 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldr'_6989586621680392224Sym2 a6989586621680392236 a6989586621680392237 :: TyFun (Identity a) b -> Type) (a6989586621680392238 :: Identity a) = Foldr'_6989586621680392224 a6989586621680392236 a6989586621680392237 a6989586621680392238
type Apply (Foldr_6989586621680392209Sym2 a6989586621680392215 a6989586621680392216 :: TyFun (Identity a) b -> Type) (a6989586621680392217 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldr_6989586621680392209Sym2 a6989586621680392215 a6989586621680392216 :: TyFun (Identity a) b -> Type) (a6989586621680392217 :: Identity a) = Foldr_6989586621680392209 a6989586621680392215 a6989586621680392216 a6989586621680392217
type Apply (Abs_6989586621680390860Sym0 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390864 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Abs_6989586621680390860Sym0 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390864 :: Identity a) = Abs_6989586621680390860 a6989586621680390864
type Apply (Negate_6989586621680390853Sym0 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390857 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Negate_6989586621680390853Sym0 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390857 :: Identity a) = Negate_6989586621680390853 a6989586621680390857
type Apply (Pred_6989586621680390662Sym0 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390666 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Pred_6989586621680390662Sym0 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390666 :: Identity a) = Pred_6989586621680390662 a6989586621680390666
type Apply (Signum_6989586621680390867Sym0 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390871 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Signum_6989586621680390867Sym0 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390871 :: Identity a) = Signum_6989586621680390867 a6989586621680390871
type Apply (Succ_6989586621680390655Sym0 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390659 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Succ_6989586621680390655Sym0 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390659 :: Identity a) = Succ_6989586621680390655 a6989586621680390659
type Apply (ToList_6989586621680392293Sym0 :: TyFun (Identity a) [a] -> Type) (a6989586621680392297 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (ToList_6989586621680392293Sym0 :: TyFun (Identity a) [a] -> Type) (a6989586621680392297 :: Identity a) = ToList_6989586621680392293 a6989586621680392297
type Apply (TFHelper_6989586621680390821Sym1 a6989586621680390826 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390827 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680390821Sym1 a6989586621680390826 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390827 :: Identity a) = TFHelper_6989586621680390821 a6989586621680390826 a6989586621680390827
type Apply (TFHelper_6989586621680390832Sym1 a6989586621680390837 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390838 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680390832Sym1 a6989586621680390837 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390838 :: Identity a) = TFHelper_6989586621680390832 a6989586621680390837 a6989586621680390838
type Apply (TFHelper_6989586621680390843Sym1 a6989586621680390848 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390849 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680390843Sym1 a6989586621680390848 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390849 :: Identity a) = TFHelper_6989586621680390843 a6989586621680390848 a6989586621680390849
type Apply (TFHelper_6989586621680390915Sym1 a6989586621680390920 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390921 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680390915Sym1 a6989586621680390920 :: TyFun (Identity a) (Identity a) -> Type) (a6989586621680390921 :: Identity a) = TFHelper_6989586621680390915 a6989586621680390920 a6989586621680390921
type Apply (EnumFromTo_6989586621680390684Sym1 a6989586621680390689 :: TyFun (Identity a) [Identity a] -> Type) (a6989586621680390690 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (EnumFromTo_6989586621680390684Sym1 a6989586621680390689 :: TyFun (Identity a) [Identity a] -> Type) (a6989586621680390690 :: Identity a) = EnumFromTo_6989586621680390684 a6989586621680390689 a6989586621680390690
type Apply (Fmap_6989586621680390943Sym1 a6989586621680390948 :: TyFun (Identity a) (Identity b) -> Type) (a6989586621680390949 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Fmap_6989586621680390943Sym1 a6989586621680390948 :: TyFun (Identity a) (Identity b) -> Type) (a6989586621680390949 :: Identity a) = Fmap_6989586621680390943 a6989586621680390948 a6989586621680390949
type Apply (TFHelper_6989586621680392310Sym1 a6989586621680392315 :: TyFun (Identity a) (Identity b) -> Type) (a6989586621680392316 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680392310Sym1 a6989586621680392315 :: TyFun (Identity a) (Identity b) -> Type) (a6989586621680392316 :: Identity a) = TFHelper_6989586621680392310 a6989586621680392315 a6989586621680392316
type Apply (EnumFromThenTo_6989586621680390696Sym2 a6989586621680390702 a6989586621680390703 :: TyFun (Identity a) [Identity a] -> Type) (a6989586621680390704 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (EnumFromThenTo_6989586621680390696Sym2 a6989586621680390702 a6989586621680390703 :: TyFun (Identity a) [Identity a] -> Type) (a6989586621680390704 :: Identity a) = EnumFromThenTo_6989586621680390696 a6989586621680390702 a6989586621680390703 a6989586621680390704
type Apply (TFHelper_6989586621680390954Sym1 a6989586621680390959 :: TyFun (Identity b) (Identity a) -> Type) (a6989586621680390960 :: Identity b)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680390954Sym1 a6989586621680390959 :: TyFun (Identity b) (Identity a) -> Type) (a6989586621680390960 :: Identity b) = TFHelper_6989586621680390954 a6989586621680390959 a6989586621680390960
type Apply (Traverse_6989586621680478824Sym1 a6989586621680478829 :: TyFun (Identity a) (f (Identity b)) -> Type) (a6989586621680478830 :: Identity a)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478824Sym1 a6989586621680478829 :: TyFun (Identity a) (f (Identity b)) -> Type) (a6989586621680478830 :: Identity a) = Traverse_6989586621680478824 a6989586621680478829 a6989586621680478830
type Apply (Let6989586621680478616Scrutinee_6989586621680478184Sym1 f6989586621680478614 :: TyFun (t a) (Identity (t b)) -> Type) (x6989586621680478615 :: t a)
Instance details Defined in Data.Traversable.Singletons type Apply (Let6989586621680478616Scrutinee_6989586621680478184Sym1 f6989586621680478614 :: TyFun (t a) (Identity (t b)) -> Type) (x6989586621680478615 :: t a) = Let6989586621680478616Scrutinee_6989586621680478184 f6989586621680478614 x6989586621680478615
type Apply (LiftA2_6989586621680392322Sym2 a6989586621680392328 a6989586621680392329 :: TyFun (Identity b) (Identity c) -> Type) (a6989586621680392330 :: Identity b)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (LiftA2_6989586621680392322Sym2 a6989586621680392328 a6989586621680392329 :: TyFun (Identity b) (Identity c) -> Type) (a6989586621680392330 :: Identity b) = LiftA2_6989586621680392322 a6989586621680392328 a6989586621680392329 a6989586621680392330
type Apply (TFHelper_6989586621680390821Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) (a6989586621680390826 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680390821Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) (a6989586621680390826 :: Identity a) = TFHelper_6989586621680390821Sym1 a6989586621680390826
type Apply (TFHelper_6989586621680390832Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) (a6989586621680390837 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680390832Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) (a6989586621680390837 :: Identity a) = TFHelper_6989586621680390832Sym1 a6989586621680390837
type Apply (TFHelper_6989586621680390843Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) (a6989586621680390848 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680390843Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) (a6989586621680390848 :: Identity a) = TFHelper_6989586621680390843Sym1 a6989586621680390848
type Apply (TFHelper_6989586621680390915Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) (a6989586621680390920 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680390915Sym0 :: TyFun (Identity a) (Identity a ~> Identity a) -> Type) (a6989586621680390920 :: Identity a) = TFHelper_6989586621680390915Sym1 a6989586621680390920
type Apply (Compare_6989586621679181827Sym0 :: TyFun (Identity a) (Identity a ~> Ordering) -> Type) (a6989586621679181832 :: Identity a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181827Sym0 :: TyFun (Identity a) (Identity a ~> Ordering) -> Type) (a6989586621679181832 :: Identity a) = Compare_6989586621679181827Sym1 a6989586621679181832
type Apply (EnumFromThenTo_6989586621680390696Sym0 :: TyFun (Identity a) (Identity a ~> (Identity a ~> [Identity a])) -> Type) (a6989586621680390702 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (EnumFromThenTo_6989586621680390696Sym0 :: TyFun (Identity a) (Identity a ~> (Identity a ~> [Identity a])) -> Type) (a6989586621680390702 :: Identity a) = EnumFromThenTo_6989586621680390696Sym1 a6989586621680390702
type Apply (TFHelper_6989586621679131006Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type) (a6989586621679131011 :: Identity a)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679131006Sym0 :: TyFun (Identity a) (Identity a ~> Bool) -> Type) (a6989586621679131011 :: Identity a) = TFHelper_6989586621679131006Sym1 a6989586621679131011
type Apply (EnumFromTo_6989586621680390684Sym0 :: TyFun (Identity a) (Identity a ~> [Identity a]) -> Type) (a6989586621680390689 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (EnumFromTo_6989586621680390684Sym0 :: TyFun (Identity a) (Identity a ~> [Identity a]) -> Type) (a6989586621680390689 :: Identity a) = EnumFromTo_6989586621680390684Sym1 a6989586621680390689
type Apply (TFHelper_6989586621680392310Sym0 :: TyFun (Identity (a ~> b)) (Identity a ~> Identity b) -> Type) (a6989586621680392315 :: Identity (a ~> b))
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680392310Sym0 :: TyFun (Identity (a ~> b)) (Identity a ~> Identity b) -> Type) (a6989586621680392315 :: Identity (a ~> b)) = TFHelper_6989586621680392310Sym1 a6989586621680392315
type Apply (EnumFromThenTo_6989586621680390696Sym1 a6989586621680390702 :: TyFun (Identity a) (Identity a ~> [Identity a]) -> Type) (a6989586621680390703 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (EnumFromThenTo_6989586621680390696Sym1 a6989586621680390702 :: TyFun (Identity a) (Identity a ~> [Identity a]) -> Type) (a6989586621680390703 :: Identity a) = EnumFromThenTo_6989586621680390696Sym2 a6989586621680390702 a6989586621680390703
type Apply (TFHelper_6989586621680392336Sym0 :: TyFun (Identity a) ((a ~> Identity b) ~> Identity b) -> Type) (a6989586621680392341 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680392336Sym0 :: TyFun (Identity a) ((a ~> Identity b) ~> Identity b) -> Type) (a6989586621680392341 :: Identity a) = TFHelper_6989586621680392336Sym1 a6989586621680392341 :: TyFun (a ~> Identity b) (Identity b) -> Type
type Apply (ShowsPrec_6989586621680390927Sym1 a6989586621680390935 :: TyFun (Identity a) (Symbol ~> Symbol) -> Type) (a6989586621680390936 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (ShowsPrec_6989586621680390927Sym1 a6989586621680390935 :: TyFun (Identity a) (Symbol ~> Symbol) -> Type) (a6989586621680390936 :: Identity a) = ShowsPrec_6989586621680390927Sym2 a6989586621680390935 a6989586621680390936
type Apply (LiftA2_6989586621680392322Sym1 a6989586621680392328 :: TyFun (Identity a) (Identity b ~> Identity c) -> Type) (a6989586621680392329 :: Identity a)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (LiftA2_6989586621680392322Sym1 a6989586621680392328 :: TyFun (Identity a) (Identity b ~> Identity c) -> Type) (a6989586621680392329 :: Identity a) = LiftA2_6989586621680392322Sym2 a6989586621680392328 a6989586621680392329
type Apply (TFHelper_6989586621680392336Sym1 a6989586621680392341 :: TyFun (a ~> Identity b) (Identity b) -> Type) (a6989586621680392342 :: a ~> Identity b)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (TFHelper_6989586621680392336Sym1 a6989586621680392341 :: TyFun (a ~> Identity b) (Identity b) -> Type) (a6989586621680392342 :: a ~> Identity b) = TFHelper_6989586621680392336 a6989586621680392341 a6989586621680392342
type Apply (Foldl1_6989586621680392198Sym0 :: TyFun (a ~> (a ~> a)) (Identity a ~> a) -> Type) (a6989586621680392203 :: a ~> (a ~> a))
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldl1_6989586621680392198Sym0 :: TyFun (a ~> (a ~> a)) (Identity a ~> a) -> Type) (a6989586621680392203 :: a ~> (a ~> a)) = Foldl1_6989586621680392198Sym1 a6989586621680392203
type Apply (Foldr1_6989586621680392244Sym0 :: TyFun (a ~> (a ~> a)) (Identity a ~> a) -> Type) (a6989586621680392249 :: a ~> (a ~> a))
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldr1_6989586621680392244Sym0 :: TyFun (a ~> (a ~> a)) (Identity a ~> a) -> Type) (a6989586621680392249 :: a ~> (a ~> a)) = Foldr1_6989586621680392244Sym1 a6989586621680392249
type Apply (Foldr'_6989586621680392224Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Identity a ~> b)) -> Type) (a6989586621680392236 :: a ~> (b ~> b))
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldr'_6989586621680392224Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Identity a ~> b)) -> Type) (a6989586621680392236 :: a ~> (b ~> b)) = Foldr'_6989586621680392224Sym1 a6989586621680392236
type Apply (Foldr_6989586621680392209Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Identity a ~> b)) -> Type) (a6989586621680392215 :: a ~> (b ~> b))
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldr_6989586621680392209Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Identity a ~> b)) -> Type) (a6989586621680392215 :: a ~> (b ~> b)) = Foldr_6989586621680392209Sym1 a6989586621680392215
type Apply (Fmap_6989586621680390943Sym0 :: TyFun (a ~> b) (Identity a ~> Identity b) -> Type) (a6989586621680390948 :: a ~> b)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Fmap_6989586621680390943Sym0 :: TyFun (a ~> b) (Identity a ~> Identity b) -> Type) (a6989586621680390948 :: a ~> b) = Fmap_6989586621680390943Sym1 a6989586621680390948
type Apply (FoldMap_6989586621680392146Sym0 :: TyFun (a ~> m) (Identity a ~> m) -> Type) (a6989586621680392151 :: a ~> m)
Instance details Defined in Data.Functor.Identity.Singletons type Apply (FoldMap_6989586621680392146Sym0 :: TyFun (a ~> m) (Identity a ~> m) -> Type) (a6989586621680392151 :: a ~> m) = FoldMap_6989586621680392146Sym1 a6989586621680392151
type Apply (Foldl'_6989586621680392184Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Identity a ~> b)) -> Type) (a6989586621680392190 :: b ~> (a ~> b))
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldl'_6989586621680392184Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Identity a ~> b)) -> Type) (a6989586621680392190 :: b ~> (a ~> b)) = Foldl'_6989586621680392184Sym1 a6989586621680392190
type Apply (Foldl_6989586621680392169Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Identity a ~> b)) -> Type) (a6989586621680392175 :: b ~> (a ~> b))
Instance details Defined in Data.Functor.Identity.Singletons type Apply (Foldl_6989586621680392169Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Identity a ~> b)) -> Type) (a6989586621680392175 :: b ~> (a ~> b)) = Foldl_6989586621680392169Sym1 a6989586621680392175
type Apply (LiftA2_6989586621680392322Sym0 :: TyFun (a ~> (b ~> c)) (Identity a ~> (Identity b ~> Identity c)) -> Type) (a6989586621680392328 :: a ~> (b ~> c))
Instance details Defined in Data.Functor.Identity.Singletons type Apply (LiftA2_6989586621680392322Sym0 :: TyFun (a ~> (b ~> c)) (Identity a ~> (Identity b ~> Identity c)) -> Type) (a6989586621680392328 :: a ~> (b ~> c)) = LiftA2_6989586621680392322Sym1 a6989586621680392328
type Apply (Let6989586621680478616Scrutinee_6989586621680478184Sym0 :: TyFun (a ~> b) (TyFun (t a) (Identity (t b)) -> Type) -> Type) (f6989586621680478614 :: a ~> b)
Instance details Defined in Data.Traversable.Singletons type Apply (Let6989586621680478616Scrutinee_6989586621680478184Sym0 :: TyFun (a ~> b) (TyFun (t a) (Identity (t b)) -> Type) -> Type) (f6989586621680478614 :: a ~> b) = Let6989586621680478616Scrutinee_6989586621680478184Sym1 f6989586621680478614 :: TyFun (t a) (Identity (t b)) -> Type
type Apply (Traverse_6989586621680478824Sym0 :: TyFun (a ~> f b) (Identity a ~> f (Identity b)) -> Type) (a6989586621680478829 :: a ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478824Sym0 :: TyFun (a ~> f b) (Identity a ~> f (Identity b)) -> Type) (a6989586621680478829 :: a ~> f b) = Traverse_6989586621680478824Sym1 a6989586621680478829
type Unwrappabled (NamedF Identity a name)
Instance details Defined in Lorentz.Wrappable type Unwrappabled (NamedF Identity a name) = a
type AsRPC (NamedF Identity a name)
Instance details Defined in Morley.AsRPC type AsRPC (NamedF Identity a name) = NamedF Identity (AsRPC a) name
type ToT (NamedF Identity a name)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (NamedF Identity a name) = ToT (Identity a)

optional :: Alternative f => f a -> f (Maybe a) #

One or none.

It is useful for modelling any computation that is allowed to fail.

Examples

Expand

Using the Alternative instance of Except, the following functions:

>>> canFail = throwError "it failed" :: Except String Int
>>> final = return 42                :: Except String Int

Can be combined by allowing the first function to fail:

>>> runExcept $ canFail *> final
Left "it failed"
>>> runExcept $ optional canFail *> final
Right 42

for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) #

for is traverse with its arguments flipped. For a version that ignores the results see for_.

filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #

This generalizes the list-based filter function.

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #

The foldM function is analogous to foldl, except that its result is encapsulated in a monad. Note that foldM works from left-to-right over the list arguments. This could be an issue where (>>) and the `folded function' are not commutative.

foldM f a1 [x1, x2, ..., xm]

==

do
  a2 <- f a1 x1
  a3 <- f a2 x2
  ...
  f am xm

If right-to-left evaluation is required, the input list should be reversed.

Note: foldM is the same as foldlM

head :: NonEmpty a -> a #

Extract the first element of the stream.

init :: NonEmpty a -> [a] #

Extract everything except the last element of the stream.

last :: NonEmpty a -> a #

Extract the last element of the stream.

tail :: NonEmpty a -> [a] #

Extract the possibly-empty tail of the stream.

absurd :: Void -> a #

Since Void values logically don't exist, this witnesses the logical reasoning tool of "ex falso quodlibet".

>>> let x :: Either Void Int; x = Right 5
>>> :{
case x of
    Right r -> r
    Left l  -> absurd l
:}
5

Since: base-4.8.0.0

vacuous :: Functor f => f Void -> f a #

If Void is uninhabited then any Functor that holds only values of type Void is holding no values. It is implemented in terms of fmap absurd.

Since: base-4.8.0.0

data Void #

Uninhabited data type

Since: base-4.8.0.0

Instances

Instances details

Data Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Void -> c Void # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Void # toConstr :: Void -> Constr # dataTypeOf :: Void -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Void) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Void) # gmapT :: (forall b. Data b => b -> b) -> Void -> Void # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r # gmapQ :: (forall d. Data d => d -> u) -> Void -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Void -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Void -> m Void # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void #
Semigroup Void	Since: base-4.9.0.0
Instance details Defined in Data.Void Methods (<>) :: Void -> Void -> Void # sconcat :: NonEmpty Void -> Void # stimes :: Integral b => b -> Void -> Void #
Exception Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String #
Generic Void
Instance details Defined in Data.Void Associated Types type Rep Void :: Type -> Type # Methods from :: Void -> Rep Void x # to :: Rep Void x -> Void #
Ix Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods range :: (Void, Void) -> [Void] # index :: (Void, Void) -> Void -> Int # unsafeIndex :: (Void, Void) -> Void -> Int # inRange :: (Void, Void) -> Void -> Bool # rangeSize :: (Void, Void) -> Int # unsafeRangeSize :: (Void, Void) -> Int #
Read Void	Reading a `Void` value is always a parse error, considering `Void` as a data type with no constructors. Since: base-4.8.0.0
Instance details Defined in Data.Void Methods readsPrec :: Int -> ReadS Void # readList :: ReadS [Void] # readPrec :: ReadPrec Void # readListPrec :: ReadPrec [Void] #
Show Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods showsPrec :: Int -> Void -> ShowS # show :: Void -> String # showList :: [Void] -> ShowS #
NFData Void	Defined as `rnf = absurd`. Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Void -> () #
Buildable Void
Instance details Defined in Formatting.Buildable Methods build :: Void -> Builder #
Eq Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Ord Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods compare :: Void -> Void -> Ordering # (<) :: Void -> Void -> Bool # (<=) :: Void -> Void -> Bool # (>) :: Void -> Void -> Bool # (>=) :: Void -> Void -> Bool # max :: Void -> Void -> Void # min :: Void -> Void -> Void #
Hashable Void
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Void -> Int # hash :: Void -> Int #
ShowErrorComponent Void
Instance details Defined in Text.Megaparsec.Error Methods showErrorComponent :: Void -> String # errorComponentLen :: Void -> Int #
IsoValue Void
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Void :: T # Methods toVal :: Void -> Value (ToT Void) # fromVal :: Value (ToT Void) -> Void #
PEq Void
Instance details Defined in Data.Eq.Singletons Associated Types type arg == arg1 :: Bool # type arg /= arg1 :: Bool #
SEq Void
Instance details Defined in Data.Eq.Singletons Methods (%==) :: forall (t1 :: Void) (t2 :: Void). Sing t1 -> Sing t2 -> Sing (Apply (Apply (==@#@$) t1) t2) # (%/=) :: forall (t1 :: Void) (t2 :: Void). Sing t1 -> Sing t2 -> Sing (Apply (Apply (/=@#@$) t1) t2) #
POrd Void
Instance details Defined in Data.Ord.Singletons Associated Types type Compare arg arg1 :: Ordering # type arg < arg1 :: Bool # type arg <= arg1 :: Bool # type arg > arg1 :: Bool # type arg >= arg1 :: Bool # type Max arg arg1 :: a # type Min arg arg1 :: a #
SOrd Void
Instance details Defined in Data.Ord.Singletons Methods sCompare :: forall (t1 :: Void) (t2 :: Void). Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2) # (%<) :: forall (t1 :: Void) (t2 :: Void). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) # (%<=) :: forall (t1 :: Void) (t2 :: Void). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2) # (%>) :: forall (t1 :: Void) (t2 :: Void). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%>=) :: forall (t1 :: Void) (t2 :: Void). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2) # sMax :: forall (t1 :: Void) (t2 :: Void). Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2) # sMin :: forall (t1 :: Void) (t2 :: Void). Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2) #
PSemigroup Void
Instance details Defined in Data.Semigroup.Singletons.Internal Associated Types type arg <> arg1 :: a # type Sconcat arg :: a #
SSemigroup Void
Instance details Defined in Data.Semigroup.Singletons.Internal Methods (%<>) :: forall (t1 :: Void) (t2 :: Void). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sSconcat :: forall (t :: NonEmpty Void). Sing t -> Sing (Apply SconcatSym0 t) #
PShow Void
Instance details Defined in Text.Show.Singletons Associated Types type ShowsPrec arg arg1 arg2 :: Symbol # type Show_ arg :: Symbol # type ShowList arg arg1 :: Symbol #
SShow Void
Instance details Defined in Text.Show.Singletons Methods sShowsPrec :: forall (t1 :: Nat) (t2 :: Void) (t3 :: Symbol). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply ShowsPrecSym0 t1) t2) t3) # sShow_ :: forall (t :: Void). Sing t -> Sing (Apply Show_Sym0 t) # sShowList :: forall (t1 :: [Void]) (t2 :: Symbol). Sing t1 -> Sing t2 -> Sing (Apply (Apply ShowListSym0 t1) t2) #
TestCoercion SVoid
Instance details Defined in Data.Singletons.Base.Instances Methods testCoercion :: forall (a :: k) (b :: k). SVoid a -> SVoid b -> Maybe (Coercion a b) #
TestEquality SVoid
Instance details Defined in Data.Singletons.Base.Instances Methods testEquality :: forall (a :: k) (b :: k). SVoid a -> SVoid b -> Maybe (a :~: b) #
Lift Void	Since: template-haskell-2.15.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Void -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Void -> Code m Void #
MonadError (MichelsonFailureWithStack Void) EvalOp
Instance details Defined in Morley.Michelson.Interpret Methods throwError :: MichelsonFailureWithStack Void -> EvalOp a # catchError :: EvalOp a -> (MichelsonFailureWithStack Void -> EvalOp a) -> EvalOp a #
SuppressUnusedWarnings TFHelper_6989586621679584165Sym0
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings Compare_6989586621679181460Sym0
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings TFHelper_6989586621679130639Sym0
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings ShowsPrec_6989586621680071884Sym0
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679584165Sym1 a6989586621679584170 :: TyFun Void Void -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679181460Sym1 a6989586621679181465 :: TyFun Void Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680071884Sym1 a6989586621680071892 :: TyFun Void (Symbol ~> Symbol) -> Type)
Instance details Defined in Text.Show.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679130639Sym1 a6989586621679130644 :: TyFun Void Bool -> Type)
Instance details Defined in Data.Eq.Singletons Methods suppressUnusedWarnings :: () #
type Rep Void	Since: base-4.8.0.0
Instance details Defined in Data.Void type Rep Void = D1 ('MetaData "Void" "Data.Void" "base" 'False) (V1 :: Type -> Type)
type ToT Void
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Void = GValueType (Rep Void)
type Demote Void
Instance details Defined in Data.Singletons.Base.Instances type Demote Void = Void
type Sing
Instance details Defined in Data.Singletons.Base.Instances type Sing = SVoid
type Sconcat (arg :: NonEmpty Void)
Instance details Defined in Data.Semigroup.Singletons.Internal type Sconcat (arg :: NonEmpty Void) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty Void) Void -> Type) arg
type Show_ (arg :: Void)
Instance details Defined in Text.Show.Singletons type Show_ (arg :: Void) = Apply (Show__6989586621680047550Sym0 :: TyFun Void Symbol -> Type) arg
type (arg1 :: Void) /= (arg2 :: Void)
Instance details Defined in Data.Eq.Singletons type (arg1 :: Void) /= (arg2 :: Void) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun Void (Void ~> Bool) -> Type) arg1) arg2
type (a1 :: Void) == (a2 :: Void)
Instance details Defined in Data.Eq.Singletons type (a1 :: Void) == (a2 :: Void) = Apply (Apply TFHelper_6989586621679130639Sym0 a1) a2
type (arg1 :: Void) < (arg2 :: Void)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Void) < (arg2 :: Void) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun Void (Void ~> Bool) -> Type) arg1) arg2
type (arg1 :: Void) <= (arg2 :: Void)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Void) <= (arg2 :: Void) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun Void (Void ~> Bool) -> Type) arg1) arg2
type (arg1 :: Void) > (arg2 :: Void)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Void) > (arg2 :: Void) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun Void (Void ~> Bool) -> Type) arg1) arg2
type (arg1 :: Void) >= (arg2 :: Void)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Void) >= (arg2 :: Void) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun Void (Void ~> Bool) -> Type) arg1) arg2
type Compare (a1 :: Void) (a2 :: Void)
Instance details Defined in Data.Ord.Singletons type Compare (a1 :: Void) (a2 :: Void) = Apply (Apply Compare_6989586621679181460Sym0 a1) a2
type Max (arg1 :: Void) (arg2 :: Void)
Instance details Defined in Data.Ord.Singletons type Max (arg1 :: Void) (arg2 :: Void) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun Void (Void ~> Void) -> Type) arg1) arg2
type Min (arg1 :: Void) (arg2 :: Void)
Instance details Defined in Data.Ord.Singletons type Min (arg1 :: Void) (arg2 :: Void) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun Void (Void ~> Void) -> Type) arg1) arg2
type (a1 :: Void) <> (a2 :: Void)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a1 :: Void) <> (a2 :: Void) = Apply (Apply TFHelper_6989586621679584165Sym0 a1) a2
type ShowList (arg1 :: [Void]) arg2
Instance details Defined in Text.Show.Singletons type ShowList (arg1 :: [Void]) arg2 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Void] (Symbol ~> Symbol) -> Type) arg1) arg2
type ShowsPrec a1 (a2 :: Void) a3
Instance details Defined in Text.Show.Singletons type ShowsPrec a1 (a2 :: Void) a3 = Apply (Apply (Apply ShowsPrec_6989586621680071884Sym0 a1) a2) a3
type Apply (TFHelper_6989586621679584165Sym1 a6989586621679584170 :: TyFun Void Void -> Type) (a6989586621679584171 :: Void)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679584165Sym1 a6989586621679584170 :: TyFun Void Void -> Type) (a6989586621679584171 :: Void) = TFHelper_6989586621679584165 a6989586621679584170 a6989586621679584171
type Apply (Compare_6989586621679181460Sym1 a6989586621679181465 :: TyFun Void Ordering -> Type) (a6989586621679181466 :: Void)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679181460Sym1 a6989586621679181465 :: TyFun Void Ordering -> Type) (a6989586621679181466 :: Void) = Compare_6989586621679181460 a6989586621679181465 a6989586621679181466
type Apply (TFHelper_6989586621679130639Sym1 a6989586621679130644 :: TyFun Void Bool -> Type) (a6989586621679130645 :: Void)
Instance details Defined in Data.Eq.Singletons type Apply (TFHelper_6989586621679130639Sym1 a6989586621679130644 :: TyFun Void Bool -> Type) (a6989586621679130645 :: Void) = TFHelper_6989586621679130639 a6989586621679130644 a6989586621679130645
type Apply TFHelper_6989586621679584165Sym0 (a6989586621679584170 :: Void)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply TFHelper_6989586621679584165Sym0 (a6989586621679584170 :: Void) = TFHelper_6989586621679584165Sym1 a6989586621679584170
type Apply Compare_6989586621679181460Sym0 (a6989586621679181465 :: Void)
Instance details Defined in Data.Ord.Singletons type Apply Compare_6989586621679181460Sym0 (a6989586621679181465 :: Void) = Compare_6989586621679181460Sym1 a6989586621679181465
type Apply TFHelper_6989586621679130639Sym0 (a6989586621679130644 :: Void)
Instance details Defined in Data.Eq.Singletons type Apply TFHelper_6989586621679130639Sym0 (a6989586621679130644 :: Void) = TFHelper_6989586621679130639Sym1 a6989586621679130644
type Apply ShowsPrec_6989586621680071884Sym0 (a6989586621680071892 :: Nat)
Instance details Defined in Text.Show.Singletons type Apply ShowsPrec_6989586621680071884Sym0 (a6989586621680071892 :: Nat) = ShowsPrec_6989586621680071884Sym1 a6989586621680071892
type Apply (ShowsPrec_6989586621680071884Sym1 a6989586621680071892 :: TyFun Void (Symbol ~> Symbol) -> Type) (a6989586621680071893 :: Void)
Instance details Defined in Text.Show.Singletons type Apply (ShowsPrec_6989586621680071884Sym1 a6989586621680071892 :: TyFun Void (Symbol ~> Symbol) -> Type) (a6989586621680071893 :: Void) = ShowsPrec_6989586621680071884Sym2 a6989586621680071892 a6989586621680071893

class MonadTrans (t :: (Type -> Type) -> Type -> Type) where #

The class of monad transformers. Instances should satisfy the following laws, which state that lift is a monad transformation:

```
lift . return = return
```
```
lift (m >>= f) = lift m >>= (lift . f)
```

Methods

lift :: Monad m => m a -> t m a #

Lift a computation from the argument monad to the constructed monad.

Instances

Instances details

MonadTrans Free	This is not a true monad transformer. It is only a monad transformer "up to `retract`".
Instance details Defined in Control.Monad.Free Methods lift :: Monad m => m a -> Free m a #
MonadTrans Yoneda
Instance details Defined in Data.Functor.Yoneda Methods lift :: Monad m => m a -> Yoneda m a #
MonadTrans MaybeT
Instance details Defined in Control.Monad.Trans.Maybe Methods lift :: Monad m => m a -> MaybeT m a #
MonadTrans (RandT g)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods lift :: Monad m => m a -> RandT g m a #
MonadTrans (RandT g)
Instance details Defined in Control.Monad.Trans.Random.Strict Methods lift :: Monad m => m a -> RandT g m a #
Alternative f => MonadTrans (CofreeT f)
Instance details Defined in Control.Comonad.Trans.Cofree Methods lift :: Monad m => m a -> CofreeT f m a #
MonadTrans (FreeT f)
Instance details Defined in Control.Monad.Trans.Free Methods lift :: Monad m => m a -> FreeT f m a #
MonadTrans (ErrorT e)
Instance details Defined in Control.Monad.Trans.Error Methods lift :: Monad m => m a -> ErrorT e m a #
MonadTrans (ExceptT e)
Instance details Defined in Control.Monad.Trans.Except Methods lift :: Monad m => m a -> ExceptT e m a #
MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Trans.Identity Methods lift :: Monad m => m a -> IdentityT m a #
MonadTrans (ReaderT r)
Instance details Defined in Control.Monad.Trans.Reader Methods lift :: Monad m => m a -> ReaderT r m a #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods lift :: Monad m => m a -> StateT s m a #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Strict Methods lift :: Monad m => m a -> StateT s m a #

liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).

liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).

liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. liftM2).

fix :: (a -> a) -> a #

fix f is the least fixed point of the function f, i.e. the least defined x such that f x = x.

For example, we can write the factorial function using direct recursion as

>>> let fac n = if n <= 1 then 1 else n * fac (n-1) in fac 5
120

This uses the fact that Haskell’s let introduces recursive bindings. We can rewrite this definition using fix,

>>> fix (\rec n -> if n <= 1 then 1 else n * rec (n-1)) 5
120

Instead of making a recursive call, we introduce a dummy parameter rec; when used within fix, this parameter then refers to fix’s argument, hence the recursion is reintroduced.

forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) #

forM is mapM with its arguments flipped. For a version that ignores the results see forM_.

(<$!>) :: Monad m => (a -> b) -> m a -> m b infixl 4 #

Strict version of <$>.

Since: base-4.8.0.0

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 #

Right-to-left composition of Kleisli arrows. (>=>), with the arguments flipped.

Note how this operator resembles function composition (.):

(.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #

Left-to-right composition of Kleisli arrows.

'(bs >=> cs) a' can be understood as the do expression

do b <- bs a
   cs b

foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () #

Like foldM, but discards the result.

forever :: Applicative f => f a -> f b #

Repeat an action indefinitely.

Examples

Expand

A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan).

For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

echoServer :: Socket -> IO ()
echoServer socket = forever $ do
  client <- accept socket
  forkFinally (echo client) (\_ -> hClose client)
  where
    echo :: Handle -> IO ()
    echo client = forever $
      hGetLine client >>= hPutStrLn client

Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #

The mapAndUnzipM function maps its first argument over a list, returning the result as a pair of lists. This function is mainly used with complicated data structures or a state monad.

mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a #

Direct MonadPlus equivalent of filter.

Examples

Expand

The filter function is just mfilter specialized to the list monad:

filter = ( mfilter :: (a -> Bool) -> [a] -> [a] )

An example using mfilter with the Maybe monad:

>>> mfilter odd (Just 1)
Just 1
>>> mfilter odd (Just 2)
Nothing

replicateM :: Applicative m => Int -> m a -> m [a] #

replicateM n act performs the action act n times, and then returns the list of results:

Examples

Expand

>>> replicateM 3 (putStrLn "a")
a
a
a

replicateM_ :: Applicative m => Int -> m a -> m () #

Like replicateM, but discards the result.

zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #

The zipWithM function generalizes zipWith to arbitrary applicative functors.

zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #

zipWithM_ is the extension of zipWithM which ignores the final result.

class Monad m => MonadIO (m :: Type -> Type) where #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a #

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

Expand

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Instances

Instances details

MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
MonadIO Q
Instance details Defined in Language.Haskell.TH.Syntax Methods liftIO :: IO a -> Q a #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a #
MonadIO m => MonadIO (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods liftIO :: IO a -> RandT g m a #
MonadIO m => MonadIO (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Strict Methods liftIO :: IO a -> RandT g m a #
(Functor f, MonadIO m) => MonadIO (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods liftIO :: IO a -> FreeT f m a #
(Error e, MonadIO m) => MonadIO (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods liftIO :: IO a -> ErrorT e m a #
MonadIO m => MonadIO (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a #
MonadIO m => MonadIO (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a #

modify :: MonadState s m => (s -> s) -> m () #

Monadic state transformer.

Maps an old state to a new state inside a state monad. The old state is thrown away.

     Main> :t modify ((+1) :: Int -> Int)
     modify (...) :: (MonadState Int a) => a ()

This says that modify (+1) acts over any Monad that is a member of the MonadState class, with an Int state.

type Word62 = OddWord Word64 (One (One (One (One (One (Zero ())))))) #

type Word63 = OddWord Word64 (One (One (One (One (One (One ())))))) #

class Monad m => MonadReader r (m :: Type -> Type) | m -> r where #

See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.

Minimal complete definition

(ask | reader), local

Methods

ask :: m r #

Retrieves the monad environment.

local #

Arguments

:: (r -> r)	The function to modify the environment.
-> m a	`Reader` to run in the modified environment.
-> m a

Executes a computation in a modified environment.

reader #

Arguments

:: (r -> a)	The selector function to apply to the environment.
-> m a

Retrieves a function of the current environment.

Instances

Instances details

MonadReader ContractEnv EvalOp
Instance details Defined in Morley.Michelson.Interpret Methods ask :: EvalOp ContractEnv # local :: (ContractEnv -> ContractEnv) -> EvalOp a -> EvalOp a # reader :: (ContractEnv -> a) -> EvalOp a #
(Representable f, Rep f ~ a) => MonadReader a (Co f)
Instance details Defined in Data.Functor.Rep Methods ask :: Co f a # local :: (a -> a) -> Co f a0 -> Co f a0 # reader :: (a -> a0) -> Co f a0 #
(Functor m, MonadReader e m) => MonadReader e (Free m)
Instance details Defined in Control.Monad.Free Methods ask :: Free m e # local :: (e -> e) -> Free m a -> Free m a # reader :: (e -> a) -> Free m a #
MonadReader r m => MonadReader r (ListT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ListT m r # local :: (r -> r) -> ListT m a -> ListT m a # reader :: (r -> a) -> ListT m a #
MonadReader r m => MonadReader r (MaybeT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: MaybeT m r # local :: (r -> r) -> MaybeT m a -> MaybeT m a # reader :: (r -> a) -> MaybeT m a #
MonadReader s (ReifiedFold s)
Instance details Defined in Control.Lens.Reified Methods ask :: ReifiedFold s s # local :: (s -> s) -> ReifiedFold s a -> ReifiedFold s a # reader :: (s -> a) -> ReifiedFold s a #
MonadReader s (ReifiedGetter s)
Instance details Defined in Control.Lens.Reified Methods ask :: ReifiedGetter s s # local :: (s -> s) -> ReifiedGetter s a -> ReifiedGetter s a # reader :: (s -> a) -> ReifiedGetter s a #
MonadReader r m => MonadReader r (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods ask :: RandT g m r # local :: (r -> r) -> RandT g m a -> RandT g m a # reader :: (r -> a) -> RandT g m a #
MonadReader r m => MonadReader r (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Strict Methods ask :: RandT g m r # local :: (r -> r) -> RandT g m a -> RandT g m a # reader :: (r -> a) -> RandT g m a #
(Functor f, MonadReader r m) => MonadReader r (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods ask :: FreeT f m r # local :: (r -> r) -> FreeT f m a -> FreeT f m a # reader :: (r -> a) -> FreeT f m a #
(Error e, MonadReader r m) => MonadReader r (ErrorT e m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ErrorT e m r # local :: (r -> r) -> ErrorT e m a -> ErrorT e m a # reader :: (r -> a) -> ErrorT e m a #
MonadReader r m => MonadReader r (ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ExceptT e m r # local :: (r -> r) -> ExceptT e m a -> ExceptT e m a # reader :: (r -> a) -> ExceptT e m a #
MonadReader r m => MonadReader r (IdentityT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: IdentityT m r # local :: (r -> r) -> IdentityT m a -> IdentityT m a # reader :: (r -> a) -> IdentityT m a #
Monad m => MonadReader r (ReaderT r m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ReaderT r m r # local :: (r -> r) -> ReaderT r m a -> ReaderT r m a # reader :: (r -> a) -> ReaderT r m a #
MonadReader r m => MonadReader r (StateT s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
MonadReader r m => MonadReader r (StateT s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
MonadReader r ((->) r)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: r -> r # local :: (r -> r) -> (r -> a) -> r -> a # reader :: (r -> a) -> r -> a #
MonadReader r' m => MonadReader r' (ContT r m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ContT r m r' # local :: (r' -> r') -> ContT r m a -> ContT r m a # reader :: (r' -> a) -> ContT r m a #
(Monad m, Monoid w) => MonadReader r (RWST r w s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: RWST r w s m r # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #
(Monad m, Monoid w) => MonadReader r (RWST r w s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: RWST r w s m r # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #

class Monad m => MonadState s (m :: Type -> Type) | m -> s where #

Minimal definition is either both of get and put or just state

Minimal complete definition

state | get, put

Methods

put :: s -> m () #

Replace the state inside the monad.

state :: (s -> (a, s)) -> m a #

Embed a simple state action into the monad.

Instances

Instances details

MonadState InterpreterState EvalOp
Instance details Defined in Morley.Michelson.Interpret Methods get :: EvalOp InterpreterState # put :: InterpreterState -> EvalOp () # state :: (InterpreterState -> (a, InterpreterState)) -> EvalOp a #
(Functor m, MonadState s m) => MonadState s (Free m)
Instance details Defined in Control.Monad.Free Methods get :: Free m s # put :: s -> Free m () # state :: (s -> (a, s)) -> Free m a #
MonadState s m => MonadState s (ListT m)
Instance details Defined in Control.Monad.State.Class Methods get :: ListT m s # put :: s -> ListT m () # state :: (s -> (a, s)) -> ListT m a #
MonadState s m => MonadState s (MaybeT m)
Instance details Defined in Control.Monad.State.Class Methods get :: MaybeT m s # put :: s -> MaybeT m () # state :: (s -> (a, s)) -> MaybeT m a #
MonadState s m => MonadState s (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods get :: RandT g m s # put :: s -> RandT g m () # state :: (s -> (a, s)) -> RandT g m a #
MonadState s m => MonadState s (RandT g m)
Instance details Defined in Control.Monad.Trans.Random.Strict Methods get :: RandT g m s # put :: s -> RandT g m () # state :: (s -> (a, s)) -> RandT g m a #
(Functor f, MonadState s m) => MonadState s (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods get :: FreeT f m s # put :: s -> FreeT f m () # state :: (s -> (a, s)) -> FreeT f m a #
(Error e, MonadState s m) => MonadState s (ErrorT e m)
Instance details Defined in Control.Monad.State.Class Methods get :: ErrorT e m s # put :: s -> ErrorT e m () # state :: (s -> (a, s)) -> ErrorT e m a #
MonadState s m => MonadState s (ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.State.Class Methods get :: ExceptT e m s # put :: s -> ExceptT e m () # state :: (s -> (a, s)) -> ExceptT e m a #
MonadState s m => MonadState s (IdentityT m)
Instance details Defined in Control.Monad.State.Class Methods get :: IdentityT m s # put :: s -> IdentityT m () # state :: (s -> (a, s)) -> IdentityT m a #
MonadState s m => MonadState s (ReaderT r m)
Instance details Defined in Control.Monad.State.Class Methods get :: ReaderT r m s # put :: s -> ReaderT r m () # state :: (s -> (a, s)) -> ReaderT r m a #
Monad m => MonadState s (StateT s m)
Instance details Defined in Control.Monad.State.Class Methods get :: StateT s m s # put :: s -> StateT s m () # state :: (s -> (a, s)) -> StateT s m a #
Monad m => MonadState s (StateT s m)
Instance details Defined in Control.Monad.State.Class Methods get :: StateT s m s # put :: s -> StateT s m () # state :: (s -> (a, s)) -> StateT s m a #
(Monoid w, MonadState s m) => MonadState s (WriterT w m)
Instance details Defined in Control.Monad.State.Class Methods get :: WriterT w m s # put :: s -> WriterT w m () # state :: (s -> (a, s)) -> WriterT w m a #
(Monoid w, MonadState s m) => MonadState s (WriterT w m)
Instance details Defined in Control.Monad.State.Class Methods get :: WriterT w m s # put :: s -> WriterT w m () # state :: (s -> (a, s)) -> WriterT w m a #
MonadState s m => MonadState s (ContT r m)
Instance details Defined in Control.Monad.State.Class Methods get :: ContT r m s # put :: s -> ContT r m () # state :: (s -> (a, s)) -> ContT r m a #
(Monad m, Monoid w) => MonadState s (RWST r w s m)
Instance details Defined in Control.Monad.State.Class Methods get :: RWST r w s m s # put :: s -> RWST r w s m () # state :: (s -> (a, s)) -> RWST r w s m a #
(Monad m, Monoid w) => MonadState s (RWST r w s m)
Instance details Defined in Control.Monad.State.Class Methods get :: RWST r w s m s # put :: s -> RWST r w s m () # state :: (s -> (a, s)) -> RWST r w s m a #

class Hashable a where #

The class of types that can be converted to a hash value.

Minimal implementation: hashWithSalt.

Note: the hash is not guaranteed to be stable across library versions, operating systems or architectures. For stable hashing use named hashes: SHA256, CRC32 etc.

If you are looking for Hashable instance in time package, check time-compat

Minimal complete definition

Nothing

Methods

hashWithSalt :: Int -> a -> Int infixl 0 #

Return a hash value for the argument, using the given salt.

The general contract of hashWithSalt is:

If two values are equal according to the == method, then applying the hashWithSalt method on each of the two values must produce the same integer result if the same salt is used in each case.
It is not required that if two values are unequal according to the == method, then applying the hashWithSalt method on each of the two values must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal values may improve the performance of hashing-based data structures.
This method can be used to compute different hash values for the same input by providing a different salt in each application of the method. This implies that any instance that defines hashWithSalt must make use of the salt in its implementation.
hashWithSalt may return negative Int values.

Instances

Instances details

Hashable Value
Instance details Defined in Data.Aeson.Types.Internal Methods hashWithSalt :: Int -> Value -> Int # hash :: Value -> Int #
Hashable SomeTypeRep
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> SomeTypeRep -> Int # hash :: SomeTypeRep -> Int #
Hashable Unique
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Unique -> Int # hash :: Unique -> Int #
Hashable Version
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Version -> Int # hash :: Version -> Int #
Hashable Void
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Void -> Int # hash :: Void -> Int #
Hashable IntPtr
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntPtr -> Int # hash :: IntPtr -> Int #
Hashable WordPtr
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WordPtr -> Int # hash :: WordPtr -> Int #
Hashable ThreadId
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ThreadId -> Int # hash :: ThreadId -> Int #
Hashable Fingerprint	Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Fingerprint -> Int # hash :: Fingerprint -> Int #
Hashable Int16
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int16 -> Int # hash :: Int16 -> Int #
Hashable Int32
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int32 -> Int # hash :: Int32 -> Int #
Hashable Int64
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int64 -> Int # hash :: Int64 -> Int #
Hashable Int8
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int8 -> Int # hash :: Int8 -> Int #
Hashable Word16
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word16 -> Int # hash :: Word16 -> Int #
Hashable Word32
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word32 -> Int # hash :: Word32 -> Int #
Hashable Word64
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word64 -> Int # hash :: Word64 -> Int #
Hashable ByteString
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Hashable ByteString
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Hashable ShortByteString
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> ShortByteString -> Int # hash :: ShortByteString -> Int #
Hashable IntSet	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntSet -> Int # hash :: IntSet -> Int #
Hashable BigNat
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> BigNat -> Int # hash :: BigNat -> Int #
Hashable Ordering
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ordering -> Int # hash :: Ordering -> Int #
Hashable TicketKey
Instance details Defined in Morley.Michelson.Runtime.GState Methods hashWithSalt :: Int -> TicketKey -> Int # hash :: TicketKey -> Int #
Hashable MText
Instance details Defined in Morley.Michelson.Text Methods hashWithSalt :: Int -> MText -> Int # hash :: MText -> Int #
Hashable GlobalCounter
Instance details Defined in Morley.Tezos.Address Methods hashWithSalt :: Int -> GlobalCounter -> Int # hash :: GlobalCounter -> Int #
Hashable HexJSONByteString
Instance details Defined in Morley.Util.ByteString Methods hashWithSalt :: Int -> HexJSONByteString -> Int # hash :: HexJSONByteString -> Int #
Hashable Scientific	A hash can be safely calculated from a `Scientific`. No magnitude `10^e` is calculated so there's no risk of a blowup in space or time when hashing scientific numbers coming from untrusted sources. `>>>` `import Data.Hashable (hash)``>>>` `let x = scientific 1 2``>>>` `let y = scientific 100 0``>>>` `(x == y, hash x == hash y)`(True,True)
Instance details Defined in Data.Scientific Methods hashWithSalt :: Int -> Scientific -> Int # hash :: Scientific -> Int #
Hashable Text
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Hashable Text
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Hashable ShortText
Instance details Defined in Data.Text.Short.Internal Methods hashWithSalt :: Int -> ShortText -> Int # hash :: ShortText -> Int #
Hashable UUID
Instance details Defined in Data.UUID.Types.Internal Methods hashWithSalt :: Int -> UUID -> Int # hash :: UUID -> Int #
Hashable Word8
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word8 -> Int # hash :: Word8 -> Int #
Hashable Integer
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Integer -> Int # hash :: Integer -> Int #
Hashable Natural
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Natural -> Int # hash :: Natural -> Int #
Hashable ()
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> () -> Int # hash :: () -> Int #
Hashable Bool
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Bool -> Int # hash :: Bool -> Int #
Hashable Char
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Char -> Int # hash :: Char -> Int #
Hashable Double	Note: prior to `hashable-1.3.0.0`, `hash 0.0 /= hash (-0.0)` The `hash` of NaN is not well defined. Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Double -> Int # hash :: Double -> Int #
Hashable Float	Note: prior to `hashable-1.3.0.0`, `hash 0.0 /= hash (-0.0)` The `hash` of NaN is not well defined. Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Float -> Int # hash :: Float -> Int #
Hashable Int
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Int -> Int # hash :: Int -> Int #
Hashable Word
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Word -> Int # hash :: Word -> Int #
Hashable v => Hashable (KeyMap v)
Instance details Defined in Data.Aeson.KeyMap Methods hashWithSalt :: Int -> KeyMap v -> Int # hash :: KeyMap v -> Int #
Hashable a => Hashable (Complex a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Complex a -> Int # hash :: Complex a -> Int #
Hashable a => Hashable (Identity a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Identity a -> Int # hash :: Identity a -> Int #
Hashable a => Hashable (First a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> First a -> Int # hash :: First a -> Int #
Hashable a => Hashable (Last a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Last a -> Int # hash :: Last a -> Int #
Hashable a => Hashable (Max a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Max a -> Int # hash :: Max a -> Int #
Hashable a => Hashable (Min a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Min a -> Int # hash :: Min a -> Int #
Hashable a => Hashable (Option a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Option a -> Int # hash :: Option a -> Int #
Hashable a => Hashable (WrappedMonoid a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WrappedMonoid a -> Int # hash :: WrappedMonoid a -> Int #
Hashable a => Hashable (NonEmpty a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> NonEmpty a -> Int # hash :: NonEmpty a -> Int #
Hashable (FunPtr a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> FunPtr a -> Int # hash :: FunPtr a -> Int #
Hashable (Ptr a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ptr a -> Int # hash :: Ptr a -> Int #
Hashable a => Hashable (Ratio a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Ratio a -> Int # hash :: Ratio a -> Int #
Hashable (StableName a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> StableName a -> Int # hash :: StableName a -> Int #
Hashable v => Hashable (IntMap v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntMap v -> Int # hash :: IntMap v -> Int #
Hashable v => Hashable (Seq v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Seq v -> Int # hash :: Seq v -> Int #
Hashable v => Hashable (Set v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Set v -> Int # hash :: Set v -> Int #
Hashable v => Hashable (Tree v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Tree v -> Int # hash :: Tree v -> Int #
Hashable1 f => Hashable (Fix f)
Instance details Defined in Data.Fix Methods hashWithSalt :: Int -> Fix f -> Int # hash :: Fix f -> Int #
Hashable (Prime p)
Instance details Defined in Data.Field.Galois.Prime Methods hashWithSalt :: Int -> Prime p -> Int # hash :: Prime p -> Int #
Hashable (Hashed a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Hashed a -> Int # hash :: Hashed a -> Int #
Hashable a => Hashable (StringEncode a)
Instance details Defined in Morley.Micheline.Json Methods hashWithSalt :: Int -> StringEncode a -> Int # hash :: StringEncode a -> Int #
Hashable a => Hashable (Maybe a)
Instance details Defined in Data.Strict.Maybe Methods hashWithSalt :: Int -> Maybe a -> Int # hash :: Maybe a -> Int #
Hashable a => Hashable (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods hashWithSalt :: Int -> HashSet a -> Int # hash :: HashSet a -> Int #
Hashable a => Hashable (Maybe a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Maybe a -> Int # hash :: Maybe a -> Int #
Hashable a => Hashable (a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a) -> Int # hash :: (a) -> Int #
Hashable a => Hashable [a]
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> [a] -> Int # hash :: [a] -> Int #
(Hashable a, Hashable b) => Hashable (Either a b)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Either a b -> Int # hash :: Either a b -> Int #
Hashable (Fixed a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Fixed a -> Int # hash :: Fixed a -> Int #
Hashable (Proxy a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Proxy a -> Int # hash :: Proxy a -> Int #
Hashable a => Hashable (Arg a b)	Note: Prior to `hashable-1.3.0.0` the hash computation included the second argument of `Arg` which wasn't consistent with its `Eq` instance. Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Arg a b -> Int # hash :: Arg a b -> Int #
Hashable (TypeRep a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> TypeRep a -> Int # hash :: TypeRep a -> Int #
(Hashable k, Hashable v) => Hashable (Map k v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Map k v -> Int # hash :: Map k v -> Int #
(Hashable a, Hashable b) => Hashable (Either a b)
Instance details Defined in Data.Strict.Either Methods hashWithSalt :: Int -> Either a b -> Int # hash :: Either a b -> Int #
(Hashable a, Hashable b) => Hashable (These a b)
Instance details Defined in Data.Strict.These Methods hashWithSalt :: Int -> These a b -> Int # hash :: These a b -> Int #
(Hashable a, Hashable b) => Hashable (Pair a b)
Instance details Defined in Data.Strict.Tuple Methods hashWithSalt :: Int -> Pair a b -> Int # hash :: Pair a b -> Int #
(Hashable a, Hashable b) => Hashable (These a b)
Instance details Defined in Data.These Methods hashWithSalt :: Int -> These a b -> Int # hash :: These a b -> Int #
(Hashable k, Hashable v) => Hashable (HashMap k v)
Instance details Defined in Data.HashMap.Internal Methods hashWithSalt :: Int -> HashMap k v -> Int # hash :: HashMap k v -> Int #
(Hashable a1, Hashable a2) => Hashable (a1, a2)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2) -> Int # hash :: (a1, a2) -> Int #
Hashable a => Hashable (Const a b)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Const a b -> Int # hash :: Const a b -> Int #
(Hashable a1, Hashable a2, Hashable a3) => Hashable (a1, a2, a3)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3) -> Int # hash :: (a1, a2, a3) -> Int #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Product f g a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Product f g a -> Int # hash :: Product f g a -> Int #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Sum f g a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Sum f g a -> Int # hash :: Sum f g a -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4) => Hashable (a1, a2, a3, a4)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4) -> Int # hash :: (a1, a2, a3, a4) -> Int #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Compose f g a)	In general, `hash (Compose x) ≠ hash x`. However, `hashWithSalt` satisfies its variant of this equivalence.
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Compose f g a -> Int # hash :: Compose f g a -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5) => Hashable (a1, a2, a3, a4, a5)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5) -> Int # hash :: (a1, a2, a3, a4, a5) -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6) => Hashable (a1, a2, a3, a4, a5, a6)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5, a6) -> Int # hash :: (a1, a2, a3, a4, a5, a6) -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6, Hashable a7) => Hashable (a1, a2, a3, a4, a5, a6, a7)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5, a6, a7) -> Int # hash :: (a1, a2, a3, a4, a5, a6, a7) -> Int #

data Text #

A space efficient, packed, unboxed Unicode text type.

Instances

Instances details

Structured Text
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy Text -> Structure # structureHash' :: Tagged Text MD5
Chunk Text
Instance details Defined in Data.Attoparsec.Internal.Types Associated Types type ChunkElem Text # Methods nullChunk :: Text -> Bool # pappendChunk :: State Text -> Text -> State Text # atBufferEnd :: Text -> State Text -> Pos # bufferElemAt :: Text -> Pos -> State Text -> Maybe (ChunkElem Text, Int) # chunkElemToChar :: Text -> ChunkElem Text -> Char #
FromBuilder Text
Instance details Defined in Fmt.Internal.Core Methods fromBuilder :: Builder -> Text #
Buildable Text
Instance details Defined in Formatting.Buildable Methods build :: Text -> Builder #
Hashable Text
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Ixed Text
Instance details Defined in Control.Lens.At Methods ix :: Index Text -> Traversal' Text (IxValue Text) #
Stream Text
Instance details Defined in Text.Megaparsec.Stream Associated Types type Token Text # type Tokens Text # Methods tokenToChunk :: Proxy Text -> Token Text -> Tokens Text # tokensToChunk :: Proxy Text -> [Token Text] -> Tokens Text # chunkToTokens :: Proxy Text -> Tokens Text -> [Token Text] # chunkLength :: Proxy Text -> Tokens Text -> Int # chunkEmpty :: Proxy Text -> Tokens Text -> Bool # take1_ :: Text -> Maybe (Token Text, Text) # takeN_ :: Int -> Text -> Maybe (Tokens Text, Text) # takeWhile_ :: (Token Text -> Bool) -> Text -> (Tokens Text, Text) #
TraversableStream Text
Instance details Defined in Text.Megaparsec.Stream Methods reachOffset :: Int -> PosState Text -> (Maybe String, PosState Text) # reachOffsetNoLine :: Int -> PosState Text -> PosState Text #
VisualStream Text
Instance details Defined in Text.Megaparsec.Stream Methods showTokens :: Proxy Text -> NonEmpty (Token Text) -> String # tokensLength :: Proxy Text -> NonEmpty (Token Text) -> Int #
(Bottom, DoNotUseTextError :: Constraint) => IsoValue Text
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Text :: T # Methods toVal :: Text -> Value (ToT Text) # fromVal :: Value (ToT Text) -> Text #
ToAnchor Text
Instance details Defined in Morley.Util.Markdown Methods toAnchor :: Text -> Anchor #
Container Text
Instance details Defined in Universum.Container.Class Associated Types type Element Text # Methods toList :: Text -> [Element Text] # null :: Text -> Bool # foldr :: (Element Text -> b -> b) -> b -> Text -> b # foldl :: (b -> Element Text -> b) -> b -> Text -> b # foldl' :: (b -> Element Text -> b) -> b -> Text -> b # length :: Text -> Int # elem :: Element Text -> Text -> Bool # foldMap :: Monoid m => (Element Text -> m) -> Text -> m # fold :: Text -> Element Text # foldr' :: (Element Text -> b -> b) -> b -> Text -> b # notElem :: Element Text -> Text -> Bool # all :: (Element Text -> Bool) -> Text -> Bool # any :: (Element Text -> Bool) -> Text -> Bool # and :: Text -> Bool # or :: Text -> Bool # find :: (Element Text -> Bool) -> Text -> Maybe (Element Text) # safeHead :: Text -> Maybe (Element Text) # safeMaximum :: Text -> Maybe (Element Text) # safeMinimum :: Text -> Maybe (Element Text) # safeFoldr1 :: (Element Text -> Element Text -> Element Text) -> Text -> Maybe (Element Text) # safeFoldl1 :: (Element Text -> Element Text -> Element Text) -> Text -> Maybe (Element Text) #
FromList Text
Instance details Defined in Universum.Container.Class Associated Types type ListElement Text # type FromListC Text # Methods fromList :: [ListElement Text] -> Text #
One Text
Instance details Defined in Universum.Container.Class Associated Types type OneItem Text # Methods one :: OneItem Text -> Text #
Print Text
Instance details Defined in Universum.Print.Internal Methods hPutStr :: Handle -> Text -> IO () # hPutStrLn :: Handle -> Text -> IO () #
ToLText Text
Instance details Defined in Universum.String.Conversion Methods toLText :: Text -> Text0 #
ToString Text
Instance details Defined in Universum.String.Conversion Methods toString :: Text -> String #
ToText Text
Instance details Defined in Universum.String.Conversion Methods toText :: Text -> Text #
ConvertUtf8 Text ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: Text -> ByteString # decodeUtf8 :: ByteString -> Text # decodeUtf8Strict :: ByteString -> Either UnicodeException Text #
ConvertUtf8 Text ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: Text -> ByteString # decodeUtf8 :: ByteString -> Text # decodeUtf8Strict :: ByteString -> Either UnicodeException Text #
type ChunkElem Text
Instance details Defined in Data.Attoparsec.Internal.Types type ChunkElem Text = Char
type State Text
Instance details Defined in Data.Attoparsec.Internal.Types type State Text = Buffer
type Item Text
Instance details Defined in Data.Text type Item Text = Char
type Index Text
Instance details Defined in Control.Lens.At type Index Text = Int
type IxValue Text
Instance details Defined in Control.Lens.At type IxValue Text = Char
type Token Text
Instance details Defined in Text.Megaparsec.Stream type Token Text = Char
type Tokens Text
Instance details Defined in Text.Megaparsec.Stream type Tokens Text = Text
type ToT Text
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Text = ToT MText
type PrettyShow Text
Instance details Defined in Morley.Prelude.Show type PrettyShow Text = TypeError ('Text "Show instance for Text is not pretty" :$$: 'Text "Consider relying on the Buildable instance") :: Constraint
type Element Text
Instance details Defined in Universum.Container.Class type Element Text = Char
type FromListC Text
Instance details Defined in Universum.Container.Class type FromListC Text = ()
type ListElement Text
Instance details Defined in Universum.Container.Class type ListElement Text = Item Text
type OneItem Text
Instance details Defined in Universum.Container.Class type OneItem Text = Char

data HashMap k v #

A map from keys to values. A map cannot contain duplicate keys; each key can map to at most one value.

Instances

Instances details

Bifoldable HashMap	Since: unordered-containers-0.2.11
Instance details Defined in Data.HashMap.Internal Methods bifold :: Monoid m => HashMap m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> HashMap a b -> m # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> HashMap a b -> c # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> HashMap a b -> c #
Eq2 HashMap
Instance details Defined in Data.HashMap.Internal Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> HashMap a c -> HashMap b d -> Bool #
Ord2 HashMap
Instance details Defined in Data.HashMap.Internal Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> HashMap a c -> HashMap b d -> Ordering #
Show2 HashMap
Instance details Defined in Data.HashMap.Internal Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> HashMap a b -> ShowS # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [HashMap a b] -> ShowS #
NFData2 HashMap	Since: unordered-containers-0.2.14.0
Instance details Defined in Data.HashMap.Internal Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> HashMap a b -> () #
Hashable2 HashMap
Instance details Defined in Data.HashMap.Internal Methods liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> HashMap a b -> Int #
(Lift k, Lift v) => Lift (HashMap k v :: Type)	Since: unordered-containers-0.2.17.0
Instance details Defined in Data.HashMap.Internal Methods lift :: Quote m => HashMap k v -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => HashMap k v -> Code m (HashMap k v) #
Foldable (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods fold :: Monoid m => HashMap k m -> m # foldMap :: Monoid m => (a -> m) -> HashMap k a -> m # foldMap' :: Monoid m => (a -> m) -> HashMap k a -> m # foldr :: (a -> b -> b) -> b -> HashMap k a -> b # foldr' :: (a -> b -> b) -> b -> HashMap k a -> b # foldl :: (b -> a -> b) -> b -> HashMap k a -> b # foldl' :: (b -> a -> b) -> b -> HashMap k a -> b # foldr1 :: (a -> a -> a) -> HashMap k a -> a # foldl1 :: (a -> a -> a) -> HashMap k a -> a # toList :: HashMap k a -> [a] # null :: HashMap k a -> Bool # length :: HashMap k a -> Int # elem :: Eq a => a -> HashMap k a -> Bool # maximum :: Ord a => HashMap k a -> a # minimum :: Ord a => HashMap k a -> a # sum :: Num a => HashMap k a -> a # product :: Num a => HashMap k a -> a #
Eq k => Eq1 (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods liftEq :: (a -> b -> Bool) -> HashMap k a -> HashMap k b -> Bool #
Ord k => Ord1 (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods liftCompare :: (a -> b -> Ordering) -> HashMap k a -> HashMap k b -> Ordering #
(Eq k, Hashable k, Read k) => Read1 (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (HashMap k a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [HashMap k a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (HashMap k a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [HashMap k a] #
Show k => Show1 (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> HashMap k a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [HashMap k a] -> ShowS #
Traversable (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods traverse :: Applicative f => (a -> f b) -> HashMap k a -> f (HashMap k b) # sequenceA :: Applicative f => HashMap k (f a) -> f (HashMap k a) # mapM :: Monad m => (a -> m b) -> HashMap k a -> m (HashMap k b) # sequence :: Monad m => HashMap k (m a) -> m (HashMap k a) #
Functor (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods fmap :: (a -> b) -> HashMap k a -> HashMap k b # (<$) :: a -> HashMap k b -> HashMap k a #
NFData k => NFData1 (HashMap k)	Since: unordered-containers-0.2.14.0
Instance details Defined in Data.HashMap.Internal Methods liftRnf :: (a -> ()) -> HashMap k a -> () #
Hashable k => Hashable1 (HashMap k)
Instance details Defined in Data.HashMap.Internal Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> HashMap k a -> Int #
(Data k, Data v, Eq k, Hashable k) => Data (HashMap k v)
Instance details Defined in Data.HashMap.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HashMap k v -> c (HashMap k v) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HashMap k v) # toConstr :: HashMap k v -> Constr # dataTypeOf :: HashMap k v -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HashMap k v)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HashMap k v)) # gmapT :: (forall b. Data b => b -> b) -> HashMap k v -> HashMap k v # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HashMap k v -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HashMap k v -> r # gmapQ :: (forall d. Data d => d -> u) -> HashMap k v -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HashMap k v -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HashMap k v -> m (HashMap k v) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HashMap k v -> m (HashMap k v) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HashMap k v -> m (HashMap k v) #
(Eq k, Hashable k) => Monoid (HashMap k v)	`mempty` = `empty` `mappend` = `union` If a key occurs in both maps, the mapping from the first will be the mapping in the result. Examples Expand `>>>` `mappend (fromList [(1,'a'),(2,'b')]) (fromList [(2,'c'),(3,'d')])`fromList [(1,'a'),(2,'b'),(3,'d')]
Instance details Defined in Data.HashMap.Internal Methods mempty :: HashMap k v # mappend :: HashMap k v -> HashMap k v -> HashMap k v # mconcat :: [HashMap k v] -> HashMap k v #
(Eq k, Hashable k) => Semigroup (HashMap k v)	`<>` = `union` If a key occurs in both maps, the mapping from the first will be the mapping in the result. Examples Expand `>>>` `fromList [(1,'a'),(2,'b')] <> fromList [(2,'c'),(3,'d')]`fromList [(1,'a'),(2,'b'),(3,'d')]
Instance details Defined in Data.HashMap.Internal Methods (<>) :: HashMap k v -> HashMap k v -> HashMap k v # sconcat :: NonEmpty (HashMap k v) -> HashMap k v # stimes :: Integral b => b -> HashMap k v -> HashMap k v #
(Eq k, Hashable k) => IsList (HashMap k v)
Instance details Defined in Data.HashMap.Internal Associated Types type Item (HashMap k v) # Methods fromList :: [Item (HashMap k v)] -> HashMap k v # fromListN :: Int -> [Item (HashMap k v)] -> HashMap k v # toList :: HashMap k v -> [Item (HashMap k v)] #
(Eq k, Hashable k, Read k, Read e) => Read (HashMap k e)
Instance details Defined in Data.HashMap.Internal Methods readsPrec :: Int -> ReadS (HashMap k e) # readList :: ReadS [HashMap k e] # readPrec :: ReadPrec (HashMap k e) # readListPrec :: ReadPrec [HashMap k e] #
(Show k, Show v) => Show (HashMap k v)
Instance details Defined in Data.HashMap.Internal Methods showsPrec :: Int -> HashMap k v -> ShowS # show :: HashMap k v -> String # showList :: [HashMap k v] -> ShowS #
(NFData k, NFData v) => NFData (HashMap k v)
Instance details Defined in Data.HashMap.Internal Methods rnf :: HashMap k v -> () #
(Eq k, Eq v) => Eq (HashMap k v)	Note that, in the presence of hash collisions, equal `HashMap`s may behave differently, i.e. substitutivity may be violated: `>>>` `data D = A \| B deriving (Eq, Show)``>>>` `instance Hashable D where hashWithSalt salt _d = salt` `>>>` `x = fromList [(A,1), (B,2)]``>>>` `y = fromList [(B,2), (A,1)]` `>>>` `x == y`True `>>>` `toList x`[(A,1),(B,2)] `>>>` `toList y`[(B,2),(A,1)] In general, the lack of substitutivity can be observed with any function that depends on the key ordering, such as folds and traversals.
Instance details Defined in Data.HashMap.Internal Methods (==) :: HashMap k v -> HashMap k v -> Bool # (/=) :: HashMap k v -> HashMap k v -> Bool #
(Ord k, Ord v) => Ord (HashMap k v)	The ordering is total and consistent with the `Eq` instance. However, nothing else about the ordering is specified, and it may change from version to version of either this package or of hashable.
Instance details Defined in Data.HashMap.Internal Methods compare :: HashMap k v -> HashMap k v -> Ordering # (<) :: HashMap k v -> HashMap k v -> Bool # (<=) :: HashMap k v -> HashMap k v -> Bool # (>) :: HashMap k v -> HashMap k v -> Bool # (>=) :: HashMap k v -> HashMap k v -> Bool # max :: HashMap k v -> HashMap k v -> HashMap k v # min :: HashMap k v -> HashMap k v -> HashMap k v #
(Hashable k, Hashable v) => Hashable (HashMap k v)
Instance details Defined in Data.HashMap.Internal Methods hashWithSalt :: Int -> HashMap k v -> Int # hash :: HashMap k v -> Int #
(Eq k, Hashable k) => At (HashMap k a)
Instance details Defined in Control.Lens.At Methods at :: Index (HashMap k a) -> Lens' (HashMap k a) (Maybe (IxValue (HashMap k a))) #
(Eq k, Hashable k) => Ixed (HashMap k a)
Instance details Defined in Control.Lens.At Methods ix :: Index (HashMap k a) -> Traversal' (HashMap k a) (IxValue (HashMap k a)) #
(Hashable k, Eq k) => Wrapped (HashMap k a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (HashMap k a) # Methods _Wrapped' :: Iso' (HashMap k a) (Unwrapped (HashMap k a)) #
(Eq k, Hashable k, Monoid k, Semiring v) => Semiring (HashMap k v)	The multiplication laws are satisfied for any underlying `Monoid` as the key type, so we require a `Monoid` constraint instead of a `Semiring` constraint since `times` can use the context of either.
Instance details Defined in Data.Semiring Methods plus :: HashMap k v -> HashMap k v -> HashMap k v # zero :: HashMap k v # times :: HashMap k v -> HashMap k v -> HashMap k v # one :: HashMap k v # fromNatural :: Natural -> HashMap k v #
Container (HashMap k v)
Instance details Defined in Universum.Container.Class Associated Types type Element (HashMap k v) # Methods toList :: HashMap k v -> [Element (HashMap k v)] # null :: HashMap k v -> Bool # foldr :: (Element (HashMap k v) -> b -> b) -> b -> HashMap k v -> b # foldl :: (b -> Element (HashMap k v) -> b) -> b -> HashMap k v -> b # foldl' :: (b -> Element (HashMap k v) -> b) -> b -> HashMap k v -> b # length :: HashMap k v -> Int # elem :: Element (HashMap k v) -> HashMap k v -> Bool # foldMap :: Monoid m => (Element (HashMap k v) -> m) -> HashMap k v -> m # fold :: HashMap k v -> Element (HashMap k v) # foldr' :: (Element (HashMap k v) -> b -> b) -> b -> HashMap k v -> b # notElem :: Element (HashMap k v) -> HashMap k v -> Bool # all :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Bool # any :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Bool # and :: HashMap k v -> Bool # or :: HashMap k v -> Bool # find :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Maybe (Element (HashMap k v)) # safeHead :: HashMap k v -> Maybe (Element (HashMap k v)) # safeMaximum :: HashMap k v -> Maybe (Element (HashMap k v)) # safeMinimum :: HashMap k v -> Maybe (Element (HashMap k v)) # safeFoldr1 :: (Element (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> Maybe (Element (HashMap k v)) # safeFoldl1 :: (Element (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> Maybe (Element (HashMap k v)) #
(Eq k, Hashable k) => FromList (HashMap k v)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (HashMap k v) # type FromListC (HashMap k v) # Methods fromList :: [ListElement (HashMap k v)] -> HashMap k v #
Hashable k => One (HashMap k v)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (HashMap k v) # Methods one :: OneItem (HashMap k v) -> HashMap k v #
ToPairs (HashMap k v)
Instance details Defined in Universum.Container.Class Associated Types type Key (HashMap k v) # type Val (HashMap k v) # Methods toPairs :: HashMap k v -> [(Key (HashMap k v), Val (HashMap k v))] # keys :: HashMap k v -> [Key (HashMap k v)] # elems :: HashMap k v -> [Val (HashMap k v)] #
(t ~ HashMap k' a', Hashable k, Eq k) => Rewrapped (HashMap k a) t	Use `wrapping fromList`. Unwrapping returns some permutation of the list.
Instance details Defined in Control.Lens.Wrapped
type Item (HashMap k v)
Instance details Defined in Data.HashMap.Internal type Item (HashMap k v) = (k, v)
type Index (HashMap k a)
Instance details Defined in Control.Lens.At type Index (HashMap k a) = k
type IxValue (HashMap k a)
Instance details Defined in Control.Lens.At type IxValue (HashMap k a) = a
type Unwrapped (HashMap k a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (HashMap k a) = [(k, a)]
type Element (HashMap k v)
Instance details Defined in Universum.Container.Class type Element (HashMap k v) = ElementDefault (HashMap k v)
type FromListC (HashMap k v)
Instance details Defined in Universum.Container.Class type FromListC (HashMap k v) = ()
type Key (HashMap k v)
Instance details Defined in Universum.Container.Class type Key (HashMap k v) = k
type ListElement (HashMap k v)
Instance details Defined in Universum.Container.Class type ListElement (HashMap k v) = Item (HashMap k v)
type OneItem (HashMap k v)
Instance details Defined in Universum.Container.Class type OneItem (HashMap k v) = (k, v)
type Val (HashMap k v)
Instance details Defined in Universum.Container.Class type Val (HashMap k v) = v

stdout :: Handle #

data Handle #

Haskell defines operations to read and write characters from and to files, represented by values of type Handle. Each value of this type is a handle: a record used by the Haskell run-time system to manage I/O with file system objects. A handle has at least the following properties:

whether it manages input or output or both;
whether it is open, closed or semi-closed;
whether the object is seekable;
whether buffering is disabled, or enabled on a line or block basis;
a buffer (whose length may be zero).

Most handles will also have a current I/O position indicating where the next input or output operation will occur. A handle is readable if it manages only input or both input and output; likewise, it is writable if it manages only output or both input and output. A handle is open when first allocated. Once it is closed it can no longer be used for either input or output, though an implementation cannot re-use its storage while references remain to it. Handles are in the Show and Eq classes. The string produced by showing a handle is system dependent; it should include enough information to identify the handle for debugging. A handle is equal according to == only to itself; no attempt is made to compare the internal state of different handles for equality.

Instances

Instances details

Show Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> Handle -> ShowS # show :: Handle -> String # showList :: [Handle] -> ShowS #
Eq Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods (==) :: Handle -> Handle -> Bool # (/=) :: Handle -> Handle -> Bool #

class Bifunctor (p :: Type -> Type -> Type) where #

A bifunctor is a type constructor that takes two type arguments and is a functor in both arguments. That is, unlike with Functor, a type constructor such as Either does not need to be partially applied for a Bifunctor instance, and the methods in this class permit mapping functions over the Left value or the Right value, or both at the same time.

Formally, the class Bifunctor represents a bifunctor from Hask -> Hask.

Intuitively it is a bifunctor where both the first and second arguments are covariant.

You can define a Bifunctor by either defining bimap or by defining both first and second.

If you supply bimap, you should ensure that:

bimap id id ≡ id

If you supply first and second, ensure:

first id ≡ id
second id ≡ id

If you supply both, you should also ensure:

bimap f g ≡ first f . second g

These ensure by parametricity:

bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
first  (f . g) ≡ first  f . first  g
second (f . g) ≡ second f . second g

Since: base-4.8.0.0

Minimal complete definition

bimap | first, second

Methods

bimap :: (a -> b) -> (c -> d) -> p a c -> p b d #

Map over both arguments at the same time.

bimap f g ≡ first f . second g

Examples

Expand

>>> bimap toUpper (+1) ('j', 3)
('J',4)

>>> bimap toUpper (+1) (Left 'j')
Left 'J'

>>> bimap toUpper (+1) (Right 3)
Right 4

first :: (a -> b) -> p a c -> p b c #

Map covariantly over the first argument.

first f ≡ bimap f id

Examples

Expand

>>> first toUpper ('j', 3)
('J',3)

>>> first toUpper (Left 'j')
Left 'J'

second :: (b -> c) -> p a b -> p a c #

Map covariantly over the second argument.

second ≡ bimap id

Examples

Expand

>>> second (+1) ('j', 3)
('j',4)

>>> second (+1) (Right 3)
Right 4

Instances

Instances details

Bifunctor Either	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d # first :: (a -> b) -> Either a c -> Either b c # second :: (b -> c) -> Either a b -> Either a c #
Bifunctor Arg	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods bimap :: (a -> b) -> (c -> d) -> Arg a c -> Arg b d # first :: (a -> b) -> Arg a c -> Arg b c # second :: (b -> c) -> Arg a b -> Arg a c #
Bifunctor Either
Instance details Defined in Data.Strict.Either Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d # first :: (a -> b) -> Either a c -> Either b c # second :: (b -> c) -> Either a b -> Either a c #
Bifunctor These
Instance details Defined in Data.Strict.These Methods bimap :: (a -> b) -> (c -> d) -> These a c -> These b d # first :: (a -> b) -> These a c -> These b c # second :: (b -> c) -> These a b -> These a c #
Bifunctor Pair
Instance details Defined in Data.Strict.Tuple Methods bimap :: (a -> b) -> (c -> d) -> Pair a c -> Pair b d # first :: (a -> b) -> Pair a c -> Pair b c # second :: (b -> c) -> Pair a b -> Pair a c #
Bifunctor These
Instance details Defined in Data.These Methods bimap :: (a -> b) -> (c -> d) -> These a c -> These b d # first :: (a -> b) -> These a c -> These b c # second :: (b -> c) -> These a b -> These a c #
Bifunctor (,)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) # first :: (a -> b) -> (a, c) -> (b, c) # second :: (b -> c) -> (a, b) -> (a, c) #
Bifunctor (Const :: Type -> Type -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d # first :: (a -> b) -> Const a c -> Const b c # second :: (b -> c) -> Const a b -> Const a c #
Functor f => Bifunctor (CofreeF f)
Instance details Defined in Control.Comonad.Trans.Cofree Methods bimap :: (a -> b) -> (c -> d) -> CofreeF f a c -> CofreeF f b d # first :: (a -> b) -> CofreeF f a c -> CofreeF f b c # second :: (b -> c) -> CofreeF f a b -> CofreeF f a c #
Functor f => Bifunctor (FreeF f)
Instance details Defined in Control.Monad.Trans.Free Methods bimap :: (a -> b) -> (c -> d) -> FreeF f a c -> FreeF f b d # first :: (a -> b) -> FreeF f a c -> FreeF f b c # second :: (b -> c) -> FreeF f a b -> FreeF f a c #
Bifunctor (Tagged :: Type -> Type -> Type)
Instance details Defined in Data.Tagged Methods bimap :: (a -> b) -> (c -> d) -> Tagged a c -> Tagged b d # first :: (a -> b) -> Tagged a c -> Tagged b c # second :: (b -> c) -> Tagged a b -> Tagged a c #
Bifunctor ((,,) x1)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, a, c) -> (x1, b, d) # first :: (a -> b) -> (x1, a, c) -> (x1, b, c) # second :: (b -> c) -> (x1, a, b) -> (x1, a, c) #
Bifunctor (K1 i :: Type -> Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d # first :: (a -> b) -> K1 i a c -> K1 i b c # second :: (b -> c) -> K1 i a b -> K1 i a c #
Bifunctor ((,,,) x1 x2)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, a, c) -> (x1, x2, b, d) # first :: (a -> b) -> (x1, x2, a, c) -> (x1, x2, b, c) # second :: (b -> c) -> (x1, x2, a, b) -> (x1, x2, a, c) #
Functor f => Bifunctor (Clown f :: Type -> Type -> Type)
Instance details Defined in Data.Bifunctor.Clown Methods bimap :: (a -> b) -> (c -> d) -> Clown f a c -> Clown f b d # first :: (a -> b) -> Clown f a c -> Clown f b c # second :: (b -> c) -> Clown f a b -> Clown f a c #
Bifunctor p => Bifunctor (Flip p)
Instance details Defined in Data.Bifunctor.Flip Methods bimap :: (a -> b) -> (c -> d) -> Flip p a c -> Flip p b d # first :: (a -> b) -> Flip p a c -> Flip p b c # second :: (b -> c) -> Flip p a b -> Flip p a c #
Functor g => Bifunctor (Joker g :: Type -> Type -> Type)
Instance details Defined in Data.Bifunctor.Joker Methods bimap :: (a -> b) -> (c -> d) -> Joker g a c -> Joker g b d # first :: (a -> b) -> Joker g a c -> Joker g b c # second :: (b -> c) -> Joker g a b -> Joker g a c #
Bifunctor p => Bifunctor (WrappedBifunctor p)
Instance details Defined in Data.Bifunctor.Wrapped Methods bimap :: (a -> b) -> (c -> d) -> WrappedBifunctor p a c -> WrappedBifunctor p b d # first :: (a -> b) -> WrappedBifunctor p a c -> WrappedBifunctor p b c # second :: (b -> c) -> WrappedBifunctor p a b -> WrappedBifunctor p a c #
Bifunctor ((,,,,) x1 x2 x3)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, d) # first :: (a -> b) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, c) # second :: (b -> c) -> (x1, x2, x3, a, b) -> (x1, x2, x3, a, c) #
(Bifunctor f, Bifunctor g) => Bifunctor (Product f g)
Instance details Defined in Data.Bifunctor.Product Methods bimap :: (a -> b) -> (c -> d) -> Product f g a c -> Product f g b d # first :: (a -> b) -> Product f g a c -> Product f g b c # second :: (b -> c) -> Product f g a b -> Product f g a c #
(Bifunctor p, Bifunctor q) => Bifunctor (Sum p q)
Instance details Defined in Data.Bifunctor.Sum Methods bimap :: (a -> b) -> (c -> d) -> Sum p q a c -> Sum p q b d # first :: (a -> b) -> Sum p q a c -> Sum p q b c # second :: (b -> c) -> Sum p q a b -> Sum p q a c #
Bifunctor ((,,,,,) x1 x2 x3 x4)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, d) # first :: (a -> b) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, c) # second :: (b -> c) -> (x1, x2, x3, x4, a, b) -> (x1, x2, x3, x4, a, c) #
(Functor f, Bifunctor p) => Bifunctor (Tannen f p)
Instance details Defined in Data.Bifunctor.Tannen Methods bimap :: (a -> b) -> (c -> d) -> Tannen f p a c -> Tannen f p b d # first :: (a -> b) -> Tannen f p a c -> Tannen f p b c # second :: (b -> c) -> Tannen f p a b -> Tannen f p a c #
Bifunctor ((,,,,,,) x1 x2 x3 x4 x5)	Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, d) # first :: (a -> b) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, c) # second :: (b -> c) -> (x1, x2, x3, x4, x5, a, b) -> (x1, x2, x3, x4, x5, a, c) #
(Bifunctor p, Functor f, Functor g) => Bifunctor (Biff p f g)
Instance details Defined in Data.Bifunctor.Biff Methods bimap :: (a -> b) -> (c -> d) -> Biff p f g a c -> Biff p f g b d # first :: (a -> b) -> Biff p f g a c -> Biff p f g b c # second :: (b -> c) -> Biff p f g a b -> Biff p f g a c #

newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) infixr 9 #

Right-to-left composition of functors. The composition of applicative functors is always applicative, but the composition of monads is not always a monad.

Constructors

Compose infixr 9
Fields getCompose :: f (g a)

Instances

Instances details

TestEquality f => TestEquality (Compose f g :: k2 -> Type)	The deduction (via generativity) that if `g x :~: g y` then `x :~: y`. Since: base-4.14.0.0
Instance details Defined in Data.Functor.Compose Methods testEquality :: forall (a :: k) (b :: k). Compose f g a -> Compose f g b -> Maybe (a :~: b) #
Functor f => Generic1 (Compose f g :: k -> Type)
Instance details Defined in Data.Functor.Compose Associated Types type Rep1 (Compose f g) :: k -> Type # Methods from1 :: forall (a :: k0). Compose f g a -> Rep1 (Compose f g) a # to1 :: forall (a :: k0). Rep1 (Compose f g) a -> Compose f g a #
Unbox (f (g a)) => Vector Vector (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Compose f g a) -> m (Vector (Compose f g a)) # basicUnsafeThaw :: PrimMonad m => Vector (Compose f g a) -> m (Mutable Vector (PrimState m) (Compose f g a)) # basicLength :: Vector (Compose f g a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Compose f g a) -> Vector (Compose f g a) # basicUnsafeIndexM :: Monad m => Vector (Compose f g a) -> Int -> m (Compose f g a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Compose f g a) -> Vector (Compose f g a) -> m () # elemseq :: Vector (Compose f g a) -> Compose f g a -> b -> b #
Unbox (f (g a)) => MVector MVector (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Compose f g a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Compose f g a) -> MVector s (Compose f g a) # basicOverlaps :: MVector s (Compose f g a) -> MVector s (Compose f g a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Compose f g a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Compose f g a -> m (MVector (PrimState m) (Compose f g a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> Int -> m (Compose f g a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> Int -> Compose f g a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> Compose f g a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> MVector (PrimState m) (Compose f g a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> MVector (PrimState m) (Compose f g a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Compose f g a) -> Int -> m (MVector (PrimState m) (Compose f g a)) #
Sieve (ReifiedIndexedFold i) (Compose [] ((,) i))
Instance details Defined in Control.Lens.Reified Methods sieve :: ReifiedIndexedFold i a b -> a -> Compose [] ((,) i) b #
(Representable f, Representable g) => Representable (Compose f g)
Instance details Defined in Data.Functor.Rep Associated Types type Rep (Compose f g) # Methods tabulate :: (Rep (Compose f g) -> a) -> Compose f g a # index :: Compose f g a -> Rep (Compose f g) -> a #
(Foldable f, Foldable g) => Foldable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m # foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m # foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b # foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b # foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] # null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # sum :: Num a => Compose f g a -> a # product :: Num a => Compose f g a -> a #
(Eq1 f, Eq1 g) => Eq1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftEq :: (a -> b -> Bool) -> Compose f g a -> Compose f g b -> Bool #
(Ord1 f, Ord1 g) => Ord1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftCompare :: (a -> b -> Ordering) -> Compose f g a -> Compose f g b -> Ordering #
(Read1 f, Read1 g) => Read1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Compose f g a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Compose f g a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Compose f g a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Compose f g a] #
(Show1 f, Show1 g) => Show1 (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Compose f g a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Compose f g a] -> ShowS #
(Traversable f, Traversable g) => Traversable (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods traverse :: Applicative f0 => (a -> f0 b) -> Compose f g a -> f0 (Compose f g b) # sequenceA :: Applicative f0 => Compose f g (f0 a) -> f0 (Compose f g a) # mapM :: Monad m => (a -> m b) -> Compose f g a -> m (Compose f g b) # sequence :: Monad m => Compose f g (m a) -> m (Compose f g a) #
(Alternative f, Applicative g) => Alternative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods empty :: Compose f g a # (<\|>) :: Compose f g a -> Compose f g a -> Compose f g a # some :: Compose f g a -> Compose f g [a] # many :: Compose f g a -> Compose f g [a] #
(Applicative f, Applicative g) => Applicative (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods pure :: a -> Compose f g a # (<>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c # (>) :: Compose f g a -> Compose f g b -> Compose f g b # (<*) :: Compose f g a -> Compose f g b -> Compose f g a #
(Functor f, Functor g) => Functor (Compose f g)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fmap :: (a -> b) -> Compose f g a -> Compose f g b # (<$) :: a -> Compose f g b -> Compose f g a #
(NFData1 f, NFData1 g) => NFData1 (Compose f g)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Compose f g a -> () #
(Hashable1 f, Hashable1 g) => Hashable1 (Compose f g)
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Compose f g a -> Int #
(Typeable a, Typeable f, Typeable g, Typeable k1, Typeable k2, Data (f (g a))) => Data (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Compose f g a -> c (Compose f g a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Compose f g a) # toConstr :: Compose f g a -> Constr # dataTypeOf :: Compose f g a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Compose f g a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Compose f g a)) # gmapT :: (forall b. Data b => b -> b) -> Compose f g a -> Compose f g a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r # gmapQ :: (forall d. Data d => d -> u) -> Compose f g a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Compose f g a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) #
Generic (Compose f g a)
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type # Methods from :: Compose f g a -> Rep (Compose f g a) x # to :: Rep (Compose f g a) x -> Compose f g a #
(Read1 f, Read1 g, Read a) => Read (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods readsPrec :: Int -> ReadS (Compose f g a) # readList :: ReadS [Compose f g a] # readPrec :: ReadPrec (Compose f g a) # readListPrec :: ReadPrec [Compose f g a] #
(Show1 f, Show1 g, Show a) => Show (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods showsPrec :: Int -> Compose f g a -> ShowS # show :: Compose f g a -> String # showList :: [Compose f g a] -> ShowS #
(NFData1 f, NFData1 g, NFData a) => NFData (Compose f g a)	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods rnf :: Compose f g a -> () #
(Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods (==) :: Compose f g a -> Compose f g a -> Bool # (/=) :: Compose f g a -> Compose f g a -> Bool #
(Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # max :: Compose f g a -> Compose f g a -> Compose f g a # min :: Compose f g a -> Compose f g a -> Compose f g a #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Compose f g a)	In general, `hash (Compose x) ≠ hash x`. However, `hashWithSalt` satisfies its variant of this equivalence.
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Compose f g a -> Int # hash :: Compose f g a -> Int #
Wrapped (Compose f g a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Compose f g a) # Methods _Wrapped' :: Iso' (Compose f g a) (Unwrapped (Compose f g a)) #
Unbox (f (g a)) => Unbox (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base
t ~ Compose f' g' a' => Rewrapped (Compose f g a) t
Instance details Defined in Control.Lens.Wrapped
(Cosieve p f, Cosieve q g) => Cosieve (Procompose p q) (Compose f g)
Instance details Defined in Data.Profunctor.Composition Methods cosieve :: Procompose p q a b -> Compose f g a -> b #
(Sieve p f, Sieve q g) => Sieve (Procompose p q) (Compose g f)
Instance details Defined in Data.Profunctor.Composition Methods sieve :: Procompose p q a b -> a -> Compose g f b #
type Rep1 (Compose f g :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose type Rep1 (Compose f g :: k -> Type) = D1 ('MetaData "Compose" "Data.Functor.Compose" "base" 'True) (C1 ('MetaCons "Compose" 'PrefixI 'True) (S1 ('MetaSel ('Just "getCompose") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (f :.: Rec1 g)))
newtype MVector s (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Compose f g a) = MV_Compose (MVector s (f (g a)))
type Rep (Compose f g)
Instance details Defined in Data.Functor.Rep type Rep (Compose f g) = (Rep f, Rep g)
type Rep (Compose f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose type Rep (Compose f g a) = D1 ('MetaData "Compose" "Data.Functor.Compose" "base" 'True) (C1 ('MetaCons "Compose" 'PrefixI 'True) (S1 ('MetaSel ('Just "getCompose") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f (g a)))))
type Unwrapped (Compose f g a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Compose f g a) = f (g a)
newtype Vector (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Compose f g a) = V_Compose (Vector (f (g a)))

data WrappedMonoid m #

Provide a Semigroup for an arbitrary Monoid.

NOTE: This is not needed anymore since Semigroup became a superclass of Monoid in base-4.11 and this newtype be deprecated at some point in the future.

Instances

Instances details

NFData1 WrappedMonoid	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> WrappedMonoid a -> () #
Hashable1 WrappedMonoid	Since: hashable-1.3.1.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> WrappedMonoid a -> Int #
Unbox a => Vector Vector (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (WrappedMonoid a) -> m (Vector (WrappedMonoid a)) # basicUnsafeThaw :: PrimMonad m => Vector (WrappedMonoid a) -> m (Mutable Vector (PrimState m) (WrappedMonoid a)) # basicLength :: Vector (WrappedMonoid a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (WrappedMonoid a) -> Vector (WrappedMonoid a) # basicUnsafeIndexM :: Monad m => Vector (WrappedMonoid a) -> Int -> m (WrappedMonoid a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (WrappedMonoid a) -> Vector (WrappedMonoid a) -> m () # elemseq :: Vector (WrappedMonoid a) -> WrappedMonoid a -> b -> b #
Unbox a => MVector MVector (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (WrappedMonoid a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) # basicOverlaps :: MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (WrappedMonoid a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> WrappedMonoid a -> m (MVector (PrimState m) (WrappedMonoid a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> Int -> m (WrappedMonoid a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> Int -> WrappedMonoid a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> WrappedMonoid a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> MVector (PrimState m) (WrappedMonoid a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> MVector (PrimState m) (WrappedMonoid a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (WrappedMonoid a) -> Int -> m (MVector (PrimState m) (WrappedMonoid a)) #
Data m => Data (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m) # toConstr :: WrappedMonoid m -> Constr # dataTypeOf :: WrappedMonoid m -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonoid m)) # gmapT :: (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r # gmapQ :: (forall d. Data d => d -> u) -> WrappedMonoid m -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) #
Monoid m => Monoid (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
Monoid m => Semigroup (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m # stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m #
Bounded m => Bounded (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: WrappedMonoid m # maxBound :: WrappedMonoid m #
Enum a => Enum (WrappedMonoid a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] #
Generic (WrappedMonoid m)
Instance details Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m #
Read m => Read (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS (WrappedMonoid m) # readList :: ReadS [WrappedMonoid m] # readPrec :: ReadPrec (WrappedMonoid m) # readListPrec :: ReadPrec [WrappedMonoid m] #
Show m => Show (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> WrappedMonoid m -> ShowS # show :: WrappedMonoid m -> String # showList :: [WrappedMonoid m] -> ShowS #
NFData m => NFData (WrappedMonoid m)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: WrappedMonoid m -> () #
Eq m => Eq (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #
Ord m => Ord (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m #
Hashable a => Hashable (WrappedMonoid a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> WrappedMonoid a -> Int # hash :: WrappedMonoid a -> Int #
Wrapped (WrappedMonoid a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (WrappedMonoid a) # Methods _Wrapped' :: Iso' (WrappedMonoid a) (Unwrapped (WrappedMonoid a)) #
Unbox a => Unbox (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 WrappedMonoid
Instance details Defined in Data.Semigroup Associated Types type Rep1 WrappedMonoid :: k -> Type # Methods from1 :: forall (a :: k). WrappedMonoid a -> Rep1 WrappedMonoid a # to1 :: forall (a :: k). Rep1 WrappedMonoid a -> WrappedMonoid a #
t ~ WrappedMonoid b => Rewrapped (WrappedMonoid a) t
Instance details Defined in Control.Lens.Wrapped
SDecide m => TestCoercion (SWrappedMonoid :: WrappedMonoid m -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods testCoercion :: forall (a :: k) (b :: k). SWrappedMonoid a -> SWrappedMonoid b -> Maybe (Coercion a b) #
SDecide m => TestEquality (SWrappedMonoid :: WrappedMonoid m -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods testEquality :: forall (a :: k) (b :: k). SWrappedMonoid a -> SWrappedMonoid b -> Maybe (a :~: b) #
SingI (UnwrapMonoidSym0 :: TyFun (WrappedMonoid m) m -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing UnwrapMonoidSym0 #
SingI (WrapMonoidSym0 :: TyFun m (WrappedMonoid m) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing WrapMonoidSym0 #
SuppressUnusedWarnings (Pred_6989586621680605958Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Succ_6989586621680605951Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680605994Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a ~> (WrappedMonoid a ~> [WrappedMonoid a])) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromTo_6989586621680605982Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a ~> [WrappedMonoid a]) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromEnum_6989586621680605974Sym0 :: TyFun (WrappedMonoid a) Nat -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680605938Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> WrappedMonoid m) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613741Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606280Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (UnwrapMonoidSym0 :: TyFun (WrappedMonoid m) m -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ToEnum_6989586621680605965Sym0 :: TyFun Nat (WrappedMonoid a) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680582417Sym0 :: TyFun Nat (WrappedMonoid m ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (WrapMonoidSym0 :: TyFun m (WrappedMonoid m) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680605994Sym1 a6989586621680606000 :: TyFun (WrappedMonoid a) (WrappedMonoid a ~> [WrappedMonoid a]) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromTo_6989586621680605982Sym1 a6989586621680605987 :: TyFun (WrappedMonoid a) [WrappedMonoid a] -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680605938Sym1 a6989586621680605943 :: TyFun (WrappedMonoid m) (WrappedMonoid m) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613741Sym1 a6989586621679613746 :: TyFun (WrappedMonoid m) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680582417Sym1 a6989586621680582425 :: TyFun (WrappedMonoid m) (Symbol ~> Symbol) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606280Sym1 a6989586621679606285 :: TyFun (WrappedMonoid m) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (EnumFromThenTo_6989586621680605994Sym2 a6989586621680606000 a6989586621680606001 :: TyFun (WrappedMonoid a) [WrappedMonoid a] -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
newtype MVector s (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (WrappedMonoid a) = MV_WrappedMonoid (MVector s a)
type Apply (ToEnum_6989586621680605965Sym0 :: TyFun Nat (WrappedMonoid a) -> Type) (a6989586621680605971 :: Nat)
Instance details Defined in Data.Semigroup.Singletons type Apply (ToEnum_6989586621680605965Sym0 :: TyFun Nat (WrappedMonoid a) -> Type) (a6989586621680605971 :: Nat) = ToEnum_6989586621680605965 a6989586621680605971 :: WrappedMonoid a
type Apply (WrapMonoidSym0 :: TyFun m (WrappedMonoid m) -> Type) (a6989586621679596528 :: m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (WrapMonoidSym0 :: TyFun m (WrappedMonoid m) -> Type) (a6989586621679596528 :: m) = 'WrapMonoid a6989586621679596528
type Apply (ShowsPrec_6989586621680582417Sym0 :: TyFun Nat (WrappedMonoid m ~> (Symbol ~> Symbol)) -> Type) (a6989586621680582425 :: Nat)
Instance details Defined in Data.Semigroup.Singletons type Apply (ShowsPrec_6989586621680582417Sym0 :: TyFun Nat (WrappedMonoid m ~> (Symbol ~> Symbol)) -> Type) (a6989586621680582425 :: Nat) = ShowsPrec_6989586621680582417Sym1 a6989586621680582425 :: TyFun (WrappedMonoid m) (Symbol ~> Symbol) -> Type
type Rep (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup type Rep (WrappedMonoid m) = D1 ('MetaData "WrappedMonoid" "Data.Semigroup" "base" 'True) (C1 ('MetaCons "WrapMonoid" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonoid") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 m)))
type Unwrapped (WrappedMonoid a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (WrappedMonoid a) = a
type Demote (WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Demote (WrappedMonoid m) = WrappedMonoid (Demote m)
type Sing
Instance details Defined in Data.Semigroup.Singletons.Internal type Sing = SWrappedMonoid :: WrappedMonoid m -> Type
type Mempty
Instance details Defined in Data.Semigroup.Singletons type Mempty = Mempty_6989586621680605947Sym0 :: WrappedMonoid m
type MaxBound
Instance details Defined in Data.Semigroup.Singletons.Internal type MaxBound = MaxBound_6989586621679603434Sym0 :: WrappedMonoid m
type MinBound
Instance details Defined in Data.Semigroup.Singletons.Internal type MinBound = MinBound_6989586621679603431Sym0 :: WrappedMonoid m
newtype Vector (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (WrappedMonoid a) = V_WrappedMonoid (Vector a)
type Rep1 WrappedMonoid	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup type Rep1 WrappedMonoid = D1 ('MetaData "WrappedMonoid" "Data.Semigroup" "base" 'True) (C1 ('MetaCons "WrapMonoid" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonoid") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type Mconcat (arg :: [WrappedMonoid m])
Instance details Defined in Data.Semigroup.Singletons type Mconcat (arg :: [WrappedMonoid m]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [WrappedMonoid m] (WrappedMonoid m) -> Type) arg
type Sconcat (arg :: NonEmpty (WrappedMonoid m))
Instance details Defined in Data.Semigroup.Singletons type Sconcat (arg :: NonEmpty (WrappedMonoid m)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (WrappedMonoid m)) (WrappedMonoid m) -> Type) arg
type FromEnum (a2 :: WrappedMonoid a1)
Instance details Defined in Data.Semigroup.Singletons type FromEnum (a2 :: WrappedMonoid a1) = Apply (FromEnum_6989586621680605974Sym0 :: TyFun (WrappedMonoid a1) Nat -> Type) a2
type Pred (a2 :: WrappedMonoid a1)
Instance details Defined in Data.Semigroup.Singletons type Pred (a2 :: WrappedMonoid a1) = Apply (Pred_6989586621680605958Sym0 :: TyFun (WrappedMonoid a1) (WrappedMonoid a1) -> Type) a2
type Succ (a2 :: WrappedMonoid a1)
Instance details Defined in Data.Semigroup.Singletons type Succ (a2 :: WrappedMonoid a1) = Apply (Succ_6989586621680605951Sym0 :: TyFun (WrappedMonoid a1) (WrappedMonoid a1) -> Type) a2
type ToEnum a2
Instance details Defined in Data.Semigroup.Singletons type ToEnum a2 = Apply (ToEnum_6989586621680605965Sym0 :: TyFun Nat (WrappedMonoid a1) -> Type) a2
type Show_ (arg :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons type Show_ (arg :: WrappedMonoid m) = Apply (Show__6989586621680047550Sym0 :: TyFun (WrappedMonoid m) Symbol -> Type) arg
type (arg :: WrappedMonoid m) /= (arg1 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: WrappedMonoid m) /= (arg1 :: WrappedMonoid m) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type) arg) arg1
type (a1 :: WrappedMonoid m) == (a2 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a1 :: WrappedMonoid m) == (a2 :: WrappedMonoid m) = Apply (Apply (TFHelper_6989586621679606280Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type) a1) a2
type Mappend (arg :: WrappedMonoid m) (arg1 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons type Mappend (arg :: WrappedMonoid m) (arg1 :: WrappedMonoid m) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> WrappedMonoid m) -> Type) arg) arg1
type (arg :: WrappedMonoid m) < (arg1 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: WrappedMonoid m) < (arg1 :: WrappedMonoid m) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type) arg) arg1
type (arg :: WrappedMonoid m) <= (arg1 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: WrappedMonoid m) <= (arg1 :: WrappedMonoid m) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type) arg) arg1
type (arg :: WrappedMonoid m) > (arg1 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: WrappedMonoid m) > (arg1 :: WrappedMonoid m) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type) arg) arg1
type (arg :: WrappedMonoid m) >= (arg1 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: WrappedMonoid m) >= (arg1 :: WrappedMonoid m) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type) arg) arg1
type Compare (a1 :: WrappedMonoid m) (a2 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Compare (a1 :: WrappedMonoid m) (a2 :: WrappedMonoid m) = Apply (Apply (Compare_6989586621679613741Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Ordering) -> Type) a1) a2
type Max (arg :: WrappedMonoid m) (arg1 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Max (arg :: WrappedMonoid m) (arg1 :: WrappedMonoid m) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> WrappedMonoid m) -> Type) arg) arg1
type Min (arg :: WrappedMonoid m) (arg1 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Min (arg :: WrappedMonoid m) (arg1 :: WrappedMonoid m) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> WrappedMonoid m) -> Type) arg) arg1
type (a1 :: WrappedMonoid m) <> (a2 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons type (a1 :: WrappedMonoid m) <> (a2 :: WrappedMonoid m) = Apply (Apply (TFHelper_6989586621680605938Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> WrappedMonoid m) -> Type) a1) a2
type EnumFromTo (a2 :: WrappedMonoid a1) (a3 :: WrappedMonoid a1)
Instance details Defined in Data.Semigroup.Singletons type EnumFromTo (a2 :: WrappedMonoid a1) (a3 :: WrappedMonoid a1) = Apply (Apply (EnumFromTo_6989586621680605982Sym0 :: TyFun (WrappedMonoid a1) (WrappedMonoid a1 ~> [WrappedMonoid a1]) -> Type) a2) a3
type ShowList (arg :: [WrappedMonoid m]) arg1
Instance details Defined in Data.Semigroup.Singletons type ShowList (arg :: [WrappedMonoid m]) arg1 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [WrappedMonoid m] (Symbol ~> Symbol) -> Type) arg) arg1
type EnumFromThenTo (a2 :: WrappedMonoid a1) (a3 :: WrappedMonoid a1) (a4 :: WrappedMonoid a1)
Instance details Defined in Data.Semigroup.Singletons type EnumFromThenTo (a2 :: WrappedMonoid a1) (a3 :: WrappedMonoid a1) (a4 :: WrappedMonoid a1) = Apply (Apply (Apply (EnumFromThenTo_6989586621680605994Sym0 :: TyFun (WrappedMonoid a1) (WrappedMonoid a1 ~> (WrappedMonoid a1 ~> [WrappedMonoid a1])) -> Type) a2) a3) a4
type ShowsPrec a1 (a2 :: WrappedMonoid m) a3
Instance details Defined in Data.Semigroup.Singletons type ShowsPrec a1 (a2 :: WrappedMonoid m) a3 = Apply (Apply (Apply (ShowsPrec_6989586621680582417Sym0 :: TyFun Nat (WrappedMonoid m ~> (Symbol ~> Symbol)) -> Type) a1) a2) a3
type Apply (FromEnum_6989586621680605974Sym0 :: TyFun (WrappedMonoid a) Nat -> Type) (a6989586621680605978 :: WrappedMonoid a)
Instance details Defined in Data.Semigroup.Singletons type Apply (FromEnum_6989586621680605974Sym0 :: TyFun (WrappedMonoid a) Nat -> Type) (a6989586621680605978 :: WrappedMonoid a) = FromEnum_6989586621680605974 a6989586621680605978
type Apply (UnwrapMonoidSym0 :: TyFun (WrappedMonoid m) m -> Type) (a6989586621679596531 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (UnwrapMonoidSym0 :: TyFun (WrappedMonoid m) m -> Type) (a6989586621679596531 :: WrappedMonoid m) = UnwrapMonoid a6989586621679596531
type Apply (Compare_6989586621679613741Sym1 a6989586621679613746 :: TyFun (WrappedMonoid m) Ordering -> Type) (a6989586621679613747 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613741Sym1 a6989586621679613746 :: TyFun (WrappedMonoid m) Ordering -> Type) (a6989586621679613747 :: WrappedMonoid m) = Compare_6989586621679613741 a6989586621679613746 a6989586621679613747
type Apply (TFHelper_6989586621679606280Sym1 a6989586621679606285 :: TyFun (WrappedMonoid m) Bool -> Type) (a6989586621679606286 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606280Sym1 a6989586621679606285 :: TyFun (WrappedMonoid m) Bool -> Type) (a6989586621679606286 :: WrappedMonoid m) = TFHelper_6989586621679606280 a6989586621679606285 a6989586621679606286
type Apply (Pred_6989586621680605958Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a) -> Type) (a6989586621680605962 :: WrappedMonoid a)
Instance details Defined in Data.Semigroup.Singletons type Apply (Pred_6989586621680605958Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a) -> Type) (a6989586621680605962 :: WrappedMonoid a) = Pred_6989586621680605958 a6989586621680605962
type Apply (Succ_6989586621680605951Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a) -> Type) (a6989586621680605955 :: WrappedMonoid a)
Instance details Defined in Data.Semigroup.Singletons type Apply (Succ_6989586621680605951Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a) -> Type) (a6989586621680605955 :: WrappedMonoid a) = Succ_6989586621680605951 a6989586621680605955
type Apply (EnumFromTo_6989586621680605982Sym1 a6989586621680605987 :: TyFun (WrappedMonoid a) [WrappedMonoid a] -> Type) (a6989586621680605988 :: WrappedMonoid a)
Instance details Defined in Data.Semigroup.Singletons type Apply (EnumFromTo_6989586621680605982Sym1 a6989586621680605987 :: TyFun (WrappedMonoid a) [WrappedMonoid a] -> Type) (a6989586621680605988 :: WrappedMonoid a) = EnumFromTo_6989586621680605982 a6989586621680605987 a6989586621680605988
type Apply (TFHelper_6989586621680605938Sym1 a6989586621680605943 :: TyFun (WrappedMonoid m) (WrappedMonoid m) -> Type) (a6989586621680605944 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons type Apply (TFHelper_6989586621680605938Sym1 a6989586621680605943 :: TyFun (WrappedMonoid m) (WrappedMonoid m) -> Type) (a6989586621680605944 :: WrappedMonoid m) = TFHelper_6989586621680605938 a6989586621680605943 a6989586621680605944
type Apply (EnumFromThenTo_6989586621680605994Sym2 a6989586621680606000 a6989586621680606001 :: TyFun (WrappedMonoid a) [WrappedMonoid a] -> Type) (a6989586621680606002 :: WrappedMonoid a)
Instance details Defined in Data.Semigroup.Singletons type Apply (EnumFromThenTo_6989586621680605994Sym2 a6989586621680606000 a6989586621680606001 :: TyFun (WrappedMonoid a) [WrappedMonoid a] -> Type) (a6989586621680606002 :: WrappedMonoid a) = EnumFromThenTo_6989586621680605994 a6989586621680606000 a6989586621680606001 a6989586621680606002
type Apply (EnumFromThenTo_6989586621680605994Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a ~> (WrappedMonoid a ~> [WrappedMonoid a])) -> Type) (a6989586621680606000 :: WrappedMonoid a)
Instance details Defined in Data.Semigroup.Singletons type Apply (EnumFromThenTo_6989586621680605994Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a ~> (WrappedMonoid a ~> [WrappedMonoid a])) -> Type) (a6989586621680606000 :: WrappedMonoid a) = EnumFromThenTo_6989586621680605994Sym1 a6989586621680606000
type Apply (EnumFromTo_6989586621680605982Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a ~> [WrappedMonoid a]) -> Type) (a6989586621680605987 :: WrappedMonoid a)
Instance details Defined in Data.Semigroup.Singletons type Apply (EnumFromTo_6989586621680605982Sym0 :: TyFun (WrappedMonoid a) (WrappedMonoid a ~> [WrappedMonoid a]) -> Type) (a6989586621680605987 :: WrappedMonoid a) = EnumFromTo_6989586621680605982Sym1 a6989586621680605987
type Apply (TFHelper_6989586621680605938Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> WrappedMonoid m) -> Type) (a6989586621680605943 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons type Apply (TFHelper_6989586621680605938Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> WrappedMonoid m) -> Type) (a6989586621680605943 :: WrappedMonoid m) = TFHelper_6989586621680605938Sym1 a6989586621680605943
type Apply (Compare_6989586621679613741Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Ordering) -> Type) (a6989586621679613746 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613741Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Ordering) -> Type) (a6989586621679613746 :: WrappedMonoid m) = Compare_6989586621679613741Sym1 a6989586621679613746
type Apply (TFHelper_6989586621679606280Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type) (a6989586621679606285 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606280Sym0 :: TyFun (WrappedMonoid m) (WrappedMonoid m ~> Bool) -> Type) (a6989586621679606285 :: WrappedMonoid m) = TFHelper_6989586621679606280Sym1 a6989586621679606285
type Apply (EnumFromThenTo_6989586621680605994Sym1 a6989586621680606000 :: TyFun (WrappedMonoid a) (WrappedMonoid a ~> [WrappedMonoid a]) -> Type) (a6989586621680606001 :: WrappedMonoid a)
Instance details Defined in Data.Semigroup.Singletons type Apply (EnumFromThenTo_6989586621680605994Sym1 a6989586621680606000 :: TyFun (WrappedMonoid a) (WrappedMonoid a ~> [WrappedMonoid a]) -> Type) (a6989586621680606001 :: WrappedMonoid a) = EnumFromThenTo_6989586621680605994Sym2 a6989586621680606000 a6989586621680606001
type Apply (ShowsPrec_6989586621680582417Sym1 a6989586621680582425 :: TyFun (WrappedMonoid m) (Symbol ~> Symbol) -> Type) (a6989586621680582426 :: WrappedMonoid m)
Instance details Defined in Data.Semigroup.Singletons type Apply (ShowsPrec_6989586621680582417Sym1 a6989586621680582425 :: TyFun (WrappedMonoid m) (Symbol ~> Symbol) -> Type) (a6989586621680582426 :: WrappedMonoid m) = ShowsPrec_6989586621680582417Sym2 a6989586621680582425 a6989586621680582426

newtype Option a #

Option is effectively Maybe with a better instance of Monoid, built off of an underlying Semigroup instead of an underlying Monoid.

Ideally, this type would not exist at all and we would just fix the Monoid instance of Maybe.

In GHC 8.4 and higher, the Monoid instance for Maybe has been corrected to lift a Semigroup instance instead of a Monoid instance. Consequently, this type is no longer useful.

Constructors

Option
Fields getOption :: Maybe a

Instances

Instances details

MonadFix Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mfix :: (a -> Option a) -> Option a #
Foldable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fold :: Monoid m => Option m -> m # foldMap :: Monoid m => (a -> m) -> Option a -> m # foldMap' :: Monoid m => (a -> m) -> Option a -> m # foldr :: (a -> b -> b) -> b -> Option a -> b # foldr' :: (a -> b -> b) -> b -> Option a -> b # foldl :: (b -> a -> b) -> b -> Option a -> b # foldl' :: (b -> a -> b) -> b -> Option a -> b # foldr1 :: (a -> a -> a) -> Option a -> a # foldl1 :: (a -> a -> a) -> Option a -> a # toList :: Option a -> [a] # null :: Option a -> Bool # length :: Option a -> Int # elem :: Eq a => a -> Option a -> Bool # maximum :: Ord a => Option a -> a # minimum :: Ord a => Option a -> a # sum :: Num a => Option a -> a # product :: Num a => Option a -> a #
Traversable Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) # sequenceA :: Applicative f => Option (f a) -> f (Option a) # mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) # sequence :: Monad m => Option (m a) -> m (Option a) #
Alternative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods empty :: Option a # (<\|>) :: Option a -> Option a -> Option a # some :: Option a -> Option [a] # many :: Option a -> Option [a] #
Applicative Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods pure :: a -> Option a # (<>) :: Option (a -> b) -> Option a -> Option b # liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c # (>) :: Option a -> Option b -> Option b # (<*) :: Option a -> Option b -> Option a #
Functor Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Option a -> Option b # (<$) :: a -> Option b -> Option a #
Monad Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (>>=) :: Option a -> (a -> Option b) -> Option b # (>>) :: Option a -> Option b -> Option b # return :: a -> Option a #
MonadPlus Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mzero :: Option a # mplus :: Option a -> Option a -> Option a #
NFData1 Option	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Option a -> () #
Hashable1 Option	Since: hashable-1.3.1.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Option a -> Int #
Data a => Data (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Option a -> c (Option a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Option a) # toConstr :: Option a -> Constr # dataTypeOf :: Option a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Option a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Option a)) # gmapT :: (forall b. Data b => b -> b) -> Option a -> Option a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Option a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Option a -> r # gmapQ :: (forall d. Data d => d -> u) -> Option a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Option a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) #
Semigroup a => Monoid (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Semigroup a => Semigroup (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (<>) :: Option a -> Option a -> Option a # sconcat :: NonEmpty (Option a) -> Option a # stimes :: Integral b => b -> Option a -> Option a #
Generic (Option a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Option a) :: Type -> Type # Methods from :: Option a -> Rep (Option a) x # to :: Rep (Option a) x -> Option a #
Read a => Read (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods readsPrec :: Int -> ReadS (Option a) # readList :: ReadS [Option a] # readPrec :: ReadPrec (Option a) # readListPrec :: ReadPrec [Option a] #
Show a => Show (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods showsPrec :: Int -> Option a -> ShowS # show :: Option a -> String # showList :: [Option a] -> ShowS #
NFData a => NFData (Option a)	Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: Option a -> () #
Eq a => Eq (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods (==) :: Option a -> Option a -> Bool # (/=) :: Option a -> Option a -> Bool #
Ord a => Ord (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods compare :: Option a -> Option a -> Ordering # (<) :: Option a -> Option a -> Bool # (<=) :: Option a -> Option a -> Bool # (>) :: Option a -> Option a -> Bool # (>=) :: Option a -> Option a -> Bool # max :: Option a -> Option a -> Option a # min :: Option a -> Option a -> Option a #
Hashable a => Hashable (Option a)
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Option a -> Int # hash :: Option a -> Int #
Wrapped (Option a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Option a) # Methods _Wrapped' :: Iso' (Option a) (Unwrapped (Option a)) #
Generic1 Option
Instance details Defined in Data.Semigroup Associated Types type Rep1 Option :: k -> Type # Methods from1 :: forall (a :: k). Option a -> Rep1 Option a # to1 :: forall (a :: k). Rep1 Option a -> Option a #
t ~ Option b => Rewrapped (Option a) t
Instance details Defined in Control.Lens.Wrapped
type Rep (Option a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup type Rep (Option a) = D1 ('MetaData "Option" "Data.Semigroup" "base" 'True) (C1 ('MetaCons "Option" 'PrefixI 'True) (S1 ('MetaSel ('Just "getOption") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe a))))
type Unwrapped (Option a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Option a) = Maybe a
type Rep1 Option	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup type Rep1 Option = D1 ('MetaData "Option" "Data.Semigroup" "base" 'True) (C1 ('MetaCons "Option" 'PrefixI 'True) (S1 ('MetaSel ('Just "getOption") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Maybe)))

mtimesDefault :: (Integral b, Monoid a) => b -> a -> a #

Repeat a value n times.

mtimesDefault n a = a <> a <> ... <> a  -- using <> (n-1) times

Implemented using stimes and mempty.

This is a suitable definition for an mtimes member of Monoid.

cycle1 :: Semigroup m => m -> m #

A generalization of cycle to an arbitrary Semigroup. May fail to terminate for some values in some semigroups.

sortWith :: Ord b => (a -> b) -> [a] -> [a] #

The sortWith function sorts a list of elements using the user supplied function to project something out of each element

nonEmpty :: [a] -> Maybe (NonEmpty a) #

nonEmpty efficiently turns a normal list into a NonEmpty stream, producing Nothing if the input is empty.

showStackTrace :: IO (Maybe String) #

Get a string representation of the current execution stack state.

getStackTrace :: IO (Maybe [Location]) #

Get a trace of the current execution stack state.

Returns Nothing if stack trace support isn't available on host machine.

mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b) #

The mapAccumR function behaves like a combination of fmap and foldr; it applies a function to each element of a structure, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new structure.

Examples

Expand

Basic usage:

>>> mapAccumR (\a b -> (a + b, a)) 0 [1..10]
(55,[54,52,49,45,40,34,27,19,10,0])

>>> mapAccumR (\a b -> (a <> show b, a)) "0" [1..5]
("054321",["05432","0543","054","05","0"])

mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b) #

The mapAccumL function behaves like a combination of fmap and foldl; it applies a function to each element of a structure, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new structure.

Examples

Expand

Basic usage:

>>> mapAccumL (\a b -> (a + b, a)) 0 [1..10]
(55,[0,1,3,6,10,15,21,28,36,45])

>>> mapAccumL (\a b -> (a <> show b, a)) "0" [1..5]
("012345",["0","01","012","0123","01234"])

foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m #

This function may be used as a value for foldMap in a Foldable instance.

foldMapDefault f ≡ getConst . traverse (Const . f)

fmapDefault :: Traversable t => (a -> b) -> t a -> t b #

This function may be used as a value for fmap in a Functor instance, provided that traverse is defined. (Using fmapDefault with a Traversable instance defined only by sequenceA will result in infinite recursion.)

fmapDefault f ≡ runIdentity . traverse (Identity . f)

newtype ZipList a #

Lists, but with an Applicative functor based on zipping.

Constructors

ZipList
Fields getZipList :: [a]

Instances

Instances details

Foldable ZipList	Since: base-4.9.0.0
Instance details Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m # foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m # foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b # foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b # foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # toList :: ZipList a -> [a] # null :: ZipList a -> Bool # length :: ZipList a -> Int # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # sum :: Num a => ZipList a -> a # product :: Num a => ZipList a -> a #
Traversable ZipList	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) # sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) # mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) # sequence :: Monad m => ZipList (m a) -> m (ZipList a) #
Alternative ZipList	Since: base-4.11.0.0
Instance details Defined in Control.Applicative Methods empty :: ZipList a # (<\|>) :: ZipList a -> ZipList a -> ZipList a # some :: ZipList a -> ZipList [a] # many :: ZipList a -> ZipList [a] #
Applicative ZipList	f <$> ZipList xs1 <> ... <> ZipList xsN = ZipList (zipWithN f xs1 ... xsN) where `zipWithN` refers to the `zipWith` function of the appropriate arity (`zipWith`, `zipWith3`, `zipWith4`, ...). For example: (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <> ZipList "567" <> ZipList [1..] = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> ZipList a # (<>) :: ZipList (a -> b) -> ZipList a -> ZipList b # liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c # (>) :: ZipList a -> ZipList b -> ZipList b # (<*) :: ZipList a -> ZipList b -> ZipList a #
Functor ZipList	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
NFData1 ZipList	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> ZipList a -> () #
IsList (ZipList a)	Since: base-4.15.0.0
Instance details Defined in GHC.Exts Associated Types type Item (ZipList a) # Methods fromList :: [Item (ZipList a)] -> ZipList a # fromListN :: Int -> [Item (ZipList a)] -> ZipList a # toList :: ZipList a -> [Item (ZipList a)] #
Generic (ZipList a)
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type # Methods from :: ZipList a -> Rep (ZipList a) x # to :: Rep (ZipList a) x -> ZipList a #
Read a => Read (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods readsPrec :: Int -> ReadS (ZipList a) # readList :: ReadS [ZipList a] # readPrec :: ReadPrec (ZipList a) # readListPrec :: ReadPrec [ZipList a] #
Show a => Show (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods showsPrec :: Int -> ZipList a -> ShowS # show :: ZipList a -> String # showList :: [ZipList a] -> ShowS #
NFData a => NFData (ZipList a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: ZipList a -> () #
Eq a => Eq (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Ord a => Ord (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods compare :: ZipList a -> ZipList a -> Ordering # (<) :: ZipList a -> ZipList a -> Bool # (<=) :: ZipList a -> ZipList a -> Bool # (>) :: ZipList a -> ZipList a -> Bool # (>=) :: ZipList a -> ZipList a -> Bool # max :: ZipList a -> ZipList a -> ZipList a # min :: ZipList a -> ZipList a -> ZipList a #
Wrapped (ZipList a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ZipList a) # Methods _Wrapped' :: Iso' (ZipList a) (Unwrapped (ZipList a)) #
Container (ZipList a)
Instance details Defined in Universum.Container.Class Associated Types type Element (ZipList a) # Methods toList :: ZipList a -> [Element (ZipList a)] # null :: ZipList a -> Bool # foldr :: (Element (ZipList a) -> b -> b) -> b -> ZipList a -> b # foldl :: (b -> Element (ZipList a) -> b) -> b -> ZipList a -> b # foldl' :: (b -> Element (ZipList a) -> b) -> b -> ZipList a -> b # length :: ZipList a -> Int # elem :: Element (ZipList a) -> ZipList a -> Bool # foldMap :: Monoid m => (Element (ZipList a) -> m) -> ZipList a -> m # fold :: ZipList a -> Element (ZipList a) # foldr' :: (Element (ZipList a) -> b -> b) -> b -> ZipList a -> b # notElem :: Element (ZipList a) -> ZipList a -> Bool # all :: (Element (ZipList a) -> Bool) -> ZipList a -> Bool # any :: (Element (ZipList a) -> Bool) -> ZipList a -> Bool # and :: ZipList a -> Bool # or :: ZipList a -> Bool # find :: (Element (ZipList a) -> Bool) -> ZipList a -> Maybe (Element (ZipList a)) # safeHead :: ZipList a -> Maybe (Element (ZipList a)) # safeMaximum :: ZipList a -> Maybe (Element (ZipList a)) # safeMinimum :: ZipList a -> Maybe (Element (ZipList a)) # safeFoldr1 :: (Element (ZipList a) -> Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> Maybe (Element (ZipList a)) # safeFoldl1 :: (Element (ZipList a) -> Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> Maybe (Element (ZipList a)) #
FromList (ZipList a)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (ZipList a) # type FromListC (ZipList a) # Methods fromList :: [ListElement (ZipList a)] -> ZipList a #
Generic1 ZipList
Instance details Defined in Control.Applicative Associated Types type Rep1 ZipList :: k -> Type # Methods from1 :: forall (a :: k). ZipList a -> Rep1 ZipList a # to1 :: forall (a :: k). Rep1 ZipList a -> ZipList a #
t ~ ZipList b => Rewrapped (ZipList a) t
Instance details Defined in Control.Lens.Wrapped
type Item (ZipList a)
Instance details Defined in GHC.Exts type Item (ZipList a) = a
type Rep (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative type Rep (ZipList a) = D1 ('MetaData "ZipList" "Control.Applicative" "base" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a])))
type Unwrapped (ZipList a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (ZipList a) = [a]
type Element (ZipList a)
Instance details Defined in Universum.Container.Class type Element (ZipList a) = ElementDefault (ZipList a)
type FromListC (ZipList a)
Instance details Defined in Universum.Container.Class type FromListC (ZipList a) = ()
type ListElement (ZipList a)
Instance details Defined in Universum.Container.Class type ListElement (ZipList a) = a
type Rep1 ZipList	Since: base-4.7.0.0
Instance details Defined in Control.Applicative type Rep1 ZipList = D1 ('MetaData "ZipList" "Control.Applicative" "base" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 [])))

(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c') infixr 3 #

Fanout: send the input to both argument arrows and combine their output.

The default definition may be overridden with a more efficient version if desired.

stdin :: Handle #

stderr :: Handle #

data TVar a #

Shared memory locations that support atomic memory transactions.

Instances

Instances details

Eq (TVar a)	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods (==) :: TVar a -> TVar a -> Bool # (/=) :: TVar a -> TVar a -> Bool #

data STM a #

A monad supporting atomic memory transactions.

Instances

Instances details

Alternative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods empty :: STM a # (<\|>) :: STM a -> STM a -> STM a # some :: STM a -> STM [a] # many :: STM a -> STM [a] #
Applicative STM	Since: base-4.8.0.0
Instance details Defined in GHC.Conc.Sync Methods pure :: a -> STM a # (<>) :: STM (a -> b) -> STM a -> STM b # liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c # (>) :: STM a -> STM b -> STM b # (<*) :: STM a -> STM b -> STM a #
Functor STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods fmap :: (a -> b) -> STM a -> STM b # (<$) :: a -> STM b -> STM a #
Monad STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods (>>=) :: STM a -> (a -> STM b) -> STM b # (>>) :: STM a -> STM b -> STM b # return :: a -> STM a #
MonadPlus STM	Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods mzero :: STM a # mplus :: STM a -> STM a -> STM a #
MonadCatch STM
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => STM a -> (e -> STM a) -> STM a #
MonadThrow STM
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> STM a #
RandomGen g => FrozenGen (TGen g) STM	Since: random-1.2.1
Instance details Defined in System.Random.Stateful Associated Types type MutableGen (TGen g) STM = (g :: Type) # Methods freezeGen :: MutableGen (TGen g) STM -> STM (TGen g) # thawGen :: TGen g -> STM (MutableGen (TGen g) STM) #
RandomGen g => StatefulGen (TGenM g) STM	Since: random-1.2.1
Instance details Defined in System.Random.Stateful Methods uniformWord32R :: Word32 -> TGenM g -> STM Word32 # uniformWord64R :: Word64 -> TGenM g -> STM Word64 # uniformWord8 :: TGenM g -> STM Word8 # uniformWord16 :: TGenM g -> STM Word16 # uniformWord32 :: TGenM g -> STM Word32 # uniformWord64 :: TGenM g -> STM Word64 # uniformShortByteString :: Int -> TGenM g -> STM ShortByteString #
RandomGen r => RandomGenM (TGenM r) r STM
Instance details Defined in System.Random.Stateful Methods applyRandomGenM :: (r -> (a, r)) -> TGenM r -> STM a #
type MutableGen (TGen g) STM
Instance details Defined in System.Random.Stateful type MutableGen (TGen g) STM = TGenM g

writeTVar :: TVar a -> a -> STM () #

Write the supplied value into a TVar.

readTVar :: TVar a -> STM a #

Return the current value stored in a TVar.

newTVar :: a -> STM (TVar a) #

Create a new TVar holding a value supplied

data IORef a #

A mutable variable in the IO monad

Instances

Instances details

NFData1 IORef	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> IORef a -> () #
NFData (IORef a)	NOTE: Only strict in the reference and not the referenced value. Since: deepseq-1.4.2.0
Instance details Defined in Control.DeepSeq Methods rnf :: IORef a -> () #
Eq (IORef a)	Pointer equality. Since: base-4.0.0.0
Instance details Defined in GHC.IORef Methods (==) :: IORef a -> IORef a -> Bool # (/=) :: IORef a -> IORef a -> Bool #

prettySrcLoc :: SrcLoc -> String #

Pretty print a SrcLoc.

Since: base-4.9.0.0

foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b #

Right-to-left monadic fold over the elements of a structure.

Given a structure t with elements (a, b, c, ..., x, y), the result of a fold with an operator function f is equivalent to:

foldrM f z t = do
    yy <- f y z
    xx <- f x yy
    ...
    bb <- f b cc
    aa <- f a bb
    return aa -- Just @return z@ when the structure is empty

For a Monad m, given two functions f1 :: a -> m b and f2 :: b -> m c, their Kleisli composition (f1 >=> f2) :: a -> m c is defined by:

(f1 >=> f2) a = f1 a >>= f2

Another way of thinking about foldrM is that it amounts to an application to z of a Kleisli composition:

foldrM f z t = f y >=> f x >=> ... >=> f b >=> f a $ z

The monadic effects of foldrM are sequenced from right to left, and e.g. folds of infinite lists will diverge.

If at some step the bind operator (>>=) short-circuits (as with, e.g., mzero in a MonadPlus), the evaluated effects will be from a tail of the element sequence. If you want to evaluate the monadic effects in left-to-right order, or perhaps be able to short-circuit after an initial sequence of elements, you'll need to use foldlM instead.

If the monadic effects don't short-circuit, the outermost application of f is to the leftmost element a, so that, ignoring effects, the result looks like a right fold:

a `f` (b `f` (c `f` (... (x `f` (y `f` z))))).

Examples

Expand

Basic usage:

>>> let f i acc = do { print i ; return $ i : acc }
>>> foldrM f [] [0..3]
3
2
1
0
[0,1,2,3]

foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #

Left-to-right monadic fold over the elements of a structure.

Given a structure t with elements (a, b, ..., w, x, y), the result of a fold with an operator function f is equivalent to:

foldlM f z t = do
    aa <- f z a
    bb <- f aa b
    ...
    xx <- f ww x
    yy <- f xx y
    return yy -- Just @return z@ when the structure is empty

For a Monad m, given two functions f1 :: a -> m b and f2 :: b -> m c, their Kleisli composition (f1 >=> f2) :: a -> m c is defined by:

(f1 >=> f2) a = f1 a >>= f2

Another way of thinking about foldlM is that it amounts to an application to z of a Kleisli composition:

foldlM f z t =
    flip f a >=> flip f b >=> ... >=> flip f x >=> flip f y $ z

The monadic effects of foldlM are sequenced from left to right.

If at some step the bind operator (>>=) short-circuits (as with, e.g., mzero in a MonadPlus), the evaluated effects will be from an initial segment of the element sequence. If you want to evaluate the monadic effects in right-to-left order, or perhaps be able to short-circuit after processing a tail of the sequence of elements, you'll need to use foldrM instead.

If the monadic effects don't short-circuit, the outermost application of f is to the rightmost element y, so that, ignoring effects, the result looks like a left fold:

((((z `f` a) `f` b) ... `f` w) `f` x) `f` y

Examples

Expand

Basic usage:

>>> let f a e = do { print e ; return $ e : a }
>>> foldlM f [] [0..3]
0
1
2
3
[3,2,1,0]

transpose :: [[a]] -> [[a]] #

The transpose function transposes the rows and columns of its argument. For example,

>>> transpose [[1,2,3],[4,5,6]]
[[1,4],[2,5],[3,6]]

If some of the rows are shorter than the following rows, their elements are skipped:

>>> transpose [[10,11],[20],[],[30,31,32]]
[[10,20,30],[11,31],[32]]

tails :: [a] -> [[a]] #

$\mathcal{O}(n)$. The tails function returns all final segments of the argument, longest first. For example,

>>> tails "abc"
["abc","bc","c",""]

Note that tails has the following strictness property: tails _|_ = _|_ : _|_

subsequences :: [a] -> [[a]] #

The subsequences function returns the list of all subsequences of the argument.

>>> subsequences "abc"
["","a","b","ab","c","ac","bc","abc"]

sortOn :: Ord b => (a -> b) -> [a] -> [a] #

Sort a list by comparing the results of a key function applied to each element. sortOn f is equivalent to sortBy (comparing f), but has the performance advantage of only evaluating f once for each element in the input list. This is called the decorate-sort-undecorate paradigm, or Schwartzian transform.

Elements are arranged from lowest to highest, keeping duplicates in the order they appeared in the input.

>>> sortOn fst [(2, "world"), (4, "!"), (1, "Hello")]
[(1,"Hello"),(2,"world"),(4,"!")]

Since: base-4.8.0.0

permutations :: [a] -> [[a]] #

The permutations function returns the list of all permutations of the argument.

>>> permutations "abc"
["abc","bac","cba","bca","cab","acb"]

inits :: [a] -> [[a]] #

The inits function returns all initial segments of the argument, shortest first. For example,

>>> inits "abc"
["","a","ab","abc"]

Note that inits has the following strictness property: inits (xs ++ _|_) = inits xs ++ _|_

In particular, inits _|_ = [] : _|_

group :: Eq a => [a] -> [[a]] #

The group function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example,

>>> group "Mississippi"
["M","i","ss","i","ss","i","pp","i"]

It is a special case of groupBy, which allows the programmer to supply their own equality test.

genericTake :: Integral i => i -> [a] -> [a] #

The genericTake function is an overloaded version of take, which accepts any Integral value as the number of elements to take.

genericSplitAt :: Integral i => i -> [a] -> ([a], [a]) #

The genericSplitAt function is an overloaded version of splitAt, which accepts any Integral value as the position at which to split.

genericReplicate :: Integral i => i -> a -> [a] #

The genericReplicate function is an overloaded version of replicate, which accepts any Integral value as the number of repetitions to make.

genericLength :: Num i => [a] -> i #

$\mathcal{O}(n)$. The genericLength function is an overloaded version of length. In particular, instead of returning an Int, it returns any type which is an instance of Num. It is, however, less efficient than length.

>>> genericLength [1, 2, 3] :: Int
3
>>> genericLength [1, 2, 3] :: Float
3.0

genericDrop :: Integral i => i -> [a] -> [a] #

The genericDrop function is an overloaded version of drop, which accepts any Integral value as the number of elements to drop.

newtype Last a #

Maybe monoid returning the rightmost non-Nothing value.

Last a is isomorphic to Dual (First a), and thus to Dual (Alt Maybe a)

>>> getLast (Last (Just "hello") <> Last Nothing <> Last (Just "world"))
Just "world"

Constructors

Last
Fields getLast :: Maybe a

Instances

Instances details

Foldable Last	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] # null :: Last a -> Bool # length :: Last a -> Int # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # minimum :: Ord a => Last a -> a # sum :: Num a => Last a -> a # product :: Num a => Last a -> a #
Traversable Last	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) # sequence :: Monad m => Last (m a) -> m (Last a) #
Applicative Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> Last a # (<>) :: Last (a -> b) -> Last a -> Last b # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c # (>) :: Last a -> Last b -> Last b # (<*) :: Last a -> Last b -> Last a #
Functor Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Monad Last	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a #
NFData1 Last	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Last a -> () #
PFoldable Last
Instance details Defined in Data.Foldable.Singletons Associated Types type Fold arg :: m # type FoldMap arg arg1 :: m # type Foldr arg arg1 arg2 :: b # type Foldr' arg arg1 arg2 :: b # type Foldl arg arg1 arg2 :: b # type Foldl' arg arg1 arg2 :: b # type Foldr1 arg arg1 :: a # type Foldl1 arg arg1 :: a # type ToList arg :: [a] # type Null arg :: Bool # type Length arg :: Nat # type Elem arg arg1 :: Bool # type Maximum arg :: a # type Minimum arg :: a # type Sum arg :: a # type Product arg :: a #
SFoldable Last
Instance details Defined in Data.Foldable.Singletons Methods sFold :: forall m (t1 :: Last m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a m (t1 :: a ~> m) (t2 :: Last a). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Last a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Last a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Last a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Last a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Last a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Last a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a (t1 :: Last a). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a (t1 :: Last a). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a (t1 :: Last a). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a (t1 :: a) (t2 :: Last a). SEq a => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a (t1 :: Last a). SOrd a => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a (t1 :: Last a). SOrd a => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a (t1 :: Last a). SNum a => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a (t1 :: Last a). SNum a => Sing t1 -> Sing (Apply ProductSym0 t1) #
PTraversable Last
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable Last
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: Last a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: Last (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: Last a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: Last (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) #
Monoid (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Semigroup (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Monoid Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Generic (Last a)
Instance details Defined in Data.Monoid Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Read a => Read (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS (Last a) # readList :: ReadS [Last a] # readPrec :: ReadPrec (Last a) # readListPrec :: ReadPrec [Last a] #
Show a => Show (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Default (Last a)
Instance details Defined in Data.Default.Class Methods def :: Last a #
NFData a => NFData (Last a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Last a -> () #
Eq a => Eq (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Ord a => Ord (Last a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods compare :: Last a -> Last a -> Ordering # (<) :: Last a -> Last a -> Bool # (<=) :: Last a -> Last a -> Bool # (>) :: Last a -> Last a -> Bool # (>=) :: Last a -> Last a -> Bool # max :: Last a -> Last a -> Last a # min :: Last a -> Last a -> Last a #
Wrapped (Last a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Last a) # Methods _Wrapped' :: Iso' (Last a) (Unwrapped (Last a)) #
PMonoid (Last a)
Instance details Defined in Data.Monoid.Singletons Associated Types type Mempty :: a # type Mappend arg arg1 :: a # type Mconcat arg :: a #
SMonoid (Last a)
Instance details Defined in Data.Monoid.Singletons Methods sMempty :: Sing MemptySym0 # sMappend :: forall (t1 :: Last a) (t2 :: Last a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MappendSym0 t1) t2) # sMconcat :: forall (t :: [Last a]). Sing t -> Sing (Apply MconcatSym0 t) #
Container (Last a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Last a) # Methods toList :: Last a -> [Element (Last a)] # null :: Last a -> Bool # foldr :: (Element (Last a) -> b -> b) -> b -> Last a -> b # foldl :: (b -> Element (Last a) -> b) -> b -> Last a -> b # foldl' :: (b -> Element (Last a) -> b) -> b -> Last a -> b # length :: Last a -> Int # elem :: Element (Last a) -> Last a -> Bool # foldMap :: Monoid m => (Element (Last a) -> m) -> Last a -> m # fold :: Last a -> Element (Last a) # foldr' :: (Element (Last a) -> b -> b) -> b -> Last a -> b # notElem :: Element (Last a) -> Last a -> Bool # all :: (Element (Last a) -> Bool) -> Last a -> Bool # any :: (Element (Last a) -> Bool) -> Last a -> Bool # and :: Last a -> Bool # or :: Last a -> Bool # find :: (Element (Last a) -> Bool) -> Last a -> Maybe (Element (Last a)) # safeHead :: Last a -> Maybe (Element (Last a)) # safeMaximum :: Last a -> Maybe (Element (Last a)) # safeMinimum :: Last a -> Maybe (Element (Last a)) # safeFoldr1 :: (Element (Last a) -> Element (Last a) -> Element (Last a)) -> Last a -> Maybe (Element (Last a)) # safeFoldl1 :: (Element (Last a) -> Element (Last a) -> Element (Last a)) -> Last a -> Maybe (Element (Last a)) #
Generic1 Last
Instance details Defined in Data.Monoid Associated Types type Rep1 Last :: k -> Type # Methods from1 :: forall (a :: k). Last a -> Rep1 Last a # to1 :: forall (a :: k). Rep1 Last a -> Last a #
t ~ Last b => Rewrapped (Last a) t
Instance details Defined in Control.Lens.Wrapped
IsoHKD Last (a :: Type)
Instance details Defined in Data.Vinyl.XRec Associated Types type HKD Last a # Methods unHKD :: HKD Last a -> Last a # toHKD :: Last a -> HKD Last a #
SDecide (Maybe a) => TestCoercion (SLast :: Last a -> Type)
Instance details Defined in Data.Monoid.Singletons Methods testCoercion :: forall (a0 :: k) (b :: k). SLast a0 -> SLast b -> Maybe (Coercion a0 b) #
SDecide (Maybe a) => TestEquality (SLast :: Last a -> Type)
Instance details Defined in Data.Monoid.Singletons Methods testEquality :: forall (a0 :: k) (b :: k). SLast a0 -> SLast b -> Maybe (a0 :~: b) #
SingI (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing GetLastSym0 #
SingI (LastSym0 :: TyFun (Maybe a) (Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing LastSym0 #
SuppressUnusedWarnings (TFHelper_6989586621680118720Sym0 :: TyFun (Last a) (Last a ~> Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680111341Sym0 :: TyFun (Last a) (Last a ~> Ordering) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680109684Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (LastSym0 :: TyFun (Maybe a) (Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680113571Sym0 :: TyFun Nat (Last a ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680118729BSym0 :: TyFun a (Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621680118656Sym0 :: TyFun a (Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118666Sym0 :: TyFun (Last (a ~> b)) (Last a ~> Last b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118720Sym1 a6989586621680118725 :: TyFun (Last a) (Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680111341Sym1 a6989586621680111346 :: TyFun (Last a) Ordering -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118699Sym0 :: TyFun (Last a) ((a ~> Last b) ~> Last b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680113571Sym1 a6989586621680113579 :: TyFun (Last a) (Symbol ~> Symbol) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680109684Sym1 a6989586621680109689 :: TyFun (Last a) Bool -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680296714Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Last a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621680118677Sym0 :: TyFun (a ~> b) (Last a ~> Last b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680296702Sym0 :: TyFun (a ~> m) (Last a ~> m) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118688Sym0 :: TyFun a (Last b ~> Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621680118677Sym1 a6989586621680118682 :: TyFun (Last a) (Last b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118666Sym1 a6989586621680118671 :: TyFun (Last a) (Last b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680296702Sym1 a6989586621680296707 :: TyFun (Last a) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118688Sym1 a6989586621680118693 :: TyFun (Last b) (Last a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118699Sym1 a6989586621680118704 :: TyFun (a ~> Last b) (Last b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478813Sym0 :: TyFun (a ~> f b) (Last a ~> f (Last b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680296714Sym1 a6989586621680296720 :: TyFun b (Last a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680118708Sym0 :: TyFun k (TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680296714Sym2 a6989586621680296720 a6989586621680296721 :: TyFun (Last a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478813Sym1 a6989586621680478818 :: TyFun (Last a) (f (Last b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680118708Sym1 a6989586621680118706 :: TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
type Pure (a :: k1)
Instance details Defined in Data.Monoid.Singletons type Pure (a :: k1) = Apply (Pure_6989586621680118656Sym0 :: TyFun k1 (Last k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Data.Monoid.Singletons type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (Last a) -> Type) arg
type Fold (arg :: Last m)
Instance details Defined in Data.Foldable.Singletons type Fold (arg :: Last m) = Apply (Fold_6989586621680193565Sym0 :: TyFun (Last m) m -> Type) arg
type Length (arg :: Last a)
Instance details Defined in Data.Foldable.Singletons type Length (arg :: Last a) = Apply (Length_6989586621680193731Sym0 :: TyFun (Last a) Nat -> Type) arg
type Maximum (arg :: Last a)
Instance details Defined in Data.Foldable.Singletons type Maximum (arg :: Last a) = Apply (Maximum_6989586621680193764Sym0 :: TyFun (Last a) a -> Type) arg
type Minimum (arg :: Last a)
Instance details Defined in Data.Foldable.Singletons type Minimum (arg :: Last a) = Apply (Minimum_6989586621680193779Sym0 :: TyFun (Last a) a -> Type) arg
type Null (arg :: Last a)
Instance details Defined in Data.Foldable.Singletons type Null (arg :: Last a) = Apply (Null_6989586621680193714Sym0 :: TyFun (Last a) Bool -> Type) arg
type Product (arg :: Last a)
Instance details Defined in Data.Foldable.Singletons type Product (arg :: Last a) = Apply (Product_6989586621680193803Sym0 :: TyFun (Last a) a -> Type) arg
type Sum (arg :: Last a)
Instance details Defined in Data.Foldable.Singletons type Sum (arg :: Last a) = Apply (Sum_6989586621680193794Sym0 :: TyFun (Last a) a -> Type) arg
type ToList (arg :: Last a)
Instance details Defined in Data.Foldable.Singletons type ToList (arg :: Last a) = Apply (ToList_6989586621680193705Sym0 :: TyFun (Last a) [a] -> Type) arg
type Elem (arg1 :: a) (arg2 :: Last a)
Instance details Defined in Data.Foldable.Singletons type Elem (arg1 :: a) (arg2 :: Last a) = Apply (Apply (Elem_6989586621680193750Sym0 :: TyFun a (Last a ~> Bool) -> Type) arg1) arg2
type Foldl1 (arg1 :: a ~> (a ~> a)) (arg2 :: Last a)
Instance details Defined in Data.Foldable.Singletons type Foldl1 (arg1 :: a ~> (a ~> a)) (arg2 :: Last a) = Apply (Apply (Foldl1_6989586621680193685Sym0 :: TyFun (a ~> (a ~> a)) (Last a ~> a) -> Type) arg1) arg2
type Foldr1 (arg1 :: a ~> (a ~> a)) (arg2 :: Last a)
Instance details Defined in Data.Foldable.Singletons type Foldr1 (arg1 :: a ~> (a ~> a)) (arg2 :: Last a) = Apply (Apply (Foldr1_6989586621680193664Sym0 :: TyFun (a ~> (a ~> a)) (Last a ~> a) -> Type) arg1) arg2
type Sequence (arg :: Last (m a))
Instance details Defined in Data.Traversable.Singletons type Sequence (arg :: Last (m a)) = Apply (Sequence_6989586621680471117Sym0 :: TyFun (Last (m a)) (m (Last a)) -> Type) arg
type SequenceA (arg :: Last (f a))
Instance details Defined in Data.Traversable.Singletons type SequenceA (arg :: Last (f a)) = Apply (SequenceA_6989586621680471093Sym0 :: TyFun (Last (f a)) (f (Last a)) -> Type) arg
type (arg :: Last a) *> (arg1 :: Last b)
Instance details Defined in Data.Monoid.Singletons type (arg :: Last a) *> (arg1 :: Last b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (Last a) (Last b ~> Last b) -> Type) arg) arg1
type (a1 :: k1) <$ (a2 :: Last b)
Instance details Defined in Data.Monoid.Singletons type (a1 :: k1) <$ (a2 :: Last b) = Apply (Apply (TFHelper_6989586621680118688Sym0 :: TyFun k1 (Last b ~> Last k1) -> Type) a1) a2
type (arg :: Last a) <* (arg1 :: Last b)
Instance details Defined in Data.Monoid.Singletons type (arg :: Last a) <* (arg1 :: Last b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (Last a) (Last b ~> Last a) -> Type) arg) arg1
type (a2 :: Last (a1 ~> b)) <*> (a3 :: Last a1)
Instance details Defined in Data.Monoid.Singletons type (a2 :: Last (a1 ~> b)) <*> (a3 :: Last a1) = Apply (Apply (TFHelper_6989586621680118666Sym0 :: TyFun (Last (a1 ~> b)) (Last a1 ~> Last b) -> Type) a2) a3
type (arg :: Last a) >> (arg1 :: Last b)
Instance details Defined in Data.Monoid.Singletons type (arg :: Last a) >> (arg1 :: Last b) = Apply (Apply (TFHelper_6989586621679287148Sym0 :: TyFun (Last a) (Last b ~> Last b) -> Type) arg) arg1
type (a2 :: Last a1) >>= (a3 :: a1 ~> Last b)
Instance details Defined in Data.Monoid.Singletons type (a2 :: Last a1) >>= (a3 :: a1 ~> Last b) = Apply (Apply (TFHelper_6989586621680118699Sym0 :: TyFun (Last a1) ((a1 ~> Last b) ~> Last b) -> Type) a2) a3
type Fmap (a2 :: a1 ~> b) (a3 :: Last a1)
Instance details Defined in Data.Monoid.Singletons type Fmap (a2 :: a1 ~> b) (a3 :: Last a1) = Apply (Apply (Fmap_6989586621680118677Sym0 :: TyFun (a1 ~> b) (Last a1 ~> Last b) -> Type) a2) a3
type FoldMap (a2 :: a1 ~> k2) (a3 :: Last a1)
Instance details Defined in Data.Foldable.Singletons type FoldMap (a2 :: a1 ~> k2) (a3 :: Last a1) = Apply (Apply (FoldMap_6989586621680296702Sym0 :: TyFun (a1 ~> k2) (Last a1 ~> k2) -> Type) a2) a3
type Foldl (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: Last a)
Instance details Defined in Data.Foldable.Singletons type Foldl (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: Last a) = Apply (Apply (Apply (Foldl_6989586621680193627Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Last a ~> b)) -> Type) arg1) arg2) arg3
type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: Last a)
Instance details Defined in Data.Foldable.Singletons type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: Last a) = Apply (Apply (Apply (Foldl'_6989586621680193642Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Last a ~> b)) -> Type) arg1) arg2) arg3
type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Last a1)
Instance details Defined in Data.Foldable.Singletons type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Last a1) = Apply (Apply (Apply (Foldr_6989586621680296714Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Last a1 ~> k2)) -> Type) a2) a3) a4
type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: Last a)
Instance details Defined in Data.Foldable.Singletons type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: Last a) = Apply (Apply (Apply (Foldr'_6989586621680193604Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Last a ~> b)) -> Type) arg1) arg2) arg3
type MapM (arg1 :: a ~> m b) (arg2 :: Last a)
Instance details Defined in Data.Traversable.Singletons type MapM (arg1 :: a ~> m b) (arg2 :: Last a) = Apply (Apply (MapM_6989586621680471103Sym0 :: TyFun (a ~> m b) (Last a ~> m (Last b)) -> Type) arg1) arg2
type Traverse (a2 :: a1 ~> f b) (a3 :: Last a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a2 :: a1 ~> f b) (a3 :: Last a1) = Apply (Apply (Traverse_6989586621680478813Sym0 :: TyFun (a1 ~> f b) (Last a1 ~> f (Last b)) -> Type) a2) a3
type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Last a) (arg2 :: Last b)
Instance details Defined in Data.Monoid.Singletons type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Last a) (arg2 :: Last b) = Apply (Apply (Apply (LiftA2_6989586621679287093Sym0 :: TyFun (a ~> (b ~> c)) (Last a ~> (Last b ~> Last c)) -> Type) arg) arg1) arg2
type Apply (Let6989586621680118729BSym0 :: TyFun a (Last a) -> Type) (wild_69895866216801179256989586621680118728 :: a)
Instance details Defined in Data.Monoid.Singletons type Apply (Let6989586621680118729BSym0 :: TyFun a (Last a) -> Type) (wild_69895866216801179256989586621680118728 :: a) = Let6989586621680118729B wild_69895866216801179256989586621680118728
type Apply (Pure_6989586621680118656Sym0 :: TyFun a (Last a) -> Type) (a6989586621680118662 :: a)
Instance details Defined in Data.Monoid.Singletons type Apply (Pure_6989586621680118656Sym0 :: TyFun a (Last a) -> Type) (a6989586621680118662 :: a) = Pure_6989586621680118656 a6989586621680118662
type Apply (ShowsPrec_6989586621680113571Sym0 :: TyFun Nat (Last a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680113579 :: Nat)
Instance details Defined in Data.Monoid.Singletons type Apply (ShowsPrec_6989586621680113571Sym0 :: TyFun Nat (Last a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680113579 :: Nat) = ShowsPrec_6989586621680113571Sym1 a6989586621680113579 :: TyFun (Last a) (Symbol ~> Symbol) -> Type
type Apply (TFHelper_6989586621680118688Sym0 :: TyFun a (Last b ~> Last a) -> Type) (a6989586621680118693 :: a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118688Sym0 :: TyFun a (Last b ~> Last a) -> Type) (a6989586621680118693 :: a) = TFHelper_6989586621680118688Sym1 a6989586621680118693 :: TyFun (Last b) (Last a) -> Type
type Apply (Foldr_6989586621680296714Sym1 a6989586621680296720 :: TyFun b (Last a ~> b) -> Type) (a6989586621680296721 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680296714Sym1 a6989586621680296720 :: TyFun b (Last a ~> b) -> Type) (a6989586621680296721 :: b) = Foldr_6989586621680296714Sym2 a6989586621680296720 a6989586621680296721
type Apply (Lambda_6989586621680118708Sym0 :: TyFun k (TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) (a6989586621680118706 :: k)
Instance details Defined in Data.Monoid.Singletons type Apply (Lambda_6989586621680118708Sym0 :: TyFun k (TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) (a6989586621680118706 :: k) = Lambda_6989586621680118708Sym1 a6989586621680118706 :: TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type
type Rep (Last a)	Since: base-4.7.0.0
Instance details Defined in Data.Monoid type Rep (Last a) = D1 ('MetaData "Last" "Data.Monoid" "base" 'True) (C1 ('MetaCons "Last" 'PrefixI 'True) (S1 ('MetaSel ('Just "getLast") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe a))))
type Unwrapped (Last a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Last a) = Maybe a
type Demote (Last a)
Instance details Defined in Data.Monoid.Singletons type Demote (Last a) = Last (Demote a)
type Sing
Instance details Defined in Data.Monoid.Singletons type Sing = SLast :: Last a -> Type
type Mempty
Instance details Defined in Data.Monoid.Singletons type Mempty = Mempty_6989586621680118731Sym0 :: Last a
type Element (Last a)
Instance details Defined in Universum.Container.Class type Element (Last a) = ElementDefault (Last a)
type Rep1 Last	Since: base-4.7.0.0
Instance details Defined in Data.Monoid type Rep1 Last = D1 ('MetaData "Last" "Data.Monoid" "base" 'True) (C1 ('MetaCons "Last" 'PrefixI 'True) (S1 ('MetaSel ('Just "getLast") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Maybe)))
type Mconcat (arg :: [Last a])
Instance details Defined in Data.Monoid.Singletons type Mconcat (arg :: [Last a]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [Last a] (Last a) -> Type) arg
type Sconcat (arg :: NonEmpty (Last a))
Instance details Defined in Data.Monoid.Singletons type Sconcat (arg :: NonEmpty (Last a)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (Last a)) (Last a) -> Type) arg
type Show_ (arg :: Last a)
Instance details Defined in Data.Monoid.Singletons type Show_ (arg :: Last a) = Apply (Show__6989586621680047550Sym0 :: TyFun (Last a) Symbol -> Type) arg
type (arg :: Last a) /= (arg1 :: Last a)
Instance details Defined in Data.Monoid.Singletons type (arg :: Last a) /= (arg1 :: Last a) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) arg) arg1
type (a2 :: Last a1) == (a3 :: Last a1)
Instance details Defined in Data.Monoid.Singletons type (a2 :: Last a1) == (a3 :: Last a1) = Apply (Apply (TFHelper_6989586621680109684Sym0 :: TyFun (Last a1) (Last a1 ~> Bool) -> Type) a2) a3
type Mappend (arg1 :: Last a) (arg2 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Mappend (arg1 :: Last a) (arg2 :: Last a) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (Last a) (Last a ~> Last a) -> Type) arg1) arg2
type (arg :: Last a) < (arg1 :: Last a)
Instance details Defined in Data.Monoid.Singletons type (arg :: Last a) < (arg1 :: Last a) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) arg) arg1
type (arg :: Last a) <= (arg1 :: Last a)
Instance details Defined in Data.Monoid.Singletons type (arg :: Last a) <= (arg1 :: Last a) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) arg) arg1
type (arg :: Last a) > (arg1 :: Last a)
Instance details Defined in Data.Monoid.Singletons type (arg :: Last a) > (arg1 :: Last a) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) arg) arg1
type (arg :: Last a) >= (arg1 :: Last a)
Instance details Defined in Data.Monoid.Singletons type (arg :: Last a) >= (arg1 :: Last a) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) arg) arg1
type Compare (a2 :: Last a1) (a3 :: Last a1)
Instance details Defined in Data.Monoid.Singletons type Compare (a2 :: Last a1) (a3 :: Last a1) = Apply (Apply (Compare_6989586621680111341Sym0 :: TyFun (Last a1) (Last a1 ~> Ordering) -> Type) a2) a3
type Max (arg :: Last a) (arg1 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Max (arg :: Last a) (arg1 :: Last a) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (Last a) (Last a ~> Last a) -> Type) arg) arg1
type Min (arg :: Last a) (arg1 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Min (arg :: Last a) (arg1 :: Last a) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (Last a) (Last a ~> Last a) -> Type) arg) arg1
type (a2 :: Last a1) <> (a3 :: Last a1)
Instance details Defined in Data.Monoid.Singletons type (a2 :: Last a1) <> (a3 :: Last a1) = Apply (Apply (TFHelper_6989586621680118720Sym0 :: TyFun (Last a1) (Last a1 ~> Last a1) -> Type) a2) a3
type ShowList (arg :: [Last a]) arg1
Instance details Defined in Data.Monoid.Singletons type ShowList (arg :: [Last a]) arg1 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Last a] (Symbol ~> Symbol) -> Type) arg) arg1
type HKD Last (a :: Type)
Instance details Defined in Data.Vinyl.XRec type HKD Last (a :: Type) = Last a
type ShowsPrec a2 (a3 :: Last a1) a4
Instance details Defined in Data.Monoid.Singletons type ShowsPrec a2 (a3 :: Last a1) a4 = Apply (Apply (Apply (ShowsPrec_6989586621680113571Sym0 :: TyFun Nat (Last a1 ~> (Symbol ~> Symbol)) -> Type) a2) a3) a4
type Apply (Compare_6989586621680111341Sym1 a6989586621680111346 :: TyFun (Last a) Ordering -> Type) (a6989586621680111347 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (Compare_6989586621680111341Sym1 a6989586621680111346 :: TyFun (Last a) Ordering -> Type) (a6989586621680111347 :: Last a) = Compare_6989586621680111341 a6989586621680111346 a6989586621680111347
type Apply (TFHelper_6989586621680109684Sym1 a6989586621680109689 :: TyFun (Last a) Bool -> Type) (a6989586621680109690 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680109684Sym1 a6989586621680109689 :: TyFun (Last a) Bool -> Type) (a6989586621680109690 :: Last a) = TFHelper_6989586621680109684 a6989586621680109689 a6989586621680109690
type Apply (FoldMap_6989586621680296702Sym1 a6989586621680296707 :: TyFun (Last a) m -> Type) (a6989586621680296708 :: Last a)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680296702Sym1 a6989586621680296707 :: TyFun (Last a) m -> Type) (a6989586621680296708 :: Last a) = FoldMap_6989586621680296702 a6989586621680296707 a6989586621680296708
type Apply (Foldr_6989586621680296714Sym2 a6989586621680296720 a6989586621680296721 :: TyFun (Last a) b -> Type) (a6989586621680296722 :: Last a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680296714Sym2 a6989586621680296720 a6989586621680296721 :: TyFun (Last a) b -> Type) (a6989586621680296722 :: Last a) = Foldr_6989586621680296714 a6989586621680296720 a6989586621680296721 a6989586621680296722
type Apply (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type) (a6989586621680108004 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (GetLastSym0 :: TyFun (Last a) (Maybe a) -> Type) (a6989586621680108004 :: Last a) = GetLast a6989586621680108004
type Apply (LastSym0 :: TyFun (Maybe a) (Last a) -> Type) (a6989586621680108001 :: Maybe a)
Instance details Defined in Data.Monoid.Singletons type Apply (LastSym0 :: TyFun (Maybe a) (Last a) -> Type) (a6989586621680108001 :: Maybe a) = 'Last a6989586621680108001
type Apply (TFHelper_6989586621680118720Sym1 a6989586621680118725 :: TyFun (Last a) (Last a) -> Type) (a6989586621680118726 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118720Sym1 a6989586621680118725 :: TyFun (Last a) (Last a) -> Type) (a6989586621680118726 :: Last a) = TFHelper_6989586621680118720 a6989586621680118725 a6989586621680118726
type Apply (Fmap_6989586621680118677Sym1 a6989586621680118682 :: TyFun (Last a) (Last b) -> Type) (a6989586621680118683 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (Fmap_6989586621680118677Sym1 a6989586621680118682 :: TyFun (Last a) (Last b) -> Type) (a6989586621680118683 :: Last a) = Fmap_6989586621680118677 a6989586621680118682 a6989586621680118683
type Apply (TFHelper_6989586621680118666Sym1 a6989586621680118671 :: TyFun (Last a) (Last b) -> Type) (a6989586621680118672 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118666Sym1 a6989586621680118671 :: TyFun (Last a) (Last b) -> Type) (a6989586621680118672 :: Last a) = TFHelper_6989586621680118666 a6989586621680118671 a6989586621680118672
type Apply (TFHelper_6989586621680118688Sym1 a6989586621680118693 :: TyFun (Last b) (Last a) -> Type) (a6989586621680118694 :: Last b)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118688Sym1 a6989586621680118693 :: TyFun (Last b) (Last a) -> Type) (a6989586621680118694 :: Last b) = TFHelper_6989586621680118688 a6989586621680118693 a6989586621680118694
type Apply (Traverse_6989586621680478813Sym1 a6989586621680478818 :: TyFun (Last a) (f (Last b)) -> Type) (a6989586621680478819 :: Last a)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478813Sym1 a6989586621680478818 :: TyFun (Last a) (f (Last b)) -> Type) (a6989586621680478819 :: Last a) = Traverse_6989586621680478813 a6989586621680478818 a6989586621680478819
type Apply (TFHelper_6989586621680118720Sym0 :: TyFun (Last a) (Last a ~> Last a) -> Type) (a6989586621680118725 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118720Sym0 :: TyFun (Last a) (Last a ~> Last a) -> Type) (a6989586621680118725 :: Last a) = TFHelper_6989586621680118720Sym1 a6989586621680118725
type Apply (Compare_6989586621680111341Sym0 :: TyFun (Last a) (Last a ~> Ordering) -> Type) (a6989586621680111346 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (Compare_6989586621680111341Sym0 :: TyFun (Last a) (Last a ~> Ordering) -> Type) (a6989586621680111346 :: Last a) = Compare_6989586621680111341Sym1 a6989586621680111346
type Apply (TFHelper_6989586621680109684Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) (a6989586621680109689 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680109684Sym0 :: TyFun (Last a) (Last a ~> Bool) -> Type) (a6989586621680109689 :: Last a) = TFHelper_6989586621680109684Sym1 a6989586621680109689
type Apply (TFHelper_6989586621680118666Sym0 :: TyFun (Last (a ~> b)) (Last a ~> Last b) -> Type) (a6989586621680118671 :: Last (a ~> b))
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118666Sym0 :: TyFun (Last (a ~> b)) (Last a ~> Last b) -> Type) (a6989586621680118671 :: Last (a ~> b)) = TFHelper_6989586621680118666Sym1 a6989586621680118671
type Apply (TFHelper_6989586621680118699Sym0 :: TyFun (Last a) ((a ~> Last b) ~> Last b) -> Type) (a6989586621680118704 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118699Sym0 :: TyFun (Last a) ((a ~> Last b) ~> Last b) -> Type) (a6989586621680118704 :: Last a) = TFHelper_6989586621680118699Sym1 a6989586621680118704 :: TyFun (a ~> Last b) (Last b) -> Type
type Apply (ShowsPrec_6989586621680113571Sym1 a6989586621680113579 :: TyFun (Last a) (Symbol ~> Symbol) -> Type) (a6989586621680113580 :: Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (ShowsPrec_6989586621680113571Sym1 a6989586621680113579 :: TyFun (Last a) (Symbol ~> Symbol) -> Type) (a6989586621680113580 :: Last a) = ShowsPrec_6989586621680113571Sym2 a6989586621680113579 a6989586621680113580
type Apply (TFHelper_6989586621680118699Sym1 a6989586621680118704 :: TyFun (a ~> Last b) (Last b) -> Type) (a6989586621680118705 :: a ~> Last b)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118699Sym1 a6989586621680118704 :: TyFun (a ~> Last b) (Last b) -> Type) (a6989586621680118705 :: a ~> Last b) = TFHelper_6989586621680118699 a6989586621680118704 a6989586621680118705
type Apply (Foldr_6989586621680296714Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Last a ~> b)) -> Type) (a6989586621680296720 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680296714Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Last a ~> b)) -> Type) (a6989586621680296720 :: a ~> (b ~> b)) = Foldr_6989586621680296714Sym1 a6989586621680296720
type Apply (Fmap_6989586621680118677Sym0 :: TyFun (a ~> b) (Last a ~> Last b) -> Type) (a6989586621680118682 :: a ~> b)
Instance details Defined in Data.Monoid.Singletons type Apply (Fmap_6989586621680118677Sym0 :: TyFun (a ~> b) (Last a ~> Last b) -> Type) (a6989586621680118682 :: a ~> b) = Fmap_6989586621680118677Sym1 a6989586621680118682
type Apply (FoldMap_6989586621680296702Sym0 :: TyFun (a ~> m) (Last a ~> m) -> Type) (a6989586621680296707 :: a ~> m)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680296702Sym0 :: TyFun (a ~> m) (Last a ~> m) -> Type) (a6989586621680296707 :: a ~> m) = FoldMap_6989586621680296702Sym1 a6989586621680296707
type Apply (Traverse_6989586621680478813Sym0 :: TyFun (a ~> f b) (Last a ~> f (Last b)) -> Type) (a6989586621680478818 :: a ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478813Sym0 :: TyFun (a ~> f b) (Last a ~> f (Last b)) -> Type) (a6989586621680478818 :: a ~> f b) = Traverse_6989586621680478813Sym1 a6989586621680478818
type Apply (Lambda_6989586621680118708Sym1 a6989586621680118706 :: TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) (k6989586621680118707 :: k1 ~> Last a)
Instance details Defined in Data.Monoid.Singletons type Apply (Lambda_6989586621680118708Sym1 a6989586621680118706 :: TyFun (k1 ~> Last a) (TyFun k1 (Maybe a) -> Type) -> Type) (k6989586621680118707 :: k1 ~> Last a) = Lambda_6989586621680118708Sym2 a6989586621680118706 k6989586621680118707

newtype First a #

Maybe monoid returning the leftmost non-Nothing value.

First a is isomorphic to Alt Maybe a, but precedes it historically.

>>> getFirst (First (Just "hello") <> First Nothing <> First (Just "world"))
Just "hello"

Constructors

First
Fields getFirst :: Maybe a

Instances

Instances details

Foldable First	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] # null :: First a -> Bool # length :: First a -> Int # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # sum :: Num a => First a -> a # product :: Num a => First a -> a #
Traversable First	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) # sequence :: Monad m => First (m a) -> m (First a) #
Applicative First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods pure :: a -> First a # (<>) :: First (a -> b) -> First a -> First b # liftA2 :: (a -> b -> c) -> First a -> First b -> First c # (>) :: First a -> First b -> First b # (<*) :: First a -> First b -> First a #
Functor First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Monad First	Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a #
NFData1 First	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> First a -> () #
PFoldable First
Instance details Defined in Data.Foldable.Singletons Associated Types type Fold arg :: m # type FoldMap arg arg1 :: m # type Foldr arg arg1 arg2 :: b # type Foldr' arg arg1 arg2 :: b # type Foldl arg arg1 arg2 :: b # type Foldl' arg arg1 arg2 :: b # type Foldr1 arg arg1 :: a # type Foldl1 arg arg1 :: a # type ToList arg :: [a] # type Null arg :: Bool # type Length arg :: Nat # type Elem arg arg1 :: Bool # type Maximum arg :: a # type Minimum arg :: a # type Sum arg :: a # type Product arg :: a #
SFoldable First
Instance details Defined in Data.Foldable.Singletons Methods sFold :: forall m (t1 :: First m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a m (t1 :: a ~> m) (t2 :: First a). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: First a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: First a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: First a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: First a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: First a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: First a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a (t1 :: First a). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a (t1 :: First a). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a (t1 :: First a). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a (t1 :: a) (t2 :: First a). SEq a => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a (t1 :: First a). SOrd a => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a (t1 :: First a). SOrd a => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a (t1 :: First a). SNum a => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a (t1 :: First a). SNum a => Sing t1 -> Sing (Apply ProductSym0 t1) #
PTraversable First
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable First
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: First a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: First (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: First a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: First (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) #
Monoid (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Semigroup (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Monoid Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Generic (First a)
Instance details Defined in Data.Monoid Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Read a => Read (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods readsPrec :: Int -> ReadS (First a) # readList :: ReadS [First a] # readPrec :: ReadPrec (First a) # readListPrec :: ReadPrec [First a] #
Show a => Show (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Default (First a)
Instance details Defined in Data.Default.Class Methods def :: First a #
NFData a => NFData (First a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: First a -> () #
Eq a => Eq (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Ord a => Ord (First a)	Since: base-2.1
Instance details Defined in Data.Monoid Methods compare :: First a -> First a -> Ordering # (<) :: First a -> First a -> Bool # (<=) :: First a -> First a -> Bool # (>) :: First a -> First a -> Bool # (>=) :: First a -> First a -> Bool # max :: First a -> First a -> First a # min :: First a -> First a -> First a #
Wrapped (First a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (First a) # Methods _Wrapped' :: Iso' (First a) (Unwrapped (First a)) #
PMonoid (First a)
Instance details Defined in Data.Monoid.Singletons Associated Types type Mempty :: a # type Mappend arg arg1 :: a # type Mconcat arg :: a #
SMonoid (First a)
Instance details Defined in Data.Monoid.Singletons Methods sMempty :: Sing MemptySym0 # sMappend :: forall (t1 :: First a) (t2 :: First a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MappendSym0 t1) t2) # sMconcat :: forall (t :: [First a]). Sing t -> Sing (Apply MconcatSym0 t) #
Container (First a)
Instance details Defined in Universum.Container.Class Associated Types type Element (First a) # Methods toList :: First a -> [Element (First a)] # null :: First a -> Bool # foldr :: (Element (First a) -> b -> b) -> b -> First a -> b # foldl :: (b -> Element (First a) -> b) -> b -> First a -> b # foldl' :: (b -> Element (First a) -> b) -> b -> First a -> b # length :: First a -> Int # elem :: Element (First a) -> First a -> Bool # foldMap :: Monoid m => (Element (First a) -> m) -> First a -> m # fold :: First a -> Element (First a) # foldr' :: (Element (First a) -> b -> b) -> b -> First a -> b # notElem :: Element (First a) -> First a -> Bool # all :: (Element (First a) -> Bool) -> First a -> Bool # any :: (Element (First a) -> Bool) -> First a -> Bool # and :: First a -> Bool # or :: First a -> Bool # find :: (Element (First a) -> Bool) -> First a -> Maybe (Element (First a)) # safeHead :: First a -> Maybe (Element (First a)) # safeMaximum :: First a -> Maybe (Element (First a)) # safeMinimum :: First a -> Maybe (Element (First a)) # safeFoldr1 :: (Element (First a) -> Element (First a) -> Element (First a)) -> First a -> Maybe (Element (First a)) # safeFoldl1 :: (Element (First a) -> Element (First a) -> Element (First a)) -> First a -> Maybe (Element (First a)) #
Generic1 First
Instance details Defined in Data.Monoid Associated Types type Rep1 First :: k -> Type # Methods from1 :: forall (a :: k). First a -> Rep1 First a # to1 :: forall (a :: k). Rep1 First a -> First a #
t ~ First b => Rewrapped (First a) t
Instance details Defined in Control.Lens.Wrapped
IsoHKD First (a :: Type)
Instance details Defined in Data.Vinyl.XRec Associated Types type HKD First a # Methods unHKD :: HKD First a -> First a # toHKD :: First a -> HKD First a #
SDecide (Maybe a) => TestCoercion (SFirst :: First a -> Type)
Instance details Defined in Data.Monoid.Singletons Methods testCoercion :: forall (a0 :: k) (b :: k). SFirst a0 -> SFirst b -> Maybe (Coercion a0 b) #
SDecide (Maybe a) => TestEquality (SFirst :: First a -> Type)
Instance details Defined in Data.Monoid.Singletons Methods testEquality :: forall (a0 :: k) (b :: k). SFirst a0 -> SFirst b -> Maybe (a0 :~: b) #
SingI (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing GetFirstSym0 #
SingI (FirstSym0 :: TyFun (Maybe a) (First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods sing :: Sing FirstSym0 #
SuppressUnusedWarnings (TFHelper_6989586621680118641Sym0 :: TyFun (First a) (First a ~> First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680111321Sym0 :: TyFun (First a) (First a ~> Ordering) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680109664Sym0 :: TyFun (First a) (First a ~> Bool) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FirstSym0 :: TyFun (Maybe a) (First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680113533Sym0 :: TyFun Nat (First a ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Let6989586621680118650ASym0 :: TyFun a (First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621680118355Sym0 :: TyFun a (First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118365Sym0 :: TyFun (First (a ~> b)) (First a ~> First b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118641Sym1 a6989586621680118646 :: TyFun (First a) (First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621680111321Sym1 a6989586621680111326 :: TyFun (First a) Ordering -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118488Sym0 :: TyFun (First a) ((a ~> First b) ~> First b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680113533Sym1 a6989586621680113541 :: TyFun (First a) (Symbol ~> Symbol) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680109664Sym1 a6989586621680109669 :: TyFun (First a) Bool -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680296683Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (First a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680193283Sym0 :: TyFun (a ~> Bool) (TyFun k (TyFun a (First a) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621680118436Sym0 :: TyFun (a ~> b) (First a ~> First b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680296671Sym0 :: TyFun (a ~> m) (First a ~> m) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118447Sym0 :: TyFun a (First b ~> First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621680118436Sym1 a6989586621680118441 :: TyFun (First a) (First b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118365Sym1 a6989586621680118370 :: TyFun (First a) (First b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680296671Sym1 a6989586621680296676 :: TyFun (First a) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118447Sym1 a6989586621680118452 :: TyFun (First b) (First a) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680118488Sym1 a6989586621680118493 :: TyFun (a ~> First b) (First b) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478802Sym0 :: TyFun (a ~> f b) (First a ~> f (First b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680296683Sym1 a6989586621680296689 :: TyFun b (First a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680118497Sym0 :: TyFun k (TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680193283Sym1 p6989586621680193281 :: TyFun k (TyFun a (First a) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680296683Sym2 a6989586621680296689 a6989586621680296690 :: TyFun (First a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478802Sym1 a6989586621680478807 :: TyFun (First a) (f (First b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680118497Sym1 a6989586621680118495 :: TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type)
Instance details Defined in Data.Monoid.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680193283Sym2 p6989586621680193281 a_69895866216801932746989586621680193282 :: TyFun a (First a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
type Pure (a :: k1)
Instance details Defined in Data.Monoid.Singletons type Pure (a :: k1) = Apply (Pure_6989586621680118355Sym0 :: TyFun k1 (First k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Data.Monoid.Singletons type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (First a) -> Type) arg
type Fold (arg :: First m)
Instance details Defined in Data.Foldable.Singletons type Fold (arg :: First m) = Apply (Fold_6989586621680193565Sym0 :: TyFun (First m) m -> Type) arg
type Length (arg :: First a)
Instance details Defined in Data.Foldable.Singletons type Length (arg :: First a) = Apply (Length_6989586621680193731Sym0 :: TyFun (First a) Nat -> Type) arg
type Maximum (arg :: First a)
Instance details Defined in Data.Foldable.Singletons type Maximum (arg :: First a) = Apply (Maximum_6989586621680193764Sym0 :: TyFun (First a) a -> Type) arg
type Minimum (arg :: First a)
Instance details Defined in Data.Foldable.Singletons type Minimum (arg :: First a) = Apply (Minimum_6989586621680193779Sym0 :: TyFun (First a) a -> Type) arg
type Null (arg :: First a)
Instance details Defined in Data.Foldable.Singletons type Null (arg :: First a) = Apply (Null_6989586621680193714Sym0 :: TyFun (First a) Bool -> Type) arg
type Product (arg :: First a)
Instance details Defined in Data.Foldable.Singletons type Product (arg :: First a) = Apply (Product_6989586621680193803Sym0 :: TyFun (First a) a -> Type) arg
type Sum (arg :: First a)
Instance details Defined in Data.Foldable.Singletons type Sum (arg :: First a) = Apply (Sum_6989586621680193794Sym0 :: TyFun (First a) a -> Type) arg
type ToList (arg :: First a)
Instance details Defined in Data.Foldable.Singletons type ToList (arg :: First a) = Apply (ToList_6989586621680193705Sym0 :: TyFun (First a) [a] -> Type) arg
type Elem (arg1 :: a) (arg2 :: First a)
Instance details Defined in Data.Foldable.Singletons type Elem (arg1 :: a) (arg2 :: First a) = Apply (Apply (Elem_6989586621680193750Sym0 :: TyFun a (First a ~> Bool) -> Type) arg1) arg2
type Foldl1 (arg1 :: a ~> (a ~> a)) (arg2 :: First a)
Instance details Defined in Data.Foldable.Singletons type Foldl1 (arg1 :: a ~> (a ~> a)) (arg2 :: First a) = Apply (Apply (Foldl1_6989586621680193685Sym0 :: TyFun (a ~> (a ~> a)) (First a ~> a) -> Type) arg1) arg2
type Foldr1 (arg1 :: a ~> (a ~> a)) (arg2 :: First a)
Instance details Defined in Data.Foldable.Singletons type Foldr1 (arg1 :: a ~> (a ~> a)) (arg2 :: First a) = Apply (Apply (Foldr1_6989586621680193664Sym0 :: TyFun (a ~> (a ~> a)) (First a ~> a) -> Type) arg1) arg2
type Sequence (arg :: First (m a))
Instance details Defined in Data.Traversable.Singletons type Sequence (arg :: First (m a)) = Apply (Sequence_6989586621680471117Sym0 :: TyFun (First (m a)) (m (First a)) -> Type) arg
type SequenceA (arg :: First (f a))
Instance details Defined in Data.Traversable.Singletons type SequenceA (arg :: First (f a)) = Apply (SequenceA_6989586621680471093Sym0 :: TyFun (First (f a)) (f (First a)) -> Type) arg
type (arg :: First a) *> (arg1 :: First b)
Instance details Defined in Data.Monoid.Singletons type (arg :: First a) *> (arg1 :: First b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (First a) (First b ~> First b) -> Type) arg) arg1
type (a1 :: k1) <$ (a2 :: First b)
Instance details Defined in Data.Monoid.Singletons type (a1 :: k1) <$ (a2 :: First b) = Apply (Apply (TFHelper_6989586621680118447Sym0 :: TyFun k1 (First b ~> First k1) -> Type) a1) a2
type (arg :: First a) <* (arg1 :: First b)
Instance details Defined in Data.Monoid.Singletons type (arg :: First a) <* (arg1 :: First b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (First a) (First b ~> First a) -> Type) arg) arg1
type (a2 :: First (a1 ~> b)) <*> (a3 :: First a1)
Instance details Defined in Data.Monoid.Singletons type (a2 :: First (a1 ~> b)) <*> (a3 :: First a1) = Apply (Apply (TFHelper_6989586621680118365Sym0 :: TyFun (First (a1 ~> b)) (First a1 ~> First b) -> Type) a2) a3
type (arg :: First a) >> (arg1 :: First b)
Instance details Defined in Data.Monoid.Singletons type (arg :: First a) >> (arg1 :: First b) = Apply (Apply (TFHelper_6989586621679287148Sym0 :: TyFun (First a) (First b ~> First b) -> Type) arg) arg1
type (a2 :: First a1) >>= (a3 :: a1 ~> First b)
Instance details Defined in Data.Monoid.Singletons type (a2 :: First a1) >>= (a3 :: a1 ~> First b) = Apply (Apply (TFHelper_6989586621680118488Sym0 :: TyFun (First a1) ((a1 ~> First b) ~> First b) -> Type) a2) a3
type Fmap (a2 :: a1 ~> b) (a3 :: First a1)
Instance details Defined in Data.Monoid.Singletons type Fmap (a2 :: a1 ~> b) (a3 :: First a1) = Apply (Apply (Fmap_6989586621680118436Sym0 :: TyFun (a1 ~> b) (First a1 ~> First b) -> Type) a2) a3
type FoldMap (a2 :: a1 ~> k2) (a3 :: First a1)
Instance details Defined in Data.Foldable.Singletons type FoldMap (a2 :: a1 ~> k2) (a3 :: First a1) = Apply (Apply (FoldMap_6989586621680296671Sym0 :: TyFun (a1 ~> k2) (First a1 ~> k2) -> Type) a2) a3
type Foldl (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: First a)
Instance details Defined in Data.Foldable.Singletons type Foldl (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: First a) = Apply (Apply (Apply (Foldl_6989586621680193627Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (First a ~> b)) -> Type) arg1) arg2) arg3
type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: First a)
Instance details Defined in Data.Foldable.Singletons type Foldl' (arg1 :: b ~> (a ~> b)) (arg2 :: b) (arg3 :: First a) = Apply (Apply (Apply (Foldl'_6989586621680193642Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (First a ~> b)) -> Type) arg1) arg2) arg3
type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: First a1)
Instance details Defined in Data.Foldable.Singletons type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: First a1) = Apply (Apply (Apply (Foldr_6989586621680296683Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (First a1 ~> k2)) -> Type) a2) a3) a4
type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: First a)
Instance details Defined in Data.Foldable.Singletons type Foldr' (arg1 :: a ~> (b ~> b)) (arg2 :: b) (arg3 :: First a) = Apply (Apply (Apply (Foldr'_6989586621680193604Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (First a ~> b)) -> Type) arg1) arg2) arg3
type MapM (arg1 :: a ~> m b) (arg2 :: First a)
Instance details Defined in Data.Traversable.Singletons type MapM (arg1 :: a ~> m b) (arg2 :: First a) = Apply (Apply (MapM_6989586621680471103Sym0 :: TyFun (a ~> m b) (First a ~> m (First b)) -> Type) arg1) arg2
type Traverse (a2 :: a1 ~> f b) (a3 :: First a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a2 :: a1 ~> f b) (a3 :: First a1) = Apply (Apply (Traverse_6989586621680478802Sym0 :: TyFun (a1 ~> f b) (First a1 ~> f (First b)) -> Type) a2) a3
type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: First a) (arg2 :: First b)
Instance details Defined in Data.Monoid.Singletons type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: First a) (arg2 :: First b) = Apply (Apply (Apply (LiftA2_6989586621679287093Sym0 :: TyFun (a ~> (b ~> c)) (First a ~> (First b ~> First c)) -> Type) arg) arg1) arg2
type Apply (Let6989586621680118650ASym0 :: TyFun a (First a) -> Type) (wild_69895866216801179186989586621680118649 :: a)
Instance details Defined in Data.Monoid.Singletons type Apply (Let6989586621680118650ASym0 :: TyFun a (First a) -> Type) (wild_69895866216801179186989586621680118649 :: a) = Let6989586621680118650A wild_69895866216801179186989586621680118649
type Apply (Pure_6989586621680118355Sym0 :: TyFun a (First a) -> Type) (a6989586621680118361 :: a)
Instance details Defined in Data.Monoid.Singletons type Apply (Pure_6989586621680118355Sym0 :: TyFun a (First a) -> Type) (a6989586621680118361 :: a) = Pure_6989586621680118355 a6989586621680118361
type Apply (Lambda_6989586621680193283Sym2 p6989586621680193281 a_69895866216801932746989586621680193282 :: TyFun a (First a) -> Type) (x6989586621680193285 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680193283Sym2 p6989586621680193281 a_69895866216801932746989586621680193282 :: TyFun a (First a) -> Type) (x6989586621680193285 :: a) = Lambda_6989586621680193283 p6989586621680193281 a_69895866216801932746989586621680193282 x6989586621680193285
type Apply (ShowsPrec_6989586621680113533Sym0 :: TyFun Nat (First a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680113541 :: Nat)
Instance details Defined in Data.Monoid.Singletons type Apply (ShowsPrec_6989586621680113533Sym0 :: TyFun Nat (First a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680113541 :: Nat) = ShowsPrec_6989586621680113533Sym1 a6989586621680113541 :: TyFun (First a) (Symbol ~> Symbol) -> Type
type Apply (TFHelper_6989586621680118447Sym0 :: TyFun a (First b ~> First a) -> Type) (a6989586621680118452 :: a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118447Sym0 :: TyFun a (First b ~> First a) -> Type) (a6989586621680118452 :: a) = TFHelper_6989586621680118447Sym1 a6989586621680118452 :: TyFun (First b) (First a) -> Type
type Apply (Foldr_6989586621680296683Sym1 a6989586621680296689 :: TyFun b (First a ~> b) -> Type) (a6989586621680296690 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680296683Sym1 a6989586621680296689 :: TyFun b (First a ~> b) -> Type) (a6989586621680296690 :: b) = Foldr_6989586621680296683Sym2 a6989586621680296689 a6989586621680296690
type Apply (Lambda_6989586621680118497Sym0 :: TyFun k (TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) (a6989586621680118495 :: k)
Instance details Defined in Data.Monoid.Singletons type Apply (Lambda_6989586621680118497Sym0 :: TyFun k (TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) -> Type) (a6989586621680118495 :: k) = Lambda_6989586621680118497Sym1 a6989586621680118495 :: TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type
type Apply (Lambda_6989586621680193283Sym1 p6989586621680193281 :: TyFun k (TyFun a (First a) -> Type) -> Type) (a_69895866216801932746989586621680193282 :: k)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680193283Sym1 p6989586621680193281 :: TyFun k (TyFun a (First a) -> Type) -> Type) (a_69895866216801932746989586621680193282 :: k) = Lambda_6989586621680193283Sym2 p6989586621680193281 a_69895866216801932746989586621680193282
type Rep (First a)	Since: base-4.7.0.0
Instance details Defined in Data.Monoid type Rep (First a) = D1 ('MetaData "First" "Data.Monoid" "base" 'True) (C1 ('MetaCons "First" 'PrefixI 'True) (S1 ('MetaSel ('Just "getFirst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe a))))
type Unwrapped (First a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (First a) = Maybe a
type Demote (First a)
Instance details Defined in Data.Monoid.Singletons type Demote (First a) = First (Demote a)
type Sing
Instance details Defined in Data.Monoid.Singletons type Sing = SFirst :: First a -> Type
type Mempty
Instance details Defined in Data.Monoid.Singletons type Mempty = Mempty_6989586621680118652Sym0 :: First a
type Element (First a)
Instance details Defined in Universum.Container.Class type Element (First a) = ElementDefault (First a)
type Rep1 First	Since: base-4.7.0.0
Instance details Defined in Data.Monoid type Rep1 First = D1 ('MetaData "First" "Data.Monoid" "base" 'True) (C1 ('MetaCons "First" 'PrefixI 'True) (S1 ('MetaSel ('Just "getFirst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Maybe)))
type Mconcat (arg :: [First a])
Instance details Defined in Data.Monoid.Singletons type Mconcat (arg :: [First a]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [First a] (First a) -> Type) arg
type Sconcat (arg :: NonEmpty (First a))
Instance details Defined in Data.Monoid.Singletons type Sconcat (arg :: NonEmpty (First a)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (First a)) (First a) -> Type) arg
type Show_ (arg :: First a)
Instance details Defined in Data.Monoid.Singletons type Show_ (arg :: First a) = Apply (Show__6989586621680047550Sym0 :: TyFun (First a) Symbol -> Type) arg
type (arg :: First a) /= (arg1 :: First a)
Instance details Defined in Data.Monoid.Singletons type (arg :: First a) /= (arg1 :: First a) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) arg) arg1
type (a2 :: First a1) == (a3 :: First a1)
Instance details Defined in Data.Monoid.Singletons type (a2 :: First a1) == (a3 :: First a1) = Apply (Apply (TFHelper_6989586621680109664Sym0 :: TyFun (First a1) (First a1 ~> Bool) -> Type) a2) a3
type Mappend (arg1 :: First a) (arg2 :: First a)
Instance details Defined in Data.Monoid.Singletons type Mappend (arg1 :: First a) (arg2 :: First a) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (First a) (First a ~> First a) -> Type) arg1) arg2
type (arg :: First a) < (arg1 :: First a)
Instance details Defined in Data.Monoid.Singletons type (arg :: First a) < (arg1 :: First a) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) arg) arg1
type (arg :: First a) <= (arg1 :: First a)
Instance details Defined in Data.Monoid.Singletons type (arg :: First a) <= (arg1 :: First a) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) arg) arg1
type (arg :: First a) > (arg1 :: First a)
Instance details Defined in Data.Monoid.Singletons type (arg :: First a) > (arg1 :: First a) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) arg) arg1
type (arg :: First a) >= (arg1 :: First a)
Instance details Defined in Data.Monoid.Singletons type (arg :: First a) >= (arg1 :: First a) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) arg) arg1
type Compare (a2 :: First a1) (a3 :: First a1)
Instance details Defined in Data.Monoid.Singletons type Compare (a2 :: First a1) (a3 :: First a1) = Apply (Apply (Compare_6989586621680111321Sym0 :: TyFun (First a1) (First a1 ~> Ordering) -> Type) a2) a3
type Max (arg :: First a) (arg1 :: First a)
Instance details Defined in Data.Monoid.Singletons type Max (arg :: First a) (arg1 :: First a) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (First a) (First a ~> First a) -> Type) arg) arg1
type Min (arg :: First a) (arg1 :: First a)
Instance details Defined in Data.Monoid.Singletons type Min (arg :: First a) (arg1 :: First a) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (First a) (First a ~> First a) -> Type) arg) arg1
type (a2 :: First a1) <> (a3 :: First a1)
Instance details Defined in Data.Monoid.Singletons type (a2 :: First a1) <> (a3 :: First a1) = Apply (Apply (TFHelper_6989586621680118641Sym0 :: TyFun (First a1) (First a1 ~> First a1) -> Type) a2) a3
type ShowList (arg :: [First a]) arg1
Instance details Defined in Data.Monoid.Singletons type ShowList (arg :: [First a]) arg1 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [First a] (Symbol ~> Symbol) -> Type) arg) arg1
type HKD First (a :: Type)
Instance details Defined in Data.Vinyl.XRec type HKD First (a :: Type) = First a
type ShowsPrec a2 (a3 :: First a1) a4
Instance details Defined in Data.Monoid.Singletons type ShowsPrec a2 (a3 :: First a1) a4 = Apply (Apply (Apply (ShowsPrec_6989586621680113533Sym0 :: TyFun Nat (First a1 ~> (Symbol ~> Symbol)) -> Type) a2) a3) a4
type Apply (Compare_6989586621680111321Sym1 a6989586621680111326 :: TyFun (First a) Ordering -> Type) (a6989586621680111327 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (Compare_6989586621680111321Sym1 a6989586621680111326 :: TyFun (First a) Ordering -> Type) (a6989586621680111327 :: First a) = Compare_6989586621680111321 a6989586621680111326 a6989586621680111327
type Apply (TFHelper_6989586621680109664Sym1 a6989586621680109669 :: TyFun (First a) Bool -> Type) (a6989586621680109670 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680109664Sym1 a6989586621680109669 :: TyFun (First a) Bool -> Type) (a6989586621680109670 :: First a) = TFHelper_6989586621680109664 a6989586621680109669 a6989586621680109670
type Apply (FoldMap_6989586621680296671Sym1 a6989586621680296676 :: TyFun (First a) m -> Type) (a6989586621680296677 :: First a)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680296671Sym1 a6989586621680296676 :: TyFun (First a) m -> Type) (a6989586621680296677 :: First a) = FoldMap_6989586621680296671 a6989586621680296676 a6989586621680296677
type Apply (Foldr_6989586621680296683Sym2 a6989586621680296689 a6989586621680296690 :: TyFun (First a) b -> Type) (a6989586621680296691 :: First a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680296683Sym2 a6989586621680296689 a6989586621680296690 :: TyFun (First a) b -> Type) (a6989586621680296691 :: First a) = Foldr_6989586621680296683 a6989586621680296689 a6989586621680296690 a6989586621680296691
type Apply (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type) (a6989586621680107980 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (GetFirstSym0 :: TyFun (First a) (Maybe a) -> Type) (a6989586621680107980 :: First a) = GetFirst a6989586621680107980
type Apply (FirstSym0 :: TyFun (Maybe a) (First a) -> Type) (a6989586621680107977 :: Maybe a)
Instance details Defined in Data.Monoid.Singletons type Apply (FirstSym0 :: TyFun (Maybe a) (First a) -> Type) (a6989586621680107977 :: Maybe a) = 'First a6989586621680107977
type Apply (TFHelper_6989586621680118641Sym1 a6989586621680118646 :: TyFun (First a) (First a) -> Type) (a6989586621680118647 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118641Sym1 a6989586621680118646 :: TyFun (First a) (First a) -> Type) (a6989586621680118647 :: First a) = TFHelper_6989586621680118641 a6989586621680118646 a6989586621680118647
type Apply (Fmap_6989586621680118436Sym1 a6989586621680118441 :: TyFun (First a) (First b) -> Type) (a6989586621680118442 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (Fmap_6989586621680118436Sym1 a6989586621680118441 :: TyFun (First a) (First b) -> Type) (a6989586621680118442 :: First a) = Fmap_6989586621680118436 a6989586621680118441 a6989586621680118442
type Apply (TFHelper_6989586621680118365Sym1 a6989586621680118370 :: TyFun (First a) (First b) -> Type) (a6989586621680118371 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118365Sym1 a6989586621680118370 :: TyFun (First a) (First b) -> Type) (a6989586621680118371 :: First a) = TFHelper_6989586621680118365 a6989586621680118370 a6989586621680118371
type Apply (TFHelper_6989586621680118447Sym1 a6989586621680118452 :: TyFun (First b) (First a) -> Type) (a6989586621680118453 :: First b)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118447Sym1 a6989586621680118452 :: TyFun (First b) (First a) -> Type) (a6989586621680118453 :: First b) = TFHelper_6989586621680118447 a6989586621680118452 a6989586621680118453
type Apply (Traverse_6989586621680478802Sym1 a6989586621680478807 :: TyFun (First a) (f (First b)) -> Type) (a6989586621680478808 :: First a)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478802Sym1 a6989586621680478807 :: TyFun (First a) (f (First b)) -> Type) (a6989586621680478808 :: First a) = Traverse_6989586621680478802 a6989586621680478807 a6989586621680478808
type Apply (TFHelper_6989586621680118641Sym0 :: TyFun (First a) (First a ~> First a) -> Type) (a6989586621680118646 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118641Sym0 :: TyFun (First a) (First a ~> First a) -> Type) (a6989586621680118646 :: First a) = TFHelper_6989586621680118641Sym1 a6989586621680118646
type Apply (Compare_6989586621680111321Sym0 :: TyFun (First a) (First a ~> Ordering) -> Type) (a6989586621680111326 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (Compare_6989586621680111321Sym0 :: TyFun (First a) (First a ~> Ordering) -> Type) (a6989586621680111326 :: First a) = Compare_6989586621680111321Sym1 a6989586621680111326
type Apply (TFHelper_6989586621680109664Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) (a6989586621680109669 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680109664Sym0 :: TyFun (First a) (First a ~> Bool) -> Type) (a6989586621680109669 :: First a) = TFHelper_6989586621680109664Sym1 a6989586621680109669
type Apply (TFHelper_6989586621680118365Sym0 :: TyFun (First (a ~> b)) (First a ~> First b) -> Type) (a6989586621680118370 :: First (a ~> b))
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118365Sym0 :: TyFun (First (a ~> b)) (First a ~> First b) -> Type) (a6989586621680118370 :: First (a ~> b)) = TFHelper_6989586621680118365Sym1 a6989586621680118370
type Apply (TFHelper_6989586621680118488Sym0 :: TyFun (First a) ((a ~> First b) ~> First b) -> Type) (a6989586621680118493 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118488Sym0 :: TyFun (First a) ((a ~> First b) ~> First b) -> Type) (a6989586621680118493 :: First a) = TFHelper_6989586621680118488Sym1 a6989586621680118493 :: TyFun (a ~> First b) (First b) -> Type
type Apply (ShowsPrec_6989586621680113533Sym1 a6989586621680113541 :: TyFun (First a) (Symbol ~> Symbol) -> Type) (a6989586621680113542 :: First a)
Instance details Defined in Data.Monoid.Singletons type Apply (ShowsPrec_6989586621680113533Sym1 a6989586621680113541 :: TyFun (First a) (Symbol ~> Symbol) -> Type) (a6989586621680113542 :: First a) = ShowsPrec_6989586621680113533Sym2 a6989586621680113541 a6989586621680113542
type Apply (TFHelper_6989586621680118488Sym1 a6989586621680118493 :: TyFun (a ~> First b) (First b) -> Type) (a6989586621680118494 :: a ~> First b)
Instance details Defined in Data.Monoid.Singletons type Apply (TFHelper_6989586621680118488Sym1 a6989586621680118493 :: TyFun (a ~> First b) (First b) -> Type) (a6989586621680118494 :: a ~> First b) = TFHelper_6989586621680118488 a6989586621680118493 a6989586621680118494
type Apply (Foldr_6989586621680296683Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (First a ~> b)) -> Type) (a6989586621680296689 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680296683Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (First a ~> b)) -> Type) (a6989586621680296689 :: a ~> (b ~> b)) = Foldr_6989586621680296683Sym1 a6989586621680296689
type Apply (Lambda_6989586621680193283Sym0 :: TyFun (a ~> Bool) (TyFun k (TyFun a (First a) -> Type) -> Type) -> Type) (p6989586621680193281 :: a ~> Bool)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680193283Sym0 :: TyFun (a ~> Bool) (TyFun k (TyFun a (First a) -> Type) -> Type) -> Type) (p6989586621680193281 :: a ~> Bool) = Lambda_6989586621680193283Sym1 p6989586621680193281 :: TyFun k (TyFun a (First a) -> Type) -> Type
type Apply (Fmap_6989586621680118436Sym0 :: TyFun (a ~> b) (First a ~> First b) -> Type) (a6989586621680118441 :: a ~> b)
Instance details Defined in Data.Monoid.Singletons type Apply (Fmap_6989586621680118436Sym0 :: TyFun (a ~> b) (First a ~> First b) -> Type) (a6989586621680118441 :: a ~> b) = Fmap_6989586621680118436Sym1 a6989586621680118441
type Apply (FoldMap_6989586621680296671Sym0 :: TyFun (a ~> m) (First a ~> m) -> Type) (a6989586621680296676 :: a ~> m)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680296671Sym0 :: TyFun (a ~> m) (First a ~> m) -> Type) (a6989586621680296676 :: a ~> m) = FoldMap_6989586621680296671Sym1 a6989586621680296676
type Apply (Traverse_6989586621680478802Sym0 :: TyFun (a ~> f b) (First a ~> f (First b)) -> Type) (a6989586621680478807 :: a ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478802Sym0 :: TyFun (a ~> f b) (First a ~> f (First b)) -> Type) (a6989586621680478807 :: a ~> f b) = Traverse_6989586621680478802Sym1 a6989586621680478807
type Apply (Lambda_6989586621680118497Sym1 a6989586621680118495 :: TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) (k6989586621680118496 :: k1 ~> First a)
Instance details Defined in Data.Monoid.Singletons type Apply (Lambda_6989586621680118497Sym1 a6989586621680118495 :: TyFun (k1 ~> First a) (TyFun k1 (Maybe a) -> Type) -> Type) (k6989586621680118496 :: k1 ~> First a) = Lambda_6989586621680118497Sym2 a6989586621680118495 k6989586621680118496

newtype Sum a #

Monoid under addition.

>>> getSum (Sum 1 <> Sum 2 <> mempty)
3

Constructors

Sum
Fields getSum :: a

Instances

Instances details

Representable Sum
Instance details Defined in Data.Functor.Rep Associated Types type Rep Sum # Methods tabulate :: (Rep Sum -> a) -> Sum a # index :: Sum a -> Rep Sum -> a #
Foldable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m # foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldMap' :: Monoid m => (a -> m) -> Sum a -> m # foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b # foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b # foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # toList :: Sum a -> [a] # null :: Sum a -> Bool # length :: Sum a -> Int # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # minimum :: Ord a => Sum a -> a # sum :: Num a => Sum a -> a # product :: Num a => Sum a -> a #
Traversable Sum	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) # sequenceA :: Applicative f => Sum (f a) -> f (Sum a) # mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) # sequence :: Monad m => Sum (m a) -> m (Sum a) #
Applicative Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Sum a # (<>) :: Sum (a -> b) -> Sum a -> Sum b # liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c # (>) :: Sum a -> Sum b -> Sum b # (<*) :: Sum a -> Sum b -> Sum a #
Functor Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Sum a -> Sum b # (<$) :: a -> Sum b -> Sum a #
Monad Sum	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Sum a -> (a -> Sum b) -> Sum b # (>>) :: Sum a -> Sum b -> Sum b # return :: a -> Sum a #
NFData1 Sum	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Sum a -> () #
PFoldable Sum
Instance details Defined in Data.Foldable.Singletons Associated Types type Fold arg :: m # type FoldMap arg arg1 :: m # type Foldr arg arg1 arg2 :: b # type Foldr' arg arg1 arg2 :: b # type Foldl arg arg1 arg2 :: b # type Foldl' arg arg1 arg2 :: b # type Foldr1 arg arg1 :: a # type Foldl1 arg arg1 :: a # type ToList arg :: [a] # type Null arg :: Bool # type Length arg :: Nat # type Elem arg arg1 :: Bool # type Maximum arg :: a # type Minimum arg :: a # type Sum arg :: a # type Product arg :: a #
SFoldable Sum
Instance details Defined in Data.Foldable.Singletons Methods sFold :: forall m (t1 :: Sum m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a m (t1 :: a ~> m) (t2 :: Sum a). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Sum a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Sum a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Sum a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Sum a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Sum a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Sum a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a (t1 :: Sum a). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a (t1 :: Sum a). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a (t1 :: Sum a). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a (t1 :: a) (t2 :: Sum a). SEq a => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a (t1 :: Sum a). SOrd a => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a (t1 :: Sum a). SOrd a => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a (t1 :: Sum a). SNum a => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a (t1 :: Sum a). SNum a => Sing t1 -> Sing (Apply ProductSym0 t1) #
PTraversable Sum
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable Sum
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: Sum a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: Sum (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: Sum a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: Sum (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) #
Unbox a => Vector Vector (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Sum a) -> m (Vector (Sum a)) # basicUnsafeThaw :: PrimMonad m => Vector (Sum a) -> m (Mutable Vector (PrimState m) (Sum a)) # basicLength :: Vector (Sum a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Sum a) -> Vector (Sum a) # basicUnsafeIndexM :: Monad m => Vector (Sum a) -> Int -> m (Sum a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Sum a) -> Vector (Sum a) -> m () # elemseq :: Vector (Sum a) -> Sum a -> b -> b #
Unbox a => MVector MVector (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Sum a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Sum a) -> MVector s (Sum a) # basicOverlaps :: MVector s (Sum a) -> MVector s (Sum a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Sum a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Sum a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Sum a -> m (MVector (PrimState m) (Sum a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Sum a) -> Int -> m (Sum a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Sum a) -> Int -> Sum a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Sum a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Sum a) -> Sum a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Sum a) -> MVector (PrimState m) (Sum a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Sum a) -> MVector (PrimState m) (Sum a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Sum a) -> Int -> m (MVector (PrimState m) (Sum a)) #
Num a => Monoid (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Num a => Semigroup (Sum a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Sum a -> Sum a -> Sum a # sconcat :: NonEmpty (Sum a) -> Sum a # stimes :: Integral b => b -> Sum a -> Sum a #
Bounded a => Bounded (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Sum a # maxBound :: Sum a #
Generic (Sum a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Sum a) :: Type -> Type # Methods from :: Sum a -> Rep (Sum a) x # to :: Rep (Sum a) x -> Sum a #
Num a => Num (Sum a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Sum a -> Sum a -> Sum a # (-) :: Sum a -> Sum a -> Sum a # (*) :: Sum a -> Sum a -> Sum a # negate :: Sum a -> Sum a # abs :: Sum a -> Sum a # signum :: Sum a -> Sum a # fromInteger :: Integer -> Sum a #
Read a => Read (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS (Sum a) # readList :: ReadS [Sum a] # readPrec :: ReadPrec (Sum a) # readListPrec :: ReadPrec [Sum a] #
Show a => Show (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Sum a -> ShowS # show :: Sum a -> String # showList :: [Sum a] -> ShowS #
Num a => Default (Sum a)
Instance details Defined in Data.Default.Class Methods def :: Sum a #
NFData a => NFData (Sum a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Sum a -> () #
Eq a => Eq (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Sum a -> Sum a -> Bool # (/=) :: Sum a -> Sum a -> Bool #
Ord a => Ord (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Sum a -> Sum a -> Ordering # (<) :: Sum a -> Sum a -> Bool # (<=) :: Sum a -> Sum a -> Bool # (>) :: Sum a -> Sum a -> Bool # (>=) :: Sum a -> Sum a -> Bool # max :: Sum a -> Sum a -> Sum a # min :: Sum a -> Sum a -> Sum a #
Wrapped (Sum a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Sum a) # Methods _Wrapped' :: Iso' (Sum a) (Unwrapped (Sum a)) #
PMonoid (Sum a)
Instance details Defined in Data.Monoid.Singletons Associated Types type Mempty :: a # type Mappend arg arg1 :: a # type Mconcat arg :: a #
SNum a => SMonoid (Sum a)
Instance details Defined in Data.Monoid.Singletons Methods sMempty :: Sing MemptySym0 # sMappend :: forall (t1 :: Sum a) (t2 :: Sum a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MappendSym0 t1) t2) # sMconcat :: forall (t :: [Sum a]). Sing t -> Sing (Apply MconcatSym0 t) #
PSemigroup (Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal Associated Types type arg <> arg1 :: a # type Sconcat arg :: a #
SNum a => SSemigroup (Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods (%<>) :: forall (t1 :: Sum a) (t2 :: Sum a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sSconcat :: forall (t :: NonEmpty (Sum a)). Sing t -> Sing (Apply SconcatSym0 t) #
Container (Sum a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Sum a) # Methods toList :: Sum a -> [Element (Sum a)] # null :: Sum a -> Bool # foldr :: (Element (Sum a) -> b -> b) -> b -> Sum a -> b # foldl :: (b -> Element (Sum a) -> b) -> b -> Sum a -> b # foldl' :: (b -> Element (Sum a) -> b) -> b -> Sum a -> b # length :: Sum a -> Int # elem :: Element (Sum a) -> Sum a -> Bool # foldMap :: Monoid m => (Element (Sum a) -> m) -> Sum a -> m # fold :: Sum a -> Element (Sum a) # foldr' :: (Element (Sum a) -> b -> b) -> b -> Sum a -> b # notElem :: Element (Sum a) -> Sum a -> Bool # all :: (Element (Sum a) -> Bool) -> Sum a -> Bool # any :: (Element (Sum a) -> Bool) -> Sum a -> Bool # and :: Sum a -> Bool # or :: Sum a -> Bool # find :: (Element (Sum a) -> Bool) -> Sum a -> Maybe (Element (Sum a)) # safeHead :: Sum a -> Maybe (Element (Sum a)) # safeMaximum :: Sum a -> Maybe (Element (Sum a)) # safeMinimum :: Sum a -> Maybe (Element (Sum a)) # safeFoldr1 :: (Element (Sum a) -> Element (Sum a) -> Element (Sum a)) -> Sum a -> Maybe (Element (Sum a)) # safeFoldl1 :: (Element (Sum a) -> Element (Sum a) -> Element (Sum a)) -> Sum a -> Maybe (Element (Sum a)) #
Unbox a => Unbox (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Sum
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Sum :: k -> Type # Methods from1 :: forall (a :: k). Sum a -> Rep1 Sum a # to1 :: forall (a :: k). Rep1 Sum a -> Sum a #
t ~ Sum b => Rewrapped (Sum a) t
Instance details Defined in Control.Lens.Wrapped
IsoHKD Sum (a :: Type)	Work with values of type `Sum` `a` as if they were of type `a`.
Instance details Defined in Data.Vinyl.XRec Associated Types type HKD Sum a # Methods unHKD :: HKD Sum a -> Sum a # toHKD :: Sum a -> HKD Sum a #
SDecide a => TestCoercion (SSum :: Sum a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods testCoercion :: forall (a0 :: k) (b :: k). SSum a0 -> SSum b -> Maybe (Coercion a0 b) #
SDecide a => TestEquality (SSum :: Sum a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods testEquality :: forall (a0 :: k) (b :: k). SSum a0 -> SSum b -> Maybe (a0 :~: b) #
SingI (GetSumSym0 :: TyFun (Sum a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetSumSym0 #
SingI (SumSym0 :: TyFun a (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing SumSym0 #
SingI (Sum_Sym0 :: TyFun a (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods sing :: Sing Sum_Sym0 #
SuppressUnusedWarnings (Abs_6989586621679624806Sym0 :: TyFun (Sum a) (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Negate_6989586621679624799Sym0 :: TyFun (Sum a) (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Signum_6989586621679624813Sym0 :: TyFun (Sum a) (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624733Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624767Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624778Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624789Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613621Sym0 :: TyFun (Sum a) (Sum a ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606160Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680194575Sym0 :: TyFun (Sum a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Length_6989586621680194551Sym0 :: TyFun (Sum a) Nat -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ToList_6989586621680194599Sym0 :: TyFun (Sum a) [a] -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Maximum_6989586621680194557Sym0 :: TyFun (Sum a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Minimum_6989586621680194566Sym0 :: TyFun (Sum a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Product_6989586621680194581Sym0 :: TyFun (Sum a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Sum_6989586621680194590Sym0 :: TyFun (Sum a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GetSumSym0 :: TyFun (Sum a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680194492Sym0 :: TyFun (a ~> (a ~> a)) (Sum a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680194540Sym0 :: TyFun (a ~> (a ~> a)) (Sum a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromInteger_6989586621679624820Sym0 :: TyFun Nat (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680582255Sym0 :: TyFun Nat (Sum a ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621679624675Sym0 :: TyFun a (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (SumSym0 :: TyFun a (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Sum_Sym0 :: TyFun a (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194443Sym0 :: TyFun a (Sum a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624685Sym0 :: TyFun (Sum (a ~> b)) (Sum a ~> Sum b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624733Sym1 a6989586621679624738 :: TyFun (Sum a) (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624767Sym1 a6989586621679624772 :: TyFun (Sum a) (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624778Sym1 a6989586621679624783 :: TyFun (Sum a) (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624789Sym1 a6989586621679624794 :: TyFun (Sum a) (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613621Sym1 a6989586621679613626 :: TyFun (Sum a) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624722Sym0 :: TyFun (Sum a) ((a ~> Sum b) ~> Sum b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680582255Sym1 a6989586621680582263 :: TyFun (Sum a) (Symbol ~> Symbol) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194443Sym1 a6989586621680194452 :: TyFun (Sum a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606160Sym1 a6989586621679606165 :: TyFun (Sum a) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680194492Sym1 a6989586621680194499 :: TyFun (Sum a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680194540Sym1 a6989586621680194547 :: TyFun (Sum a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680194520Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Sum a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194505Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Sum a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679624696Sym0 :: TyFun (a ~> b) (Sum a ~> Sum b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194432Sym0 :: TyFun (a ~> m) (Sum a ~> m) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680194478Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Sum a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194463Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Sum a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624707Sym0 :: TyFun a (Sum b ~> Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679624696Sym1 a6989586621679624701 :: TyFun (Sum a) (Sum b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624685Sym1 a6989586621679624690 :: TyFun (Sum a) (Sum b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194432Sym1 a6989586621680194437 :: TyFun (Sum a) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624707Sym1 a6989586621679624712 :: TyFun (Sum b) (Sum a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624722Sym1 a6989586621679624727 :: TyFun (a ~> Sum b) (Sum b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478780Sym0 :: TyFun (a ~> f b) (Sum a ~> f (Sum b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680194478Sym1 a6989586621680194484 :: TyFun b (Sum a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194463Sym1 a6989586621680194469 :: TyFun b (Sum a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680194520Sym1 a6989586621680194532 :: TyFun b (Sum a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194505Sym1 a6989586621680194511 :: TyFun b (Sum a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680194478Sym2 a6989586621680194484 a6989586621680194485 :: TyFun (Sum a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194463Sym2 a6989586621680194469 a6989586621680194470 :: TyFun (Sum a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680194520Sym2 a6989586621680194532 a6989586621680194533 :: TyFun (Sum a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194505Sym2 a6989586621680194511 a6989586621680194512 :: TyFun (Sum a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478780Sym1 a6989586621680478785 :: TyFun (Sum a) (f (Sum b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680194456Sym0 :: TyFun k1 (TyFun k2 (TyFun (b ~> c) (Sum b ~> c) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680194456Sym1 a_69895866216801944456989586621680194454 :: TyFun k2 (TyFun (b ~> c) (Sum b ~> c) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680194456Sym2 a_69895866216801944456989586621680194454 a_69895866216801944476989586621680194455 :: TyFun (b ~> c) (Sum b ~> c) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
type Rep Sum
Instance details Defined in Data.Functor.Rep type Rep Sum = ()
type Pure (a :: k1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Pure (a :: k1) = Apply (Pure_6989586621679624675Sym0 :: TyFun k1 (Sum k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (Sum a) -> Type) arg
type Fold (arg :: Sum m)
Instance details Defined in Data.Foldable.Singletons type Fold (arg :: Sum m) = Apply (Fold_6989586621680193565Sym0 :: TyFun (Sum m) m -> Type) arg
type Length (a2 :: Sum a1)
Instance details Defined in Data.Foldable.Singletons type Length (a2 :: Sum a1) = Apply (Length_6989586621680194551Sym0 :: TyFun (Sum a1) Nat -> Type) a2
type Maximum (a :: Sum k2)
Instance details Defined in Data.Foldable.Singletons type Maximum (a :: Sum k2) = Apply (Maximum_6989586621680194557Sym0 :: TyFun (Sum k2) k2 -> Type) a
type Minimum (a :: Sum k2)
Instance details Defined in Data.Foldable.Singletons type Minimum (a :: Sum k2) = Apply (Minimum_6989586621680194566Sym0 :: TyFun (Sum k2) k2 -> Type) a
type Null (a2 :: Sum a1)
Instance details Defined in Data.Foldable.Singletons type Null (a2 :: Sum a1) = Apply (Null_6989586621680194575Sym0 :: TyFun (Sum a1) Bool -> Type) a2
type Product (a :: Sum k2)
Instance details Defined in Data.Foldable.Singletons type Product (a :: Sum k2) = Apply (Product_6989586621680194581Sym0 :: TyFun (Sum k2) k2 -> Type) a
type Sum (a :: Sum k2)
Instance details Defined in Data.Foldable.Singletons type Sum (a :: Sum k2) = Apply (Sum_6989586621680194590Sym0 :: TyFun (Sum k2) k2 -> Type) a
type ToList (a2 :: Sum a1)
Instance details Defined in Data.Foldable.Singletons type ToList (a2 :: Sum a1) = Apply (ToList_6989586621680194599Sym0 :: TyFun (Sum a1) [a1] -> Type) a2
type Elem (a1 :: k1) (a2 :: Sum k1)
Instance details Defined in Data.Foldable.Singletons type Elem (a1 :: k1) (a2 :: Sum k1) = Apply (Apply (Elem_6989586621680194443Sym0 :: TyFun k1 (Sum k1 ~> Bool) -> Type) a1) a2
type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Sum k2)
Instance details Defined in Data.Foldable.Singletons type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Sum k2) = Apply (Apply (Foldl1_6989586621680194492Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (Sum k2 ~> k2) -> Type) a1) a2
type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Sum k2)
Instance details Defined in Data.Foldable.Singletons type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Sum k2) = Apply (Apply (Foldr1_6989586621680194540Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (Sum k2 ~> k2) -> Type) a1) a2
type Sequence (arg :: Sum (m a))
Instance details Defined in Data.Traversable.Singletons type Sequence (arg :: Sum (m a)) = Apply (Sequence_6989586621680471117Sym0 :: TyFun (Sum (m a)) (m (Sum a)) -> Type) arg
type SequenceA (arg :: Sum (f a))
Instance details Defined in Data.Traversable.Singletons type SequenceA (arg :: Sum (f a)) = Apply (SequenceA_6989586621680471093Sym0 :: TyFun (Sum (f a)) (f (Sum a)) -> Type) arg
type (arg :: Sum a) *> (arg1 :: Sum b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Sum a) *> (arg1 :: Sum b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (Sum a) (Sum b ~> Sum b) -> Type) arg) arg1
type (a1 :: k1) <$ (a2 :: Sum b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a1 :: k1) <$ (a2 :: Sum b) = Apply (Apply (TFHelper_6989586621679624707Sym0 :: TyFun k1 (Sum b ~> Sum k1) -> Type) a1) a2
type (arg :: Sum a) <* (arg1 :: Sum b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Sum a) <* (arg1 :: Sum b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (Sum a) (Sum b ~> Sum a) -> Type) arg) arg1
type (a2 :: Sum (a1 ~> b)) <*> (a3 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Sum (a1 ~> b)) <*> (a3 :: Sum a1) = Apply (Apply (TFHelper_6989586621679624685Sym0 :: TyFun (Sum (a1 ~> b)) (Sum a1 ~> Sum b) -> Type) a2) a3
type (arg :: Sum a) >> (arg1 :: Sum b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Sum a) >> (arg1 :: Sum b) = Apply (Apply (TFHelper_6989586621679287148Sym0 :: TyFun (Sum a) (Sum b ~> Sum b) -> Type) arg) arg1
type (a2 :: Sum a1) >>= (a3 :: a1 ~> Sum b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Sum a1) >>= (a3 :: a1 ~> Sum b) = Apply (Apply (TFHelper_6989586621679624722Sym0 :: TyFun (Sum a1) ((a1 ~> Sum b) ~> Sum b) -> Type) a2) a3
type Fmap (a2 :: a1 ~> b) (a3 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Fmap (a2 :: a1 ~> b) (a3 :: Sum a1) = Apply (Apply (Fmap_6989586621679624696Sym0 :: TyFun (a1 ~> b) (Sum a1 ~> Sum b) -> Type) a2) a3
type FoldMap (a2 :: a1 ~> k2) (a3 :: Sum a1)
Instance details Defined in Data.Foldable.Singletons type FoldMap (a2 :: a1 ~> k2) (a3 :: Sum a1) = Apply (Apply (FoldMap_6989586621680194432Sym0 :: TyFun (a1 ~> k2) (Sum a1 ~> k2) -> Type) a2) a3
type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Sum a1)
Instance details Defined in Data.Foldable.Singletons type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Sum a1) = Apply (Apply (Apply (Foldl_6989586621680194463Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (Sum a1 ~> k2)) -> Type) a2) a3) a4
type Foldl' (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Sum a1)
Instance details Defined in Data.Foldable.Singletons type Foldl' (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Sum a1) = Apply (Apply (Apply (Foldl'_6989586621680194478Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (Sum a1 ~> k2)) -> Type) a2) a3) a4
type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Sum a1)
Instance details Defined in Data.Foldable.Singletons type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Sum a1) = Apply (Apply (Apply (Foldr_6989586621680194505Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Sum a1 ~> k2)) -> Type) a2) a3) a4
type Foldr' (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Sum a1)
Instance details Defined in Data.Foldable.Singletons type Foldr' (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Sum a1) = Apply (Apply (Apply (Foldr'_6989586621680194520Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Sum a1 ~> k2)) -> Type) a2) a3) a4
type MapM (arg1 :: a ~> m b) (arg2 :: Sum a)
Instance details Defined in Data.Traversable.Singletons type MapM (arg1 :: a ~> m b) (arg2 :: Sum a) = Apply (Apply (MapM_6989586621680471103Sym0 :: TyFun (a ~> m b) (Sum a ~> m (Sum b)) -> Type) arg1) arg2
type Traverse (a2 :: a1 ~> f b) (a3 :: Sum a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a2 :: a1 ~> f b) (a3 :: Sum a1) = Apply (Apply (Traverse_6989586621680478780Sym0 :: TyFun (a1 ~> f b) (Sum a1 ~> f (Sum b)) -> Type) a2) a3
type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Sum a) (arg2 :: Sum b)
Instance details Defined in Data.Semigroup.Singletons.Internal type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Sum a) (arg2 :: Sum b) = Apply (Apply (Apply (LiftA2_6989586621679287093Sym0 :: TyFun (a ~> (b ~> c)) (Sum a ~> (Sum b ~> Sum c)) -> Type) arg) arg1) arg2
newtype MVector s (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Sum a) = MV_Sum (MVector s a)
type Apply (FromInteger_6989586621679624820Sym0 :: TyFun Nat (Sum a) -> Type) (a6989586621679624824 :: Nat)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (FromInteger_6989586621679624820Sym0 :: TyFun Nat (Sum a) -> Type) (a6989586621679624824 :: Nat) = FromInteger_6989586621679624820 a6989586621679624824 :: Sum a
type Apply (Pure_6989586621679624675Sym0 :: TyFun a (Sum a) -> Type) (a6989586621679624681 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Pure_6989586621679624675Sym0 :: TyFun a (Sum a) -> Type) (a6989586621679624681 :: a) = Pure_6989586621679624675 a6989586621679624681
type Apply (SumSym0 :: TyFun a (Sum a) -> Type) (a6989586621679596414 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (SumSym0 :: TyFun a (Sum a) -> Type) (a6989586621679596414 :: a) = 'Sum a6989586621679596414
type Apply (Sum_Sym0 :: TyFun a (Sum a) -> Type) (a6989586621679713085 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation type Apply (Sum_Sym0 :: TyFun a (Sum a) -> Type) (a6989586621679713085 :: a) = Sum_ a6989586621679713085
type Apply (ShowsPrec_6989586621680582255Sym0 :: TyFun Nat (Sum a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680582263 :: Nat)
Instance details Defined in Data.Semigroup.Singletons type Apply (ShowsPrec_6989586621680582255Sym0 :: TyFun Nat (Sum a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680582263 :: Nat) = ShowsPrec_6989586621680582255Sym1 a6989586621680582263 :: TyFun (Sum a) (Symbol ~> Symbol) -> Type
type Apply (Elem_6989586621680194443Sym0 :: TyFun a (Sum a ~> Bool) -> Type) (a6989586621680194452 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194443Sym0 :: TyFun a (Sum a ~> Bool) -> Type) (a6989586621680194452 :: a) = Elem_6989586621680194443Sym1 a6989586621680194452
type Apply (TFHelper_6989586621679624707Sym0 :: TyFun a (Sum b ~> Sum a) -> Type) (a6989586621679624712 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624707Sym0 :: TyFun a (Sum b ~> Sum a) -> Type) (a6989586621679624712 :: a) = TFHelper_6989586621679624707Sym1 a6989586621679624712 :: TyFun (Sum b) (Sum a) -> Type
type Apply (Foldl'_6989586621680194478Sym1 a6989586621680194484 :: TyFun b (Sum a ~> b) -> Type) (a6989586621680194485 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl'_6989586621680194478Sym1 a6989586621680194484 :: TyFun b (Sum a ~> b) -> Type) (a6989586621680194485 :: b) = Foldl'_6989586621680194478Sym2 a6989586621680194484 a6989586621680194485
type Apply (Foldl_6989586621680194463Sym1 a6989586621680194469 :: TyFun b (Sum a ~> b) -> Type) (a6989586621680194470 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194463Sym1 a6989586621680194469 :: TyFun b (Sum a ~> b) -> Type) (a6989586621680194470 :: b) = Foldl_6989586621680194463Sym2 a6989586621680194469 a6989586621680194470
type Apply (Foldr'_6989586621680194520Sym1 a6989586621680194532 :: TyFun b (Sum a ~> b) -> Type) (a6989586621680194533 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr'_6989586621680194520Sym1 a6989586621680194532 :: TyFun b (Sum a ~> b) -> Type) (a6989586621680194533 :: b) = Foldr'_6989586621680194520Sym2 a6989586621680194532 a6989586621680194533
type Apply (Foldr_6989586621680194505Sym1 a6989586621680194511 :: TyFun b (Sum a ~> b) -> Type) (a6989586621680194512 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194505Sym1 a6989586621680194511 :: TyFun b (Sum a ~> b) -> Type) (a6989586621680194512 :: b) = Foldr_6989586621680194505Sym2 a6989586621680194511 a6989586621680194512
type Apply (Lambda_6989586621680194456Sym0 :: TyFun k1 (TyFun k2 (TyFun (b ~> c) (Sum b ~> c) -> Type) -> Type) -> Type) (a_69895866216801944456989586621680194454 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680194456Sym0 :: TyFun k1 (TyFun k2 (TyFun (b ~> c) (Sum b ~> c) -> Type) -> Type) -> Type) (a_69895866216801944456989586621680194454 :: k1) = Lambda_6989586621680194456Sym1 a_69895866216801944456989586621680194454 :: TyFun k2 (TyFun (b ~> c) (Sum b ~> c) -> Type) -> Type
type Apply (Lambda_6989586621680194456Sym1 a_69895866216801944456989586621680194454 :: TyFun k2 (TyFun (b ~> c) (Sum b ~> c) -> Type) -> Type) (a_69895866216801944476989586621680194455 :: k2)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680194456Sym1 a_69895866216801944456989586621680194454 :: TyFun k2 (TyFun (b ~> c) (Sum b ~> c) -> Type) -> Type) (a_69895866216801944476989586621680194455 :: k2) = Lambda_6989586621680194456Sym2 a_69895866216801944456989586621680194454 a_69895866216801944476989586621680194455 :: TyFun (b ~> c) (Sum b ~> c) -> Type
type Rep (Sum a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal type Rep (Sum a) = D1 ('MetaData "Sum" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "Sum" 'PrefixI 'True) (S1 ('MetaSel ('Just "getSum") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Unwrapped (Sum a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Sum a) = a
type Demote (Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Demote (Sum a) = Sum (Demote a)
type Sing
Instance details Defined in Data.Semigroup.Singletons.Internal type Sing = SSum :: Sum a -> Type
type Mempty
Instance details Defined in Data.Monoid.Singletons type Mempty = Mempty_6989586621680118255Sym0 :: Sum a
type MaxBound
Instance details Defined in Data.Semigroup.Singletons.Internal type MaxBound = MaxBound_6989586621679603380Sym0 :: Sum a
type MinBound
Instance details Defined in Data.Semigroup.Singletons.Internal type MinBound = MinBound_6989586621679603377Sym0 :: Sum a
type Element (Sum a)
Instance details Defined in Universum.Container.Class type Element (Sum a) = ElementDefault (Sum a)
newtype Vector (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Sum a) = V_Sum (Vector a)
type Rep1 Sum	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal type Rep1 Sum = D1 ('MetaData "Sum" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "Sum" 'PrefixI 'True) (S1 ('MetaSel ('Just "getSum") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type Mconcat (arg :: [Sum a])
Instance details Defined in Data.Monoid.Singletons type Mconcat (arg :: [Sum a]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [Sum a] (Sum a) -> Type) arg
type Sconcat (arg :: NonEmpty (Sum a))
Instance details Defined in Data.Semigroup.Singletons.Internal type Sconcat (arg :: NonEmpty (Sum a)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (Sum a)) (Sum a) -> Type) arg
type Abs (a2 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Abs (a2 :: Sum a1) = Apply (Abs_6989586621679624806Sym0 :: TyFun (Sum a1) (Sum a1) -> Type) a2
type FromInteger a2
Instance details Defined in Data.Semigroup.Singletons.Internal type FromInteger a2 = Apply (FromInteger_6989586621679624820Sym0 :: TyFun Nat (Sum a1) -> Type) a2
type Negate (a2 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Negate (a2 :: Sum a1) = Apply (Negate_6989586621679624799Sym0 :: TyFun (Sum a1) (Sum a1) -> Type) a2
type Signum (a2 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Signum (a2 :: Sum a1) = Apply (Signum_6989586621679624813Sym0 :: TyFun (Sum a1) (Sum a1) -> Type) a2
type Show_ (arg :: Sum a)
Instance details Defined in Data.Semigroup.Singletons type Show_ (arg :: Sum a) = Apply (Show__6989586621680047550Sym0 :: TyFun (Sum a) Symbol -> Type) arg
type (arg :: Sum a) /= (arg1 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Sum a) /= (arg1 :: Sum a) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type) arg) arg1
type (a2 :: Sum a1) == (a3 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Sum a1) == (a3 :: Sum a1) = Apply (Apply (TFHelper_6989586621679606160Sym0 :: TyFun (Sum a1) (Sum a1 ~> Bool) -> Type) a2) a3
type Mappend (arg1 :: Sum a) (arg2 :: Sum a)
Instance details Defined in Data.Monoid.Singletons type Mappend (arg1 :: Sum a) (arg2 :: Sum a) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) arg1) arg2
type (arg :: Sum a) < (arg1 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Sum a) < (arg1 :: Sum a) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type) arg) arg1
type (arg :: Sum a) <= (arg1 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Sum a) <= (arg1 :: Sum a) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type) arg) arg1
type (arg :: Sum a) > (arg1 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Sum a) > (arg1 :: Sum a) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type) arg) arg1
type (arg :: Sum a) >= (arg1 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Sum a) >= (arg1 :: Sum a) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type) arg) arg1
type Compare (a2 :: Sum a1) (a3 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Compare (a2 :: Sum a1) (a3 :: Sum a1) = Apply (Apply (Compare_6989586621679613621Sym0 :: TyFun (Sum a1) (Sum a1 ~> Ordering) -> Type) a2) a3
type Max (arg :: Sum a) (arg1 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Max (arg :: Sum a) (arg1 :: Sum a) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) arg) arg1
type Min (arg :: Sum a) (arg1 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Min (arg :: Sum a) (arg1 :: Sum a) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) arg) arg1
type (a2 :: Sum a1) <> (a3 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Sum a1) <> (a3 :: Sum a1) = Apply (Apply (TFHelper_6989586621679624733Sym0 :: TyFun (Sum a1) (Sum a1 ~> Sum a1) -> Type) a2) a3
type (a2 :: Sum a1) * (a3 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Sum a1) * (a3 :: Sum a1) = Apply (Apply (TFHelper_6989586621679624789Sym0 :: TyFun (Sum a1) (Sum a1 ~> Sum a1) -> Type) a2) a3
type (a2 :: Sum a1) + (a3 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Sum a1) + (a3 :: Sum a1) = Apply (Apply (TFHelper_6989586621679624767Sym0 :: TyFun (Sum a1) (Sum a1 ~> Sum a1) -> Type) a2) a3
type (a2 :: Sum a1) - (a3 :: Sum a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Sum a1) - (a3 :: Sum a1) = Apply (Apply (TFHelper_6989586621679624778Sym0 :: TyFun (Sum a1) (Sum a1 ~> Sum a1) -> Type) a2) a3
type ShowList (arg :: [Sum a]) arg1
Instance details Defined in Data.Semigroup.Singletons type ShowList (arg :: [Sum a]) arg1 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Sum a] (Symbol ~> Symbol) -> Type) arg) arg1
type HKD Sum (a :: Type)
Instance details Defined in Data.Vinyl.XRec type HKD Sum (a :: Type) = a
type ShowsPrec a2 (a3 :: Sum a1) a4
Instance details Defined in Data.Semigroup.Singletons type ShowsPrec a2 (a3 :: Sum a1) a4 = Apply (Apply (Apply (ShowsPrec_6989586621680582255Sym0 :: TyFun Nat (Sum a1 ~> (Symbol ~> Symbol)) -> Type) a2) a3) a4
type Apply (Null_6989586621680194575Sym0 :: TyFun (Sum a) Bool -> Type) (a6989586621680194579 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680194575Sym0 :: TyFun (Sum a) Bool -> Type) (a6989586621680194579 :: Sum a) = Null_6989586621680194575 a6989586621680194579
type Apply (Length_6989586621680194551Sym0 :: TyFun (Sum a) Nat -> Type) (a6989586621680194555 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Length_6989586621680194551Sym0 :: TyFun (Sum a) Nat -> Type) (a6989586621680194555 :: Sum a) = Length_6989586621680194551 a6989586621680194555
type Apply (Maximum_6989586621680194557Sym0 :: TyFun (Sum a) a -> Type) (a6989586621680194563 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Maximum_6989586621680194557Sym0 :: TyFun (Sum a) a -> Type) (a6989586621680194563 :: Sum a) = Maximum_6989586621680194557 a6989586621680194563
type Apply (Minimum_6989586621680194566Sym0 :: TyFun (Sum a) a -> Type) (a6989586621680194572 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Minimum_6989586621680194566Sym0 :: TyFun (Sum a) a -> Type) (a6989586621680194572 :: Sum a) = Minimum_6989586621680194566 a6989586621680194572
type Apply (Product_6989586621680194581Sym0 :: TyFun (Sum a) a -> Type) (a6989586621680194587 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Product_6989586621680194581Sym0 :: TyFun (Sum a) a -> Type) (a6989586621680194587 :: Sum a) = Product_6989586621680194581 a6989586621680194587
type Apply (Sum_6989586621680194590Sym0 :: TyFun (Sum a) a -> Type) (a6989586621680194596 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Sum_6989586621680194590Sym0 :: TyFun (Sum a) a -> Type) (a6989586621680194596 :: Sum a) = Sum_6989586621680194590 a6989586621680194596
type Apply (GetSumSym0 :: TyFun (Sum a) a -> Type) (a6989586621679596417 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (GetSumSym0 :: TyFun (Sum a) a -> Type) (a6989586621679596417 :: Sum a) = GetSum a6989586621679596417
type Apply (Compare_6989586621679613621Sym1 a6989586621679613626 :: TyFun (Sum a) Ordering -> Type) (a6989586621679613627 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613621Sym1 a6989586621679613626 :: TyFun (Sum a) Ordering -> Type) (a6989586621679613627 :: Sum a) = Compare_6989586621679613621 a6989586621679613626 a6989586621679613627
type Apply (Elem_6989586621680194443Sym1 a6989586621680194452 :: TyFun (Sum a) Bool -> Type) (a6989586621680194453 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194443Sym1 a6989586621680194452 :: TyFun (Sum a) Bool -> Type) (a6989586621680194453 :: Sum a) = Elem_6989586621680194443 a6989586621680194452 a6989586621680194453
type Apply (TFHelper_6989586621679606160Sym1 a6989586621679606165 :: TyFun (Sum a) Bool -> Type) (a6989586621679606166 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606160Sym1 a6989586621679606165 :: TyFun (Sum a) Bool -> Type) (a6989586621679606166 :: Sum a) = TFHelper_6989586621679606160 a6989586621679606165 a6989586621679606166
type Apply (Foldl1_6989586621680194492Sym1 a6989586621680194499 :: TyFun (Sum a) a -> Type) (a6989586621680194500 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl1_6989586621680194492Sym1 a6989586621680194499 :: TyFun (Sum a) a -> Type) (a6989586621680194500 :: Sum a) = Foldl1_6989586621680194492 a6989586621680194499 a6989586621680194500
type Apply (Foldr1_6989586621680194540Sym1 a6989586621680194547 :: TyFun (Sum a) a -> Type) (a6989586621680194548 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr1_6989586621680194540Sym1 a6989586621680194547 :: TyFun (Sum a) a -> Type) (a6989586621680194548 :: Sum a) = Foldr1_6989586621680194540 a6989586621680194547 a6989586621680194548
type Apply (FoldMap_6989586621680194432Sym1 a6989586621680194437 :: TyFun (Sum a) m -> Type) (a6989586621680194438 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194432Sym1 a6989586621680194437 :: TyFun (Sum a) m -> Type) (a6989586621680194438 :: Sum a) = FoldMap_6989586621680194432 a6989586621680194437 a6989586621680194438
type Apply (Foldl'_6989586621680194478Sym2 a6989586621680194484 a6989586621680194485 :: TyFun (Sum a) b -> Type) (a6989586621680194486 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl'_6989586621680194478Sym2 a6989586621680194484 a6989586621680194485 :: TyFun (Sum a) b -> Type) (a6989586621680194486 :: Sum a) = Foldl'_6989586621680194478 a6989586621680194484 a6989586621680194485 a6989586621680194486
type Apply (Foldl_6989586621680194463Sym2 a6989586621680194469 a6989586621680194470 :: TyFun (Sum a) b -> Type) (a6989586621680194471 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194463Sym2 a6989586621680194469 a6989586621680194470 :: TyFun (Sum a) b -> Type) (a6989586621680194471 :: Sum a) = Foldl_6989586621680194463 a6989586621680194469 a6989586621680194470 a6989586621680194471
type Apply (Foldr'_6989586621680194520Sym2 a6989586621680194532 a6989586621680194533 :: TyFun (Sum a) b -> Type) (a6989586621680194534 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr'_6989586621680194520Sym2 a6989586621680194532 a6989586621680194533 :: TyFun (Sum a) b -> Type) (a6989586621680194534 :: Sum a) = Foldr'_6989586621680194520 a6989586621680194532 a6989586621680194533 a6989586621680194534
type Apply (Foldr_6989586621680194505Sym2 a6989586621680194511 a6989586621680194512 :: TyFun (Sum a) b -> Type) (a6989586621680194513 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194505Sym2 a6989586621680194511 a6989586621680194512 :: TyFun (Sum a) b -> Type) (a6989586621680194513 :: Sum a) = Foldr_6989586621680194505 a6989586621680194511 a6989586621680194512 a6989586621680194513
type Apply (Abs_6989586621679624806Sym0 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624810 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Abs_6989586621679624806Sym0 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624810 :: Sum a) = Abs_6989586621679624806 a6989586621679624810
type Apply (Negate_6989586621679624799Sym0 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624803 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Negate_6989586621679624799Sym0 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624803 :: Sum a) = Negate_6989586621679624799 a6989586621679624803
type Apply (Signum_6989586621679624813Sym0 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624817 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Signum_6989586621679624813Sym0 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624817 :: Sum a) = Signum_6989586621679624813 a6989586621679624817
type Apply (ToList_6989586621680194599Sym0 :: TyFun (Sum a) [a] -> Type) (a6989586621680194603 :: Sum a)
Instance details Defined in Data.Foldable.Singletons type Apply (ToList_6989586621680194599Sym0 :: TyFun (Sum a) [a] -> Type) (a6989586621680194603 :: Sum a) = ToList_6989586621680194599 a6989586621680194603
type Apply (TFHelper_6989586621679624733Sym1 a6989586621679624738 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624739 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624733Sym1 a6989586621679624738 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624739 :: Sum a) = TFHelper_6989586621679624733 a6989586621679624738 a6989586621679624739
type Apply (TFHelper_6989586621679624767Sym1 a6989586621679624772 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624773 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624767Sym1 a6989586621679624772 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624773 :: Sum a) = TFHelper_6989586621679624767 a6989586621679624772 a6989586621679624773
type Apply (TFHelper_6989586621679624778Sym1 a6989586621679624783 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624784 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624778Sym1 a6989586621679624783 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624784 :: Sum a) = TFHelper_6989586621679624778 a6989586621679624783 a6989586621679624784
type Apply (TFHelper_6989586621679624789Sym1 a6989586621679624794 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624795 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624789Sym1 a6989586621679624794 :: TyFun (Sum a) (Sum a) -> Type) (a6989586621679624795 :: Sum a) = TFHelper_6989586621679624789 a6989586621679624794 a6989586621679624795
type Apply (Fmap_6989586621679624696Sym1 a6989586621679624701 :: TyFun (Sum a) (Sum b) -> Type) (a6989586621679624702 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Fmap_6989586621679624696Sym1 a6989586621679624701 :: TyFun (Sum a) (Sum b) -> Type) (a6989586621679624702 :: Sum a) = Fmap_6989586621679624696 a6989586621679624701 a6989586621679624702
type Apply (TFHelper_6989586621679624685Sym1 a6989586621679624690 :: TyFun (Sum a) (Sum b) -> Type) (a6989586621679624691 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624685Sym1 a6989586621679624690 :: TyFun (Sum a) (Sum b) -> Type) (a6989586621679624691 :: Sum a) = TFHelper_6989586621679624685 a6989586621679624690 a6989586621679624691
type Apply (TFHelper_6989586621679624707Sym1 a6989586621679624712 :: TyFun (Sum b) (Sum a) -> Type) (a6989586621679624713 :: Sum b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624707Sym1 a6989586621679624712 :: TyFun (Sum b) (Sum a) -> Type) (a6989586621679624713 :: Sum b) = TFHelper_6989586621679624707 a6989586621679624712 a6989586621679624713
type Apply (Traverse_6989586621680478780Sym1 a6989586621680478785 :: TyFun (Sum a) (f (Sum b)) -> Type) (a6989586621680478786 :: Sum a)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478780Sym1 a6989586621680478785 :: TyFun (Sum a) (f (Sum b)) -> Type) (a6989586621680478786 :: Sum a) = Traverse_6989586621680478780 a6989586621680478785 a6989586621680478786
type Apply (TFHelper_6989586621679624733Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) (a6989586621679624738 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624733Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) (a6989586621679624738 :: Sum a) = TFHelper_6989586621679624733Sym1 a6989586621679624738
type Apply (TFHelper_6989586621679624767Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) (a6989586621679624772 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624767Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) (a6989586621679624772 :: Sum a) = TFHelper_6989586621679624767Sym1 a6989586621679624772
type Apply (TFHelper_6989586621679624778Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) (a6989586621679624783 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624778Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) (a6989586621679624783 :: Sum a) = TFHelper_6989586621679624778Sym1 a6989586621679624783
type Apply (TFHelper_6989586621679624789Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) (a6989586621679624794 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624789Sym0 :: TyFun (Sum a) (Sum a ~> Sum a) -> Type) (a6989586621679624794 :: Sum a) = TFHelper_6989586621679624789Sym1 a6989586621679624794
type Apply (Compare_6989586621679613621Sym0 :: TyFun (Sum a) (Sum a ~> Ordering) -> Type) (a6989586621679613626 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613621Sym0 :: TyFun (Sum a) (Sum a ~> Ordering) -> Type) (a6989586621679613626 :: Sum a) = Compare_6989586621679613621Sym1 a6989586621679613626
type Apply (TFHelper_6989586621679606160Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type) (a6989586621679606165 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606160Sym0 :: TyFun (Sum a) (Sum a ~> Bool) -> Type) (a6989586621679606165 :: Sum a) = TFHelper_6989586621679606160Sym1 a6989586621679606165
type Apply (TFHelper_6989586621679624685Sym0 :: TyFun (Sum (a ~> b)) (Sum a ~> Sum b) -> Type) (a6989586621679624690 :: Sum (a ~> b))
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624685Sym0 :: TyFun (Sum (a ~> b)) (Sum a ~> Sum b) -> Type) (a6989586621679624690 :: Sum (a ~> b)) = TFHelper_6989586621679624685Sym1 a6989586621679624690
type Apply (TFHelper_6989586621679624722Sym0 :: TyFun (Sum a) ((a ~> Sum b) ~> Sum b) -> Type) (a6989586621679624727 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624722Sym0 :: TyFun (Sum a) ((a ~> Sum b) ~> Sum b) -> Type) (a6989586621679624727 :: Sum a) = TFHelper_6989586621679624722Sym1 a6989586621679624727 :: TyFun (a ~> Sum b) (Sum b) -> Type
type Apply (ShowsPrec_6989586621680582255Sym1 a6989586621680582263 :: TyFun (Sum a) (Symbol ~> Symbol) -> Type) (a6989586621680582264 :: Sum a)
Instance details Defined in Data.Semigroup.Singletons type Apply (ShowsPrec_6989586621680582255Sym1 a6989586621680582263 :: TyFun (Sum a) (Symbol ~> Symbol) -> Type) (a6989586621680582264 :: Sum a) = ShowsPrec_6989586621680582255Sym2 a6989586621680582263 a6989586621680582264
type Apply (TFHelper_6989586621679624722Sym1 a6989586621679624727 :: TyFun (a ~> Sum b) (Sum b) -> Type) (a6989586621679624728 :: a ~> Sum b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624722Sym1 a6989586621679624727 :: TyFun (a ~> Sum b) (Sum b) -> Type) (a6989586621679624728 :: a ~> Sum b) = TFHelper_6989586621679624722 a6989586621679624727 a6989586621679624728
type Apply (Foldl1_6989586621680194492Sym0 :: TyFun (a ~> (a ~> a)) (Sum a ~> a) -> Type) (a6989586621680194499 :: a ~> (a ~> a))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl1_6989586621680194492Sym0 :: TyFun (a ~> (a ~> a)) (Sum a ~> a) -> Type) (a6989586621680194499 :: a ~> (a ~> a)) = Foldl1_6989586621680194492Sym1 a6989586621680194499
type Apply (Foldr1_6989586621680194540Sym0 :: TyFun (a ~> (a ~> a)) (Sum a ~> a) -> Type) (a6989586621680194547 :: a ~> (a ~> a))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr1_6989586621680194540Sym0 :: TyFun (a ~> (a ~> a)) (Sum a ~> a) -> Type) (a6989586621680194547 :: a ~> (a ~> a)) = Foldr1_6989586621680194540Sym1 a6989586621680194547
type Apply (Foldr'_6989586621680194520Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Sum a ~> b)) -> Type) (a6989586621680194532 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr'_6989586621680194520Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Sum a ~> b)) -> Type) (a6989586621680194532 :: a ~> (b ~> b)) = Foldr'_6989586621680194520Sym1 a6989586621680194532
type Apply (Foldr_6989586621680194505Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Sum a ~> b)) -> Type) (a6989586621680194511 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194505Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Sum a ~> b)) -> Type) (a6989586621680194511 :: a ~> (b ~> b)) = Foldr_6989586621680194505Sym1 a6989586621680194511
type Apply (Fmap_6989586621679624696Sym0 :: TyFun (a ~> b) (Sum a ~> Sum b) -> Type) (a6989586621679624701 :: a ~> b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Fmap_6989586621679624696Sym0 :: TyFun (a ~> b) (Sum a ~> Sum b) -> Type) (a6989586621679624701 :: a ~> b) = Fmap_6989586621679624696Sym1 a6989586621679624701
type Apply (FoldMap_6989586621680194432Sym0 :: TyFun (a ~> m) (Sum a ~> m) -> Type) (a6989586621680194437 :: a ~> m)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194432Sym0 :: TyFun (a ~> m) (Sum a ~> m) -> Type) (a6989586621680194437 :: a ~> m) = FoldMap_6989586621680194432Sym1 a6989586621680194437
type Apply (Foldl'_6989586621680194478Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Sum a ~> b)) -> Type) (a6989586621680194484 :: b ~> (a ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl'_6989586621680194478Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Sum a ~> b)) -> Type) (a6989586621680194484 :: b ~> (a ~> b)) = Foldl'_6989586621680194478Sym1 a6989586621680194484
type Apply (Foldl_6989586621680194463Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Sum a ~> b)) -> Type) (a6989586621680194469 :: b ~> (a ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194463Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Sum a ~> b)) -> Type) (a6989586621680194469 :: b ~> (a ~> b)) = Foldl_6989586621680194463Sym1 a6989586621680194469
type Apply (Traverse_6989586621680478780Sym0 :: TyFun (a ~> f b) (Sum a ~> f (Sum b)) -> Type) (a6989586621680478785 :: a ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478780Sym0 :: TyFun (a ~> f b) (Sum a ~> f (Sum b)) -> Type) (a6989586621680478785 :: a ~> f b) = Traverse_6989586621680478780Sym1 a6989586621680478785
type Apply (Lambda_6989586621680194456Sym2 a_69895866216801944456989586621680194454 a_69895866216801944476989586621680194455 :: TyFun (b ~> c) (Sum b ~> c) -> Type) (lhs_69895866216801931186989586621680194458 :: b ~> c)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680194456Sym2 a_69895866216801944456989586621680194454 a_69895866216801944476989586621680194455 :: TyFun (b ~> c) (Sum b ~> c) -> Type) (lhs_69895866216801931186989586621680194458 :: b ~> c) = Lambda_6989586621680194456 a_69895866216801944456989586621680194454 a_69895866216801944476989586621680194455 lhs_69895866216801931186989586621680194458

newtype Product a #

Monoid under multiplication.

>>> getProduct (Product 3 <> Product 4 <> mempty)
12

Constructors

Product
Fields getProduct :: a

Instances

Instances details

Representable Product
Instance details Defined in Data.Functor.Rep Associated Types type Rep Product # Methods tabulate :: (Rep Product -> a) -> Product a # index :: Product a -> Rep Product -> a #
Foldable Product	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m # foldMap :: Monoid m => (a -> m) -> Product a -> m # foldMap' :: Monoid m => (a -> m) -> Product a -> m # foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b # foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b # foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # toList :: Product a -> [a] # null :: Product a -> Bool # length :: Product a -> Int # elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # sum :: Num a => Product a -> a # product :: Num a => Product a -> a #
Traversable Product	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) # sequenceA :: Applicative f => Product (f a) -> f (Product a) # mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) # sequence :: Monad m => Product (m a) -> m (Product a) #
Applicative Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Product a # (<>) :: Product (a -> b) -> Product a -> Product b # liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c # (>) :: Product a -> Product b -> Product b # (<*) :: Product a -> Product b -> Product a #
Functor Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Product a -> Product b # (<$) :: a -> Product b -> Product a #
Monad Product	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Product a -> (a -> Product b) -> Product b # (>>) :: Product a -> Product b -> Product b # return :: a -> Product a #
NFData1 Product	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Product a -> () #
PFoldable Product
Instance details Defined in Data.Foldable.Singletons Associated Types type Fold arg :: m # type FoldMap arg arg1 :: m # type Foldr arg arg1 arg2 :: b # type Foldr' arg arg1 arg2 :: b # type Foldl arg arg1 arg2 :: b # type Foldl' arg arg1 arg2 :: b # type Foldr1 arg arg1 :: a # type Foldl1 arg arg1 :: a # type ToList arg :: [a] # type Null arg :: Bool # type Length arg :: Nat # type Elem arg arg1 :: Bool # type Maximum arg :: a # type Minimum arg :: a # type Sum arg :: a # type Product arg :: a #
SFoldable Product
Instance details Defined in Data.Foldable.Singletons Methods sFold :: forall m (t1 :: Product m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a m (t1 :: a ~> m) (t2 :: Product a). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Product a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Product a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Product a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Product a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Product a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Product a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a (t1 :: Product a). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a (t1 :: Product a). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a (t1 :: Product a). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a (t1 :: a) (t2 :: Product a). SEq a => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a (t1 :: Product a). SOrd a => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a (t1 :: Product a). SOrd a => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a (t1 :: Product a). SNum a => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a (t1 :: Product a). SNum a => Sing t1 -> Sing (Apply ProductSym0 t1) #
PTraversable Product
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable Product
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: Product a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: Product (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: Product a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: Product (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) #
Unbox a => Vector Vector (Product a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Product a) -> m (Vector (Product a)) # basicUnsafeThaw :: PrimMonad m => Vector (Product a) -> m (Mutable Vector (PrimState m) (Product a)) # basicLength :: Vector (Product a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Product a) -> Vector (Product a) # basicUnsafeIndexM :: Monad m => Vector (Product a) -> Int -> m (Product a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Product a) -> Vector (Product a) -> m () # elemseq :: Vector (Product a) -> Product a -> b -> b #
Unbox a => MVector MVector (Product a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Product a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Product a) -> MVector s (Product a) # basicOverlaps :: MVector s (Product a) -> MVector s (Product a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Product a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Product a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Product a -> m (MVector (PrimState m) (Product a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Product a) -> Int -> m (Product a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Product a) -> Int -> Product a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Product a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Product a) -> Product a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Product a) -> MVector (PrimState m) (Product a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Product a) -> MVector (PrimState m) (Product a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Product a) -> Int -> m (MVector (PrimState m) (Product a)) #
Num a => Monoid (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Num a => Semigroup (Product a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Product a -> Product a -> Product a # sconcat :: NonEmpty (Product a) -> Product a # stimes :: Integral b => b -> Product a -> Product a #
Bounded a => Bounded (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Product a # maxBound :: Product a #
Generic (Product a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Product a) :: Type -> Type # Methods from :: Product a -> Rep (Product a) x # to :: Rep (Product a) x -> Product a #
Num a => Num (Product a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Product a -> Product a -> Product a # (-) :: Product a -> Product a -> Product a # (*) :: Product a -> Product a -> Product a # negate :: Product a -> Product a # abs :: Product a -> Product a # signum :: Product a -> Product a # fromInteger :: Integer -> Product a #
Read a => Read (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS (Product a) # readList :: ReadS [Product a] # readPrec :: ReadPrec (Product a) # readListPrec :: ReadPrec [Product a] #
Show a => Show (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Product a -> ShowS # show :: Product a -> String # showList :: [Product a] -> ShowS #
Num a => Default (Product a)
Instance details Defined in Data.Default.Class Methods def :: Product a #
NFData a => NFData (Product a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Product a -> () #
Eq a => Eq (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Product a -> Product a -> Bool # (/=) :: Product a -> Product a -> Bool #
Ord a => Ord (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Product a -> Product a -> Ordering # (<) :: Product a -> Product a -> Bool # (<=) :: Product a -> Product a -> Bool # (>) :: Product a -> Product a -> Bool # (>=) :: Product a -> Product a -> Bool # max :: Product a -> Product a -> Product a # min :: Product a -> Product a -> Product a #
Wrapped (Product a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Product a) # Methods _Wrapped' :: Iso' (Product a) (Unwrapped (Product a)) #
PMonoid (Product a)
Instance details Defined in Data.Monoid.Singletons Associated Types type Mempty :: a # type Mappend arg arg1 :: a # type Mconcat arg :: a #
SNum a => SMonoid (Product a)
Instance details Defined in Data.Monoid.Singletons Methods sMempty :: Sing MemptySym0 # sMappend :: forall (t1 :: Product a) (t2 :: Product a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MappendSym0 t1) t2) # sMconcat :: forall (t :: [Product a]). Sing t -> Sing (Apply MconcatSym0 t) #
PSemigroup (Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal Associated Types type arg <> arg1 :: a # type Sconcat arg :: a #
SNum a => SSemigroup (Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods (%<>) :: forall (t1 :: Product a) (t2 :: Product a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sSconcat :: forall (t :: NonEmpty (Product a)). Sing t -> Sing (Apply SconcatSym0 t) #
Container (Product a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Product a) # Methods toList :: Product a -> [Element (Product a)] # null :: Product a -> Bool # foldr :: (Element (Product a) -> b -> b) -> b -> Product a -> b # foldl :: (b -> Element (Product a) -> b) -> b -> Product a -> b # foldl' :: (b -> Element (Product a) -> b) -> b -> Product a -> b # length :: Product a -> Int # elem :: Element (Product a) -> Product a -> Bool # foldMap :: Monoid m => (Element (Product a) -> m) -> Product a -> m # fold :: Product a -> Element (Product a) # foldr' :: (Element (Product a) -> b -> b) -> b -> Product a -> b # notElem :: Element (Product a) -> Product a -> Bool # all :: (Element (Product a) -> Bool) -> Product a -> Bool # any :: (Element (Product a) -> Bool) -> Product a -> Bool # and :: Product a -> Bool # or :: Product a -> Bool # find :: (Element (Product a) -> Bool) -> Product a -> Maybe (Element (Product a)) # safeHead :: Product a -> Maybe (Element (Product a)) # safeMaximum :: Product a -> Maybe (Element (Product a)) # safeMinimum :: Product a -> Maybe (Element (Product a)) # safeFoldr1 :: (Element (Product a) -> Element (Product a) -> Element (Product a)) -> Product a -> Maybe (Element (Product a)) # safeFoldl1 :: (Element (Product a) -> Element (Product a) -> Element (Product a)) -> Product a -> Maybe (Element (Product a)) #
Unbox a => Unbox (Product a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Product
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Product :: k -> Type # Methods from1 :: forall (a :: k). Product a -> Rep1 Product a # to1 :: forall (a :: k). Rep1 Product a -> Product a #
t ~ Product b => Rewrapped (Product a) t
Instance details Defined in Control.Lens.Wrapped
IsoHKD Product (a :: Type)	Work with values of type `Product` `a` as if they were of type `a`.
Instance details Defined in Data.Vinyl.XRec Associated Types type HKD Product a # Methods unHKD :: HKD Product a -> Product a # toHKD :: Product a -> HKD Product a #
SDecide a => TestCoercion (SProduct :: Product a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods testCoercion :: forall (a0 :: k) (b :: k). SProduct a0 -> SProduct b -> Maybe (Coercion a0 b) #
SDecide a => TestEquality (SProduct :: Product a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods testEquality :: forall (a0 :: k) (b :: k). SProduct a0 -> SProduct b -> Maybe (a0 :~: b) #
SingI (GetProductSym0 :: TyFun (Product a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetProductSym0 #
SingI (ProductSym0 :: TyFun a (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing ProductSym0 #
SingI (Product_Sym0 :: TyFun a (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods sing :: Sing Product_Sym0 #
SuppressUnusedWarnings (Abs_6989586621679624935Sym0 :: TyFun (Product a) (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Negate_6989586621679624928Sym0 :: TyFun (Product a) (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Signum_6989586621679624942Sym0 :: TyFun (Product a) (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624885Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624896Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624907Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624918Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613641Sym0 :: TyFun (Product a) (Product a ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606180Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680194750Sym0 :: TyFun (Product a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Length_6989586621680194726Sym0 :: TyFun (Product a) Nat -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ToList_6989586621680194774Sym0 :: TyFun (Product a) [a] -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Maximum_6989586621680194732Sym0 :: TyFun (Product a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Minimum_6989586621680194741Sym0 :: TyFun (Product a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Product_6989586621680194756Sym0 :: TyFun (Product a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Sum_6989586621680194765Sym0 :: TyFun (Product a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GetProductSym0 :: TyFun (Product a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680194667Sym0 :: TyFun (a ~> (a ~> a)) (Product a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680194715Sym0 :: TyFun (a ~> (a ~> a)) (Product a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromInteger_6989586621679624949Sym0 :: TyFun Nat (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680582282Sym0 :: TyFun Nat (Product a ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ProductSym0 :: TyFun a (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621679624827Sym0 :: TyFun a (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Product_Sym0 :: TyFun a (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194618Sym0 :: TyFun a (Product a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624837Sym0 :: TyFun (Product (a ~> b)) (Product a ~> Product b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624885Sym1 a6989586621679624890 :: TyFun (Product a) (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624896Sym1 a6989586621679624901 :: TyFun (Product a) (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624907Sym1 a6989586621679624912 :: TyFun (Product a) (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624918Sym1 a6989586621679624923 :: TyFun (Product a) (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613641Sym1 a6989586621679613646 :: TyFun (Product a) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624874Sym0 :: TyFun (Product a) ((a ~> Product b) ~> Product b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680582282Sym1 a6989586621680582290 :: TyFun (Product a) (Symbol ~> Symbol) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194618Sym1 a6989586621680194627 :: TyFun (Product a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606180Sym1 a6989586621679606185 :: TyFun (Product a) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680194667Sym1 a6989586621680194674 :: TyFun (Product a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680194715Sym1 a6989586621680194722 :: TyFun (Product a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680194695Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Product a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194680Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Product a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679624848Sym0 :: TyFun (a ~> b) (Product a ~> Product b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194607Sym0 :: TyFun (a ~> m) (Product a ~> m) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680194653Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Product a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194638Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Product a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624859Sym0 :: TyFun a (Product b ~> Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679624848Sym1 a6989586621679624853 :: TyFun (Product a) (Product b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624837Sym1 a6989586621679624842 :: TyFun (Product a) (Product b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194607Sym1 a6989586621680194612 :: TyFun (Product a) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624859Sym1 a6989586621679624864 :: TyFun (Product b) (Product a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624874Sym1 a6989586621679624879 :: TyFun (a ~> Product b) (Product b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478791Sym0 :: TyFun (a ~> f b) (Product a ~> f (Product b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680194653Sym1 a6989586621680194659 :: TyFun b (Product a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194638Sym1 a6989586621680194644 :: TyFun b (Product a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680194695Sym1 a6989586621680194707 :: TyFun b (Product a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194680Sym1 a6989586621680194686 :: TyFun b (Product a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680194653Sym2 a6989586621680194659 a6989586621680194660 :: TyFun (Product a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194638Sym2 a6989586621680194644 a6989586621680194645 :: TyFun (Product a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680194695Sym2 a6989586621680194707 a6989586621680194708 :: TyFun (Product a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194680Sym2 a6989586621680194686 a6989586621680194687 :: TyFun (Product a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478791Sym1 a6989586621680478796 :: TyFun (Product a) (f (Product b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680194631Sym0 :: TyFun k1 (TyFun k2 (TyFun (b ~> c) (Product b ~> c) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680194631Sym1 a_69895866216801946206989586621680194629 :: TyFun k2 (TyFun (b ~> c) (Product b ~> c) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680194631Sym2 a_69895866216801946206989586621680194629 a_69895866216801946226989586621680194630 :: TyFun (b ~> c) (Product b ~> c) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
type Rep Product
Instance details Defined in Data.Functor.Rep type Rep Product = ()
type Pure (a :: k1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Pure (a :: k1) = Apply (Pure_6989586621679624827Sym0 :: TyFun k1 (Product k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (Product a) -> Type) arg
type Fold (arg :: Product m)
Instance details Defined in Data.Foldable.Singletons type Fold (arg :: Product m) = Apply (Fold_6989586621680193565Sym0 :: TyFun (Product m) m -> Type) arg
type Length (a2 :: Product a1)
Instance details Defined in Data.Foldable.Singletons type Length (a2 :: Product a1) = Apply (Length_6989586621680194726Sym0 :: TyFun (Product a1) Nat -> Type) a2
type Maximum (a :: Product k2)
Instance details Defined in Data.Foldable.Singletons type Maximum (a :: Product k2) = Apply (Maximum_6989586621680194732Sym0 :: TyFun (Product k2) k2 -> Type) a
type Minimum (a :: Product k2)
Instance details Defined in Data.Foldable.Singletons type Minimum (a :: Product k2) = Apply (Minimum_6989586621680194741Sym0 :: TyFun (Product k2) k2 -> Type) a
type Null (a2 :: Product a1)
Instance details Defined in Data.Foldable.Singletons type Null (a2 :: Product a1) = Apply (Null_6989586621680194750Sym0 :: TyFun (Product a1) Bool -> Type) a2
type Product (a :: Product k2)
Instance details Defined in Data.Foldable.Singletons type Product (a :: Product k2) = Apply (Product_6989586621680194756Sym0 :: TyFun (Product k2) k2 -> Type) a
type Sum (a :: Product k2)
Instance details Defined in Data.Foldable.Singletons type Sum (a :: Product k2) = Apply (Sum_6989586621680194765Sym0 :: TyFun (Product k2) k2 -> Type) a
type ToList (a2 :: Product a1)
Instance details Defined in Data.Foldable.Singletons type ToList (a2 :: Product a1) = Apply (ToList_6989586621680194774Sym0 :: TyFun (Product a1) [a1] -> Type) a2
type Elem (a1 :: k1) (a2 :: Product k1)
Instance details Defined in Data.Foldable.Singletons type Elem (a1 :: k1) (a2 :: Product k1) = Apply (Apply (Elem_6989586621680194618Sym0 :: TyFun k1 (Product k1 ~> Bool) -> Type) a1) a2
type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Product k2)
Instance details Defined in Data.Foldable.Singletons type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Product k2) = Apply (Apply (Foldl1_6989586621680194667Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (Product k2 ~> k2) -> Type) a1) a2
type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Product k2)
Instance details Defined in Data.Foldable.Singletons type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Product k2) = Apply (Apply (Foldr1_6989586621680194715Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (Product k2 ~> k2) -> Type) a1) a2
type Sequence (arg :: Product (m a))
Instance details Defined in Data.Traversable.Singletons type Sequence (arg :: Product (m a)) = Apply (Sequence_6989586621680471117Sym0 :: TyFun (Product (m a)) (m (Product a)) -> Type) arg
type SequenceA (arg :: Product (f a))
Instance details Defined in Data.Traversable.Singletons type SequenceA (arg :: Product (f a)) = Apply (SequenceA_6989586621680471093Sym0 :: TyFun (Product (f a)) (f (Product a)) -> Type) arg
type (arg :: Product a) *> (arg1 :: Product b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Product a) *> (arg1 :: Product b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (Product a) (Product b ~> Product b) -> Type) arg) arg1
type (a1 :: k1) <$ (a2 :: Product b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a1 :: k1) <$ (a2 :: Product b) = Apply (Apply (TFHelper_6989586621679624859Sym0 :: TyFun k1 (Product b ~> Product k1) -> Type) a1) a2
type (arg :: Product a) <* (arg1 :: Product b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Product a) <* (arg1 :: Product b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (Product a) (Product b ~> Product a) -> Type) arg) arg1
type (a2 :: Product (a1 ~> b)) <*> (a3 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Product (a1 ~> b)) <*> (a3 :: Product a1) = Apply (Apply (TFHelper_6989586621679624837Sym0 :: TyFun (Product (a1 ~> b)) (Product a1 ~> Product b) -> Type) a2) a3
type (arg :: Product a) >> (arg1 :: Product b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Product a) >> (arg1 :: Product b) = Apply (Apply (TFHelper_6989586621679287148Sym0 :: TyFun (Product a) (Product b ~> Product b) -> Type) arg) arg1
type (a2 :: Product a1) >>= (a3 :: a1 ~> Product b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Product a1) >>= (a3 :: a1 ~> Product b) = Apply (Apply (TFHelper_6989586621679624874Sym0 :: TyFun (Product a1) ((a1 ~> Product b) ~> Product b) -> Type) a2) a3
type Fmap (a2 :: a1 ~> b) (a3 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Fmap (a2 :: a1 ~> b) (a3 :: Product a1) = Apply (Apply (Fmap_6989586621679624848Sym0 :: TyFun (a1 ~> b) (Product a1 ~> Product b) -> Type) a2) a3
type FoldMap (a2 :: a1 ~> k2) (a3 :: Product a1)
Instance details Defined in Data.Foldable.Singletons type FoldMap (a2 :: a1 ~> k2) (a3 :: Product a1) = Apply (Apply (FoldMap_6989586621680194607Sym0 :: TyFun (a1 ~> k2) (Product a1 ~> k2) -> Type) a2) a3
type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Product a1)
Instance details Defined in Data.Foldable.Singletons type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Product a1) = Apply (Apply (Apply (Foldl_6989586621680194638Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (Product a1 ~> k2)) -> Type) a2) a3) a4
type Foldl' (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Product a1)
Instance details Defined in Data.Foldable.Singletons type Foldl' (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Product a1) = Apply (Apply (Apply (Foldl'_6989586621680194653Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (Product a1 ~> k2)) -> Type) a2) a3) a4
type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Product a1)
Instance details Defined in Data.Foldable.Singletons type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Product a1) = Apply (Apply (Apply (Foldr_6989586621680194680Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Product a1 ~> k2)) -> Type) a2) a3) a4
type Foldr' (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Product a1)
Instance details Defined in Data.Foldable.Singletons type Foldr' (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Product a1) = Apply (Apply (Apply (Foldr'_6989586621680194695Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Product a1 ~> k2)) -> Type) a2) a3) a4
type MapM (arg1 :: a ~> m b) (arg2 :: Product a)
Instance details Defined in Data.Traversable.Singletons type MapM (arg1 :: a ~> m b) (arg2 :: Product a) = Apply (Apply (MapM_6989586621680471103Sym0 :: TyFun (a ~> m b) (Product a ~> m (Product b)) -> Type) arg1) arg2
type Traverse (a2 :: a1 ~> f b) (a3 :: Product a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a2 :: a1 ~> f b) (a3 :: Product a1) = Apply (Apply (Traverse_6989586621680478791Sym0 :: TyFun (a1 ~> f b) (Product a1 ~> f (Product b)) -> Type) a2) a3
type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Product a) (arg2 :: Product b)
Instance details Defined in Data.Semigroup.Singletons.Internal type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Product a) (arg2 :: Product b) = Apply (Apply (Apply (LiftA2_6989586621679287093Sym0 :: TyFun (a ~> (b ~> c)) (Product a ~> (Product b ~> Product c)) -> Type) arg) arg1) arg2
newtype MVector s (Product a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Product a) = MV_Product (MVector s a)
type Apply (FromInteger_6989586621679624949Sym0 :: TyFun Nat (Product a) -> Type) (a6989586621679624953 :: Nat)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (FromInteger_6989586621679624949Sym0 :: TyFun Nat (Product a) -> Type) (a6989586621679624953 :: Nat) = FromInteger_6989586621679624949 a6989586621679624953 :: Product a
type Apply (ProductSym0 :: TyFun a (Product a) -> Type) (a6989586621679596433 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (ProductSym0 :: TyFun a (Product a) -> Type) (a6989586621679596433 :: a) = 'Product a6989586621679596433
type Apply (Pure_6989586621679624827Sym0 :: TyFun a (Product a) -> Type) (a6989586621679624833 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Pure_6989586621679624827Sym0 :: TyFun a (Product a) -> Type) (a6989586621679624833 :: a) = Pure_6989586621679624827 a6989586621679624833
type Apply (Product_Sym0 :: TyFun a (Product a) -> Type) (a6989586621679713079 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal.Disambiguation type Apply (Product_Sym0 :: TyFun a (Product a) -> Type) (a6989586621679713079 :: a) = Product_ a6989586621679713079
type Apply (ShowsPrec_6989586621680582282Sym0 :: TyFun Nat (Product a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680582290 :: Nat)
Instance details Defined in Data.Semigroup.Singletons type Apply (ShowsPrec_6989586621680582282Sym0 :: TyFun Nat (Product a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680582290 :: Nat) = ShowsPrec_6989586621680582282Sym1 a6989586621680582290 :: TyFun (Product a) (Symbol ~> Symbol) -> Type
type Apply (Elem_6989586621680194618Sym0 :: TyFun a (Product a ~> Bool) -> Type) (a6989586621680194627 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194618Sym0 :: TyFun a (Product a ~> Bool) -> Type) (a6989586621680194627 :: a) = Elem_6989586621680194618Sym1 a6989586621680194627
type Apply (TFHelper_6989586621679624859Sym0 :: TyFun a (Product b ~> Product a) -> Type) (a6989586621679624864 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624859Sym0 :: TyFun a (Product b ~> Product a) -> Type) (a6989586621679624864 :: a) = TFHelper_6989586621679624859Sym1 a6989586621679624864 :: TyFun (Product b) (Product a) -> Type
type Apply (Foldl'_6989586621680194653Sym1 a6989586621680194659 :: TyFun b (Product a ~> b) -> Type) (a6989586621680194660 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl'_6989586621680194653Sym1 a6989586621680194659 :: TyFun b (Product a ~> b) -> Type) (a6989586621680194660 :: b) = Foldl'_6989586621680194653Sym2 a6989586621680194659 a6989586621680194660
type Apply (Foldl_6989586621680194638Sym1 a6989586621680194644 :: TyFun b (Product a ~> b) -> Type) (a6989586621680194645 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194638Sym1 a6989586621680194644 :: TyFun b (Product a ~> b) -> Type) (a6989586621680194645 :: b) = Foldl_6989586621680194638Sym2 a6989586621680194644 a6989586621680194645
type Apply (Foldr'_6989586621680194695Sym1 a6989586621680194707 :: TyFun b (Product a ~> b) -> Type) (a6989586621680194708 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr'_6989586621680194695Sym1 a6989586621680194707 :: TyFun b (Product a ~> b) -> Type) (a6989586621680194708 :: b) = Foldr'_6989586621680194695Sym2 a6989586621680194707 a6989586621680194708
type Apply (Foldr_6989586621680194680Sym1 a6989586621680194686 :: TyFun b (Product a ~> b) -> Type) (a6989586621680194687 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194680Sym1 a6989586621680194686 :: TyFun b (Product a ~> b) -> Type) (a6989586621680194687 :: b) = Foldr_6989586621680194680Sym2 a6989586621680194686 a6989586621680194687
type Apply (Lambda_6989586621680194631Sym0 :: TyFun k1 (TyFun k2 (TyFun (b ~> c) (Product b ~> c) -> Type) -> Type) -> Type) (a_69895866216801946206989586621680194629 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680194631Sym0 :: TyFun k1 (TyFun k2 (TyFun (b ~> c) (Product b ~> c) -> Type) -> Type) -> Type) (a_69895866216801946206989586621680194629 :: k1) = Lambda_6989586621680194631Sym1 a_69895866216801946206989586621680194629 :: TyFun k2 (TyFun (b ~> c) (Product b ~> c) -> Type) -> Type
type Apply (Lambda_6989586621680194631Sym1 a_69895866216801946206989586621680194629 :: TyFun k2 (TyFun (b ~> c) (Product b ~> c) -> Type) -> Type) (a_69895866216801946226989586621680194630 :: k2)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680194631Sym1 a_69895866216801946206989586621680194629 :: TyFun k2 (TyFun (b ~> c) (Product b ~> c) -> Type) -> Type) (a_69895866216801946226989586621680194630 :: k2) = Lambda_6989586621680194631Sym2 a_69895866216801946206989586621680194629 a_69895866216801946226989586621680194630 :: TyFun (b ~> c) (Product b ~> c) -> Type
type Rep (Product a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal type Rep (Product a) = D1 ('MetaData "Product" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "Product" 'PrefixI 'True) (S1 ('MetaSel ('Just "getProduct") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Unwrapped (Product a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Product a) = a
type Demote (Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Demote (Product a) = Product (Demote a)
type Sing
Instance details Defined in Data.Semigroup.Singletons.Internal type Sing = SProduct :: Product a -> Type
type Mempty
Instance details Defined in Data.Monoid.Singletons type Mempty = Mempty_6989586621680118258Sym0 :: Product a
type MaxBound
Instance details Defined in Data.Semigroup.Singletons.Internal type MaxBound = MaxBound_6989586621679603389Sym0 :: Product a
type MinBound
Instance details Defined in Data.Semigroup.Singletons.Internal type MinBound = MinBound_6989586621679603386Sym0 :: Product a
type Element (Product a)
Instance details Defined in Universum.Container.Class type Element (Product a) = ElementDefault (Product a)
newtype Vector (Product a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Product a) = V_Product (Vector a)
type Rep1 Product	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal type Rep1 Product = D1 ('MetaData "Product" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "Product" 'PrefixI 'True) (S1 ('MetaSel ('Just "getProduct") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type Mconcat (arg :: [Product a])
Instance details Defined in Data.Monoid.Singletons type Mconcat (arg :: [Product a]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [Product a] (Product a) -> Type) arg
type Sconcat (arg :: NonEmpty (Product a))
Instance details Defined in Data.Semigroup.Singletons.Internal type Sconcat (arg :: NonEmpty (Product a)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (Product a)) (Product a) -> Type) arg
type Abs (a2 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Abs (a2 :: Product a1) = Apply (Abs_6989586621679624935Sym0 :: TyFun (Product a1) (Product a1) -> Type) a2
type FromInteger a2
Instance details Defined in Data.Semigroup.Singletons.Internal type FromInteger a2 = Apply (FromInteger_6989586621679624949Sym0 :: TyFun Nat (Product a1) -> Type) a2
type Negate (a2 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Negate (a2 :: Product a1) = Apply (Negate_6989586621679624928Sym0 :: TyFun (Product a1) (Product a1) -> Type) a2
type Signum (a2 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Signum (a2 :: Product a1) = Apply (Signum_6989586621679624942Sym0 :: TyFun (Product a1) (Product a1) -> Type) a2
type Show_ (arg :: Product a)
Instance details Defined in Data.Semigroup.Singletons type Show_ (arg :: Product a) = Apply (Show__6989586621680047550Sym0 :: TyFun (Product a) Symbol -> Type) arg
type (arg :: Product a) /= (arg1 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Product a) /= (arg1 :: Product a) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type) arg) arg1
type (a2 :: Product a1) == (a3 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Product a1) == (a3 :: Product a1) = Apply (Apply (TFHelper_6989586621679606180Sym0 :: TyFun (Product a1) (Product a1 ~> Bool) -> Type) a2) a3
type Mappend (arg1 :: Product a) (arg2 :: Product a)
Instance details Defined in Data.Monoid.Singletons type Mappend (arg1 :: Product a) (arg2 :: Product a) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) arg1) arg2
type (arg :: Product a) < (arg1 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Product a) < (arg1 :: Product a) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type) arg) arg1
type (arg :: Product a) <= (arg1 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Product a) <= (arg1 :: Product a) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type) arg) arg1
type (arg :: Product a) > (arg1 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Product a) > (arg1 :: Product a) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type) arg) arg1
type (arg :: Product a) >= (arg1 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Product a) >= (arg1 :: Product a) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type) arg) arg1
type Compare (a2 :: Product a1) (a3 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Compare (a2 :: Product a1) (a3 :: Product a1) = Apply (Apply (Compare_6989586621679613641Sym0 :: TyFun (Product a1) (Product a1 ~> Ordering) -> Type) a2) a3
type Max (arg :: Product a) (arg1 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Max (arg :: Product a) (arg1 :: Product a) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) arg) arg1
type Min (arg :: Product a) (arg1 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Min (arg :: Product a) (arg1 :: Product a) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) arg) arg1
type (a2 :: Product a1) <> (a3 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Product a1) <> (a3 :: Product a1) = Apply (Apply (TFHelper_6989586621679624885Sym0 :: TyFun (Product a1) (Product a1 ~> Product a1) -> Type) a2) a3
type (a2 :: Product a1) * (a3 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Product a1) * (a3 :: Product a1) = Apply (Apply (TFHelper_6989586621679624918Sym0 :: TyFun (Product a1) (Product a1 ~> Product a1) -> Type) a2) a3
type (a2 :: Product a1) + (a3 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Product a1) + (a3 :: Product a1) = Apply (Apply (TFHelper_6989586621679624896Sym0 :: TyFun (Product a1) (Product a1 ~> Product a1) -> Type) a2) a3
type (a2 :: Product a1) - (a3 :: Product a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Product a1) - (a3 :: Product a1) = Apply (Apply (TFHelper_6989586621679624907Sym0 :: TyFun (Product a1) (Product a1 ~> Product a1) -> Type) a2) a3
type ShowList (arg :: [Product a]) arg1
Instance details Defined in Data.Semigroup.Singletons type ShowList (arg :: [Product a]) arg1 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Product a] (Symbol ~> Symbol) -> Type) arg) arg1
type HKD Product (a :: Type)
Instance details Defined in Data.Vinyl.XRec type HKD Product (a :: Type) = a
type ShowsPrec a2 (a3 :: Product a1) a4
Instance details Defined in Data.Semigroup.Singletons type ShowsPrec a2 (a3 :: Product a1) a4 = Apply (Apply (Apply (ShowsPrec_6989586621680582282Sym0 :: TyFun Nat (Product a1 ~> (Symbol ~> Symbol)) -> Type) a2) a3) a4
type Apply (Null_6989586621680194750Sym0 :: TyFun (Product a) Bool -> Type) (a6989586621680194754 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680194750Sym0 :: TyFun (Product a) Bool -> Type) (a6989586621680194754 :: Product a) = Null_6989586621680194750 a6989586621680194754
type Apply (Length_6989586621680194726Sym0 :: TyFun (Product a) Nat -> Type) (a6989586621680194730 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Length_6989586621680194726Sym0 :: TyFun (Product a) Nat -> Type) (a6989586621680194730 :: Product a) = Length_6989586621680194726 a6989586621680194730
type Apply (Maximum_6989586621680194732Sym0 :: TyFun (Product a) a -> Type) (a6989586621680194738 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Maximum_6989586621680194732Sym0 :: TyFun (Product a) a -> Type) (a6989586621680194738 :: Product a) = Maximum_6989586621680194732 a6989586621680194738
type Apply (Minimum_6989586621680194741Sym0 :: TyFun (Product a) a -> Type) (a6989586621680194747 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Minimum_6989586621680194741Sym0 :: TyFun (Product a) a -> Type) (a6989586621680194747 :: Product a) = Minimum_6989586621680194741 a6989586621680194747
type Apply (Product_6989586621680194756Sym0 :: TyFun (Product a) a -> Type) (a6989586621680194762 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Product_6989586621680194756Sym0 :: TyFun (Product a) a -> Type) (a6989586621680194762 :: Product a) = Product_6989586621680194756 a6989586621680194762
type Apply (Sum_6989586621680194765Sym0 :: TyFun (Product a) a -> Type) (a6989586621680194771 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Sum_6989586621680194765Sym0 :: TyFun (Product a) a -> Type) (a6989586621680194771 :: Product a) = Sum_6989586621680194765 a6989586621680194771
type Apply (GetProductSym0 :: TyFun (Product a) a -> Type) (a6989586621679596436 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (GetProductSym0 :: TyFun (Product a) a -> Type) (a6989586621679596436 :: Product a) = GetProduct a6989586621679596436
type Apply (Compare_6989586621679613641Sym1 a6989586621679613646 :: TyFun (Product a) Ordering -> Type) (a6989586621679613647 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613641Sym1 a6989586621679613646 :: TyFun (Product a) Ordering -> Type) (a6989586621679613647 :: Product a) = Compare_6989586621679613641 a6989586621679613646 a6989586621679613647
type Apply (Elem_6989586621680194618Sym1 a6989586621680194627 :: TyFun (Product a) Bool -> Type) (a6989586621680194628 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194618Sym1 a6989586621680194627 :: TyFun (Product a) Bool -> Type) (a6989586621680194628 :: Product a) = Elem_6989586621680194618 a6989586621680194627 a6989586621680194628
type Apply (TFHelper_6989586621679606180Sym1 a6989586621679606185 :: TyFun (Product a) Bool -> Type) (a6989586621679606186 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606180Sym1 a6989586621679606185 :: TyFun (Product a) Bool -> Type) (a6989586621679606186 :: Product a) = TFHelper_6989586621679606180 a6989586621679606185 a6989586621679606186
type Apply (Foldl1_6989586621680194667Sym1 a6989586621680194674 :: TyFun (Product a) a -> Type) (a6989586621680194675 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl1_6989586621680194667Sym1 a6989586621680194674 :: TyFun (Product a) a -> Type) (a6989586621680194675 :: Product a) = Foldl1_6989586621680194667 a6989586621680194674 a6989586621680194675
type Apply (Foldr1_6989586621680194715Sym1 a6989586621680194722 :: TyFun (Product a) a -> Type) (a6989586621680194723 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr1_6989586621680194715Sym1 a6989586621680194722 :: TyFun (Product a) a -> Type) (a6989586621680194723 :: Product a) = Foldr1_6989586621680194715 a6989586621680194722 a6989586621680194723
type Apply (FoldMap_6989586621680194607Sym1 a6989586621680194612 :: TyFun (Product a) m -> Type) (a6989586621680194613 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194607Sym1 a6989586621680194612 :: TyFun (Product a) m -> Type) (a6989586621680194613 :: Product a) = FoldMap_6989586621680194607 a6989586621680194612 a6989586621680194613
type Apply (Foldl'_6989586621680194653Sym2 a6989586621680194659 a6989586621680194660 :: TyFun (Product a) b -> Type) (a6989586621680194661 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl'_6989586621680194653Sym2 a6989586621680194659 a6989586621680194660 :: TyFun (Product a) b -> Type) (a6989586621680194661 :: Product a) = Foldl'_6989586621680194653 a6989586621680194659 a6989586621680194660 a6989586621680194661
type Apply (Foldl_6989586621680194638Sym2 a6989586621680194644 a6989586621680194645 :: TyFun (Product a) b -> Type) (a6989586621680194646 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194638Sym2 a6989586621680194644 a6989586621680194645 :: TyFun (Product a) b -> Type) (a6989586621680194646 :: Product a) = Foldl_6989586621680194638 a6989586621680194644 a6989586621680194645 a6989586621680194646
type Apply (Foldr'_6989586621680194695Sym2 a6989586621680194707 a6989586621680194708 :: TyFun (Product a) b -> Type) (a6989586621680194709 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr'_6989586621680194695Sym2 a6989586621680194707 a6989586621680194708 :: TyFun (Product a) b -> Type) (a6989586621680194709 :: Product a) = Foldr'_6989586621680194695 a6989586621680194707 a6989586621680194708 a6989586621680194709
type Apply (Foldr_6989586621680194680Sym2 a6989586621680194686 a6989586621680194687 :: TyFun (Product a) b -> Type) (a6989586621680194688 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194680Sym2 a6989586621680194686 a6989586621680194687 :: TyFun (Product a) b -> Type) (a6989586621680194688 :: Product a) = Foldr_6989586621680194680 a6989586621680194686 a6989586621680194687 a6989586621680194688
type Apply (Abs_6989586621679624935Sym0 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624939 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Abs_6989586621679624935Sym0 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624939 :: Product a) = Abs_6989586621679624935 a6989586621679624939
type Apply (Negate_6989586621679624928Sym0 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624932 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Negate_6989586621679624928Sym0 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624932 :: Product a) = Negate_6989586621679624928 a6989586621679624932
type Apply (Signum_6989586621679624942Sym0 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624946 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Signum_6989586621679624942Sym0 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624946 :: Product a) = Signum_6989586621679624942 a6989586621679624946
type Apply (ToList_6989586621680194774Sym0 :: TyFun (Product a) [a] -> Type) (a6989586621680194778 :: Product a)
Instance details Defined in Data.Foldable.Singletons type Apply (ToList_6989586621680194774Sym0 :: TyFun (Product a) [a] -> Type) (a6989586621680194778 :: Product a) = ToList_6989586621680194774 a6989586621680194778
type Apply (TFHelper_6989586621679624885Sym1 a6989586621679624890 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624891 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624885Sym1 a6989586621679624890 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624891 :: Product a) = TFHelper_6989586621679624885 a6989586621679624890 a6989586621679624891
type Apply (TFHelper_6989586621679624896Sym1 a6989586621679624901 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624902 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624896Sym1 a6989586621679624901 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624902 :: Product a) = TFHelper_6989586621679624896 a6989586621679624901 a6989586621679624902
type Apply (TFHelper_6989586621679624907Sym1 a6989586621679624912 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624913 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624907Sym1 a6989586621679624912 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624913 :: Product a) = TFHelper_6989586621679624907 a6989586621679624912 a6989586621679624913
type Apply (TFHelper_6989586621679624918Sym1 a6989586621679624923 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624924 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624918Sym1 a6989586621679624923 :: TyFun (Product a) (Product a) -> Type) (a6989586621679624924 :: Product a) = TFHelper_6989586621679624918 a6989586621679624923 a6989586621679624924
type Apply (Fmap_6989586621679624848Sym1 a6989586621679624853 :: TyFun (Product a) (Product b) -> Type) (a6989586621679624854 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Fmap_6989586621679624848Sym1 a6989586621679624853 :: TyFun (Product a) (Product b) -> Type) (a6989586621679624854 :: Product a) = Fmap_6989586621679624848 a6989586621679624853 a6989586621679624854
type Apply (TFHelper_6989586621679624837Sym1 a6989586621679624842 :: TyFun (Product a) (Product b) -> Type) (a6989586621679624843 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624837Sym1 a6989586621679624842 :: TyFun (Product a) (Product b) -> Type) (a6989586621679624843 :: Product a) = TFHelper_6989586621679624837 a6989586621679624842 a6989586621679624843
type Apply (TFHelper_6989586621679624859Sym1 a6989586621679624864 :: TyFun (Product b) (Product a) -> Type) (a6989586621679624865 :: Product b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624859Sym1 a6989586621679624864 :: TyFun (Product b) (Product a) -> Type) (a6989586621679624865 :: Product b) = TFHelper_6989586621679624859 a6989586621679624864 a6989586621679624865
type Apply (Traverse_6989586621680478791Sym1 a6989586621680478796 :: TyFun (Product a) (f (Product b)) -> Type) (a6989586621680478797 :: Product a)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478791Sym1 a6989586621680478796 :: TyFun (Product a) (f (Product b)) -> Type) (a6989586621680478797 :: Product a) = Traverse_6989586621680478791 a6989586621680478796 a6989586621680478797
type Apply (TFHelper_6989586621679624885Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) (a6989586621679624890 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624885Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) (a6989586621679624890 :: Product a) = TFHelper_6989586621679624885Sym1 a6989586621679624890
type Apply (TFHelper_6989586621679624896Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) (a6989586621679624901 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624896Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) (a6989586621679624901 :: Product a) = TFHelper_6989586621679624896Sym1 a6989586621679624901
type Apply (TFHelper_6989586621679624907Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) (a6989586621679624912 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624907Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) (a6989586621679624912 :: Product a) = TFHelper_6989586621679624907Sym1 a6989586621679624912
type Apply (TFHelper_6989586621679624918Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) (a6989586621679624923 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624918Sym0 :: TyFun (Product a) (Product a ~> Product a) -> Type) (a6989586621679624923 :: Product a) = TFHelper_6989586621679624918Sym1 a6989586621679624923
type Apply (Compare_6989586621679613641Sym0 :: TyFun (Product a) (Product a ~> Ordering) -> Type) (a6989586621679613646 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613641Sym0 :: TyFun (Product a) (Product a ~> Ordering) -> Type) (a6989586621679613646 :: Product a) = Compare_6989586621679613641Sym1 a6989586621679613646
type Apply (TFHelper_6989586621679606180Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type) (a6989586621679606185 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606180Sym0 :: TyFun (Product a) (Product a ~> Bool) -> Type) (a6989586621679606185 :: Product a) = TFHelper_6989586621679606180Sym1 a6989586621679606185
type Apply (TFHelper_6989586621679624837Sym0 :: TyFun (Product (a ~> b)) (Product a ~> Product b) -> Type) (a6989586621679624842 :: Product (a ~> b))
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624837Sym0 :: TyFun (Product (a ~> b)) (Product a ~> Product b) -> Type) (a6989586621679624842 :: Product (a ~> b)) = TFHelper_6989586621679624837Sym1 a6989586621679624842
type Apply (TFHelper_6989586621679624874Sym0 :: TyFun (Product a) ((a ~> Product b) ~> Product b) -> Type) (a6989586621679624879 :: Product a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624874Sym0 :: TyFun (Product a) ((a ~> Product b) ~> Product b) -> Type) (a6989586621679624879 :: Product a) = TFHelper_6989586621679624874Sym1 a6989586621679624879 :: TyFun (a ~> Product b) (Product b) -> Type
type Apply (ShowsPrec_6989586621680582282Sym1 a6989586621680582290 :: TyFun (Product a) (Symbol ~> Symbol) -> Type) (a6989586621680582291 :: Product a)
Instance details Defined in Data.Semigroup.Singletons type Apply (ShowsPrec_6989586621680582282Sym1 a6989586621680582290 :: TyFun (Product a) (Symbol ~> Symbol) -> Type) (a6989586621680582291 :: Product a) = ShowsPrec_6989586621680582282Sym2 a6989586621680582290 a6989586621680582291
type Apply (TFHelper_6989586621679624874Sym1 a6989586621679624879 :: TyFun (a ~> Product b) (Product b) -> Type) (a6989586621679624880 :: a ~> Product b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624874Sym1 a6989586621679624879 :: TyFun (a ~> Product b) (Product b) -> Type) (a6989586621679624880 :: a ~> Product b) = TFHelper_6989586621679624874 a6989586621679624879 a6989586621679624880
type Apply (Foldl1_6989586621680194667Sym0 :: TyFun (a ~> (a ~> a)) (Product a ~> a) -> Type) (a6989586621680194674 :: a ~> (a ~> a))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl1_6989586621680194667Sym0 :: TyFun (a ~> (a ~> a)) (Product a ~> a) -> Type) (a6989586621680194674 :: a ~> (a ~> a)) = Foldl1_6989586621680194667Sym1 a6989586621680194674
type Apply (Foldr1_6989586621680194715Sym0 :: TyFun (a ~> (a ~> a)) (Product a ~> a) -> Type) (a6989586621680194722 :: a ~> (a ~> a))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr1_6989586621680194715Sym0 :: TyFun (a ~> (a ~> a)) (Product a ~> a) -> Type) (a6989586621680194722 :: a ~> (a ~> a)) = Foldr1_6989586621680194715Sym1 a6989586621680194722
type Apply (Foldr'_6989586621680194695Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Product a ~> b)) -> Type) (a6989586621680194707 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr'_6989586621680194695Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Product a ~> b)) -> Type) (a6989586621680194707 :: a ~> (b ~> b)) = Foldr'_6989586621680194695Sym1 a6989586621680194707
type Apply (Foldr_6989586621680194680Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Product a ~> b)) -> Type) (a6989586621680194686 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194680Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Product a ~> b)) -> Type) (a6989586621680194686 :: a ~> (b ~> b)) = Foldr_6989586621680194680Sym1 a6989586621680194686
type Apply (Fmap_6989586621679624848Sym0 :: TyFun (a ~> b) (Product a ~> Product b) -> Type) (a6989586621679624853 :: a ~> b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Fmap_6989586621679624848Sym0 :: TyFun (a ~> b) (Product a ~> Product b) -> Type) (a6989586621679624853 :: a ~> b) = Fmap_6989586621679624848Sym1 a6989586621679624853
type Apply (FoldMap_6989586621680194607Sym0 :: TyFun (a ~> m) (Product a ~> m) -> Type) (a6989586621680194612 :: a ~> m)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194607Sym0 :: TyFun (a ~> m) (Product a ~> m) -> Type) (a6989586621680194612 :: a ~> m) = FoldMap_6989586621680194607Sym1 a6989586621680194612
type Apply (Foldl'_6989586621680194653Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Product a ~> b)) -> Type) (a6989586621680194659 :: b ~> (a ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl'_6989586621680194653Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Product a ~> b)) -> Type) (a6989586621680194659 :: b ~> (a ~> b)) = Foldl'_6989586621680194653Sym1 a6989586621680194659
type Apply (Foldl_6989586621680194638Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Product a ~> b)) -> Type) (a6989586621680194644 :: b ~> (a ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194638Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Product a ~> b)) -> Type) (a6989586621680194644 :: b ~> (a ~> b)) = Foldl_6989586621680194638Sym1 a6989586621680194644
type Apply (Traverse_6989586621680478791Sym0 :: TyFun (a ~> f b) (Product a ~> f (Product b)) -> Type) (a6989586621680478796 :: a ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478791Sym0 :: TyFun (a ~> f b) (Product a ~> f (Product b)) -> Type) (a6989586621680478796 :: a ~> f b) = Traverse_6989586621680478791Sym1 a6989586621680478796
type Apply (Lambda_6989586621680194631Sym2 a_69895866216801946206989586621680194629 a_69895866216801946226989586621680194630 :: TyFun (b ~> c) (Product b ~> c) -> Type) (lhs_69895866216801931206989586621680194633 :: b ~> c)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680194631Sym2 a_69895866216801946206989586621680194629 a_69895866216801946226989586621680194630 :: TyFun (b ~> c) (Product b ~> c) -> Type) (lhs_69895866216801931206989586621680194633 :: b ~> c) = Lambda_6989586621680194631 a_69895866216801946206989586621680194629 a_69895866216801946226989586621680194630 lhs_69895866216801931206989586621680194633

newtype Endo a #

The monoid of endomorphisms under composition.

>>> let computation = Endo ("Hello, " ++) <> Endo (++ "!")
>>> appEndo computation "Haskell"
"Hello, Haskell!"

Constructors

Endo
Fields appEndo :: a -> a

Instances

Instances details

Monoid (Endo a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Semigroup (Endo a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Endo a -> Endo a -> Endo a # sconcat :: NonEmpty (Endo a) -> Endo a # stimes :: Integral b => b -> Endo a -> Endo a #
Generic (Endo a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Endo a) :: Type -> Type # Methods from :: Endo a -> Rep (Endo a) x # to :: Rep (Endo a) x -> Endo a #
Default (Endo a)
Instance details Defined in Data.Default.Class Methods def :: Endo a #
Wrapped (Endo a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Endo a) # Methods _Wrapped' :: Iso' (Endo a) (Unwrapped (Endo a)) #
t ~ Endo b => Rewrapped (Endo a) t
Instance details Defined in Control.Lens.Wrapped
type Rep (Endo a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal type Rep (Endo a) = D1 ('MetaData "Endo" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "Endo" 'PrefixI 'True) (S1 ('MetaSel ('Just "appEndo") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a -> a))))
type Unwrapped (Endo a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Endo a) = a -> a

newtype Dual a #

The dual of a Monoid, obtained by swapping the arguments of mappend.

>>> getDual (mappend (Dual "Hello") (Dual "World"))
"WorldHello"

Constructors

Dual
Fields getDual :: a

Instances

Instances details

Representable Dual
Instance details Defined in Data.Functor.Rep Associated Types type Rep Dual # Methods tabulate :: (Rep Dual -> a) -> Dual a # index :: Dual a -> Rep Dual -> a #
Foldable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m # foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldMap' :: Monoid m => (a -> m) -> Dual a -> m # foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b # foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b # foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # toList :: Dual a -> [a] # null :: Dual a -> Bool # length :: Dual a -> Int # elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # minimum :: Ord a => Dual a -> a # sum :: Num a => Dual a -> a # product :: Num a => Dual a -> a #
Traversable Dual	Since: base-4.8.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) # sequenceA :: Applicative f => Dual (f a) -> f (Dual a) # mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) # sequence :: Monad m => Dual (m a) -> m (Dual a) #
Applicative Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Dual a # (<>) :: Dual (a -> b) -> Dual a -> Dual b # liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c # (>) :: Dual a -> Dual b -> Dual b # (<*) :: Dual a -> Dual b -> Dual a #
Functor Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Dual a -> Dual b # (<$) :: a -> Dual b -> Dual a #
Monad Dual	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Dual a -> (a -> Dual b) -> Dual b # (>>) :: Dual a -> Dual b -> Dual b # return :: a -> Dual a #
NFData1 Dual	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Dual a -> () #
PFoldable Dual
Instance details Defined in Data.Foldable.Singletons Associated Types type Fold arg :: m # type FoldMap arg arg1 :: m # type Foldr arg arg1 arg2 :: b # type Foldr' arg arg1 arg2 :: b # type Foldl arg arg1 arg2 :: b # type Foldl' arg arg1 arg2 :: b # type Foldr1 arg arg1 :: a # type Foldl1 arg arg1 :: a # type ToList arg :: [a] # type Null arg :: Bool # type Length arg :: Nat # type Elem arg arg1 :: Bool # type Maximum arg :: a # type Minimum arg :: a # type Sum arg :: a # type Product arg :: a #
SFoldable Dual
Instance details Defined in Data.Foldable.Singletons Methods sFold :: forall m (t1 :: Dual m). SMonoid m => Sing t1 -> Sing (Apply FoldSym0 t1) # sFoldMap :: forall a m (t1 :: a ~> m) (t2 :: Dual a). SMonoid m => Sing t1 -> Sing t2 -> Sing (Apply (Apply FoldMapSym0 t1) t2) # sFoldr :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Dual a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldrSym0 t1) t2) t3) # sFoldr' :: forall a b (t1 :: a ~> (b ~> b)) (t2 :: b) (t3 :: Dual a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldr'Sym0 t1) t2) t3) # sFoldl :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Dual a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply FoldlSym0 t1) t2) t3) # sFoldl' :: forall b a (t1 :: b ~> (a ~> b)) (t2 :: b) (t3 :: Dual a). Sing t1 -> Sing t2 -> Sing t3 -> Sing (Apply (Apply (Apply Foldl'Sym0 t1) t2) t3) # sFoldr1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Dual a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldr1Sym0 t1) t2) # sFoldl1 :: forall a (t1 :: a ~> (a ~> a)) (t2 :: Dual a). Sing t1 -> Sing t2 -> Sing (Apply (Apply Foldl1Sym0 t1) t2) # sToList :: forall a (t1 :: Dual a). Sing t1 -> Sing (Apply ToListSym0 t1) # sNull :: forall a (t1 :: Dual a). Sing t1 -> Sing (Apply NullSym0 t1) # sLength :: forall a (t1 :: Dual a). Sing t1 -> Sing (Apply LengthSym0 t1) # sElem :: forall a (t1 :: a) (t2 :: Dual a). SEq a => Sing t1 -> Sing t2 -> Sing (Apply (Apply ElemSym0 t1) t2) # sMaximum :: forall a (t1 :: Dual a). SOrd a => Sing t1 -> Sing (Apply MaximumSym0 t1) # sMinimum :: forall a (t1 :: Dual a). SOrd a => Sing t1 -> Sing (Apply MinimumSym0 t1) # sSum :: forall a (t1 :: Dual a). SNum a => Sing t1 -> Sing (Apply SumSym0 t1) # sProduct :: forall a (t1 :: Dual a). SNum a => Sing t1 -> Sing (Apply ProductSym0 t1) #
PTraversable Dual
Instance details Defined in Data.Traversable.Singletons Associated Types type Traverse arg arg1 :: f (t b) # type SequenceA arg :: f (t a) # type MapM arg arg1 :: m (t b) # type Sequence arg :: m (t a) #
STraversable Dual
Instance details Defined in Data.Traversable.Singletons Methods sTraverse :: forall a (f :: Type -> Type) b (t1 :: a ~> f b) (t2 :: Dual a). SApplicative f => Sing t1 -> Sing t2 -> Sing (Apply (Apply TraverseSym0 t1) t2) # sSequenceA :: forall (f :: Type -> Type) a (t1 :: Dual (f a)). SApplicative f => Sing t1 -> Sing (Apply SequenceASym0 t1) # sMapM :: forall a (m :: Type -> Type) b (t1 :: a ~> m b) (t2 :: Dual a). SMonad m => Sing t1 -> Sing t2 -> Sing (Apply (Apply MapMSym0 t1) t2) # sSequence :: forall (m :: Type -> Type) a (t1 :: Dual (m a)). SMonad m => Sing t1 -> Sing (Apply SequenceSym0 t1) #
Unbox a => Vector Vector (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Dual a) -> m (Vector (Dual a)) # basicUnsafeThaw :: PrimMonad m => Vector (Dual a) -> m (Mutable Vector (PrimState m) (Dual a)) # basicLength :: Vector (Dual a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Dual a) -> Vector (Dual a) # basicUnsafeIndexM :: Monad m => Vector (Dual a) -> Int -> m (Dual a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Dual a) -> Vector (Dual a) -> m () # elemseq :: Vector (Dual a) -> Dual a -> b -> b #
Unbox a => MVector MVector (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Dual a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Dual a) -> MVector s (Dual a) # basicOverlaps :: MVector s (Dual a) -> MVector s (Dual a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Dual a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Dual a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Dual a -> m (MVector (PrimState m) (Dual a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Dual a) -> Int -> m (Dual a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Dual a) -> Int -> Dual a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Dual a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Dual a) -> Dual a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Dual a) -> MVector (PrimState m) (Dual a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Dual a) -> MVector (PrimState m) (Dual a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Dual a) -> Int -> m (MVector (PrimState m) (Dual a)) #
Monoid a => Monoid (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Semigroup a => Semigroup (Dual a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Dual a -> Dual a -> Dual a # sconcat :: NonEmpty (Dual a) -> Dual a # stimes :: Integral b => b -> Dual a -> Dual a #
Bounded a => Bounded (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Dual a # maxBound :: Dual a #
Generic (Dual a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Dual a) :: Type -> Type # Methods from :: Dual a -> Rep (Dual a) x # to :: Rep (Dual a) x -> Dual a #
Read a => Read (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS (Dual a) # readList :: ReadS [Dual a] # readPrec :: ReadPrec (Dual a) # readListPrec :: ReadPrec [Dual a] #
Show a => Show (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Dual a -> ShowS # show :: Dual a -> String # showList :: [Dual a] -> ShowS #
Default a => Default (Dual a)
Instance details Defined in Data.Default.Class Methods def :: Dual a #
NFData a => NFData (Dual a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Dual a -> () #
Eq a => Eq (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Dual a -> Dual a -> Bool # (/=) :: Dual a -> Dual a -> Bool #
Ord a => Ord (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods compare :: Dual a -> Dual a -> Ordering # (<) :: Dual a -> Dual a -> Bool # (<=) :: Dual a -> Dual a -> Bool # (>) :: Dual a -> Dual a -> Bool # (>=) :: Dual a -> Dual a -> Bool # max :: Dual a -> Dual a -> Dual a # min :: Dual a -> Dual a -> Dual a #
Wrapped (Dual a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Dual a) # Methods _Wrapped' :: Iso' (Dual a) (Unwrapped (Dual a)) #
Ring a => Ring (Dual a)
Instance details Defined in Data.Semiring Methods negate :: Dual a -> Dual a #
Semiring a => Semiring (Dual a)
Instance details Defined in Data.Semiring Methods plus :: Dual a -> Dual a -> Dual a # zero :: Dual a # times :: Dual a -> Dual a -> Dual a # one :: Dual a # fromNatural :: Natural -> Dual a #
PMonoid (Dual a)
Instance details Defined in Data.Monoid.Singletons Associated Types type Mempty :: a # type Mappend arg arg1 :: a # type Mconcat arg :: a #
SMonoid a => SMonoid (Dual a)
Instance details Defined in Data.Monoid.Singletons Methods sMempty :: Sing MemptySym0 # sMappend :: forall (t1 :: Dual a) (t2 :: Dual a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MappendSym0 t1) t2) # sMconcat :: forall (t :: [Dual a]). Sing t -> Sing (Apply MconcatSym0 t) #
PSemigroup (Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal Associated Types type arg <> arg1 :: a # type Sconcat arg :: a #
SSemigroup a => SSemigroup (Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods (%<>) :: forall (t1 :: Dual a) (t2 :: Dual a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sSconcat :: forall (t :: NonEmpty (Dual a)). Sing t -> Sing (Apply SconcatSym0 t) #
Container (Dual a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Dual a) # Methods toList :: Dual a -> [Element (Dual a)] # null :: Dual a -> Bool # foldr :: (Element (Dual a) -> b -> b) -> b -> Dual a -> b # foldl :: (b -> Element (Dual a) -> b) -> b -> Dual a -> b # foldl' :: (b -> Element (Dual a) -> b) -> b -> Dual a -> b # length :: Dual a -> Int # elem :: Element (Dual a) -> Dual a -> Bool # foldMap :: Monoid m => (Element (Dual a) -> m) -> Dual a -> m # fold :: Dual a -> Element (Dual a) # foldr' :: (Element (Dual a) -> b -> b) -> b -> Dual a -> b # notElem :: Element (Dual a) -> Dual a -> Bool # all :: (Element (Dual a) -> Bool) -> Dual a -> Bool # any :: (Element (Dual a) -> Bool) -> Dual a -> Bool # and :: Dual a -> Bool # or :: Dual a -> Bool # find :: (Element (Dual a) -> Bool) -> Dual a -> Maybe (Element (Dual a)) # safeHead :: Dual a -> Maybe (Element (Dual a)) # safeMaximum :: Dual a -> Maybe (Element (Dual a)) # safeMinimum :: Dual a -> Maybe (Element (Dual a)) # safeFoldr1 :: (Element (Dual a) -> Element (Dual a) -> Element (Dual a)) -> Dual a -> Maybe (Element (Dual a)) # safeFoldl1 :: (Element (Dual a) -> Element (Dual a) -> Element (Dual a)) -> Dual a -> Maybe (Element (Dual a)) #
Unbox a => Unbox (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Dual
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Dual :: k -> Type # Methods from1 :: forall (a :: k). Dual a -> Rep1 Dual a # to1 :: forall (a :: k). Rep1 Dual a -> Dual a #
t ~ Dual b => Rewrapped (Dual a) t
Instance details Defined in Control.Lens.Wrapped
SDecide a => TestCoercion (SDual :: Dual a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods testCoercion :: forall (a0 :: k) (b :: k). SDual a0 -> SDual b -> Maybe (Coercion a0 b) #
SDecide a => TestEquality (SDual :: Dual a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods testEquality :: forall (a0 :: k) (b :: k). SDual a0 -> SDual b -> Maybe (a0 :~: b) #
SingI (GetDualSym0 :: TyFun (Dual a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing GetDualSym0 #
SingI (DualSym0 :: TyFun a (Dual a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods sing :: Sing DualSym0 #
SuppressUnusedWarnings (TFHelper_6989586621679624643Sym0 :: TyFun (Dual a) (Dual a ~> Dual a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613565Sym0 :: TyFun (Dual a) (Dual a ~> Ordering) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606106Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Null_6989586621680194400Sym0 :: TyFun (Dual a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Length_6989586621680194376Sym0 :: TyFun (Dual a) Nat -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ToList_6989586621680194424Sym0 :: TyFun (Dual a) [a] -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Maximum_6989586621680194382Sym0 :: TyFun (Dual a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Minimum_6989586621680194391Sym0 :: TyFun (Dual a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Product_6989586621680194406Sym0 :: TyFun (Dual a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Sum_6989586621680194415Sym0 :: TyFun (Dual a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GetDualSym0 :: TyFun (Dual a) a -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680194317Sym0 :: TyFun (a ~> (a ~> a)) (Dual a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680194365Sym0 :: TyFun (a ~> (a ~> a)) (Dual a ~> a) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680582180Sym0 :: TyFun Nat (Dual a ~> (Symbol ~> Symbol)) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (DualSym0 :: TyFun a (Dual a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621679624481Sym0 :: TyFun a (Dual a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194268Sym0 :: TyFun a (Dual a ~> Bool) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624491Sym0 :: TyFun (Dual (a ~> b)) (Dual a ~> Dual b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624643Sym1 a6989586621679624648 :: TyFun (Dual a) (Dual a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679613565Sym1 a6989586621679613570 :: TyFun (Dual a) Ordering -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624632Sym0 :: TyFun (Dual a) ((a ~> Dual b) ~> Dual b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (ShowsPrec_6989586621680582180Sym1 a6989586621680582188 :: TyFun (Dual a) (Symbol ~> Symbol) -> Type)
Instance details Defined in Data.Semigroup.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Elem_6989586621680194268Sym1 a6989586621680194277 :: TyFun (Dual a) Bool -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679606106Sym1 a6989586621679606111 :: TyFun (Dual a) Bool -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl1_6989586621680194317Sym1 a6989586621680194324 :: TyFun (Dual a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr1_6989586621680194365Sym1 a6989586621680194372 :: TyFun (Dual a) a -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680194345Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Dual a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194330Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Dual a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679624502Sym0 :: TyFun (a ~> b) (Dual a ~> Dual b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194257Sym0 :: TyFun (a ~> m) (Dual a ~> m) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680194303Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Dual a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194288Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Dual a ~> b)) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624513Sym0 :: TyFun a (Dual b ~> Dual a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679624502Sym1 a6989586621679624507 :: TyFun (Dual a) (Dual b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624491Sym1 a6989586621679624496 :: TyFun (Dual a) (Dual b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FoldMap_6989586621680194257Sym1 a6989586621680194262 :: TyFun (Dual a) m -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624513Sym1 a6989586621679624518 :: TyFun (Dual b) (Dual a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679624632Sym1 a6989586621679624637 :: TyFun (a ~> Dual b) (Dual b) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478769Sym0 :: TyFun (a ~> f b) (Dual a ~> f (Dual b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680194303Sym1 a6989586621680194309 :: TyFun b (Dual a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194288Sym1 a6989586621680194294 :: TyFun b (Dual a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680194345Sym1 a6989586621680194357 :: TyFun b (Dual a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194330Sym1 a6989586621680194336 :: TyFun b (Dual a ~> b) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl'_6989586621680194303Sym2 a6989586621680194309 a6989586621680194310 :: TyFun (Dual a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldl_6989586621680194288Sym2 a6989586621680194294 a6989586621680194295 :: TyFun (Dual a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr'_6989586621680194345Sym2 a6989586621680194357 a6989586621680194358 :: TyFun (Dual a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Foldr_6989586621680194330Sym2 a6989586621680194336 a6989586621680194337 :: TyFun (Dual a) b -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Traverse_6989586621680478769Sym1 a6989586621680478774 :: TyFun (Dual a) (f (Dual b)) -> Type)
Instance details Defined in Data.Traversable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680194281Sym0 :: TyFun k1 (TyFun k2 (TyFun (b ~> c) (Dual b ~> c) -> Type) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680194281Sym1 a_69895866216801942706989586621680194279 :: TyFun k2 (TyFun (b ~> c) (Dual b ~> c) -> Type) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Lambda_6989586621680194281Sym2 a_69895866216801942706989586621680194279 a_69895866216801942726989586621680194280 :: TyFun (b ~> c) (Dual b ~> c) -> Type)
Instance details Defined in Data.Foldable.Singletons Methods suppressUnusedWarnings :: () #
type Rep Dual
Instance details Defined in Data.Functor.Rep type Rep Dual = ()
type Pure (a :: k1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Pure (a :: k1) = Apply (Pure_6989586621679624481Sym0 :: TyFun k1 (Dual k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (Dual a) -> Type) arg
type Fold (arg :: Dual m)
Instance details Defined in Data.Foldable.Singletons type Fold (arg :: Dual m) = Apply (Fold_6989586621680193565Sym0 :: TyFun (Dual m) m -> Type) arg
type Length (a2 :: Dual a1)
Instance details Defined in Data.Foldable.Singletons type Length (a2 :: Dual a1) = Apply (Length_6989586621680194376Sym0 :: TyFun (Dual a1) Nat -> Type) a2
type Maximum (a :: Dual k2)
Instance details Defined in Data.Foldable.Singletons type Maximum (a :: Dual k2) = Apply (Maximum_6989586621680194382Sym0 :: TyFun (Dual k2) k2 -> Type) a
type Minimum (a :: Dual k2)
Instance details Defined in Data.Foldable.Singletons type Minimum (a :: Dual k2) = Apply (Minimum_6989586621680194391Sym0 :: TyFun (Dual k2) k2 -> Type) a
type Null (a2 :: Dual a1)
Instance details Defined in Data.Foldable.Singletons type Null (a2 :: Dual a1) = Apply (Null_6989586621680194400Sym0 :: TyFun (Dual a1) Bool -> Type) a2
type Product (a :: Dual k2)
Instance details Defined in Data.Foldable.Singletons type Product (a :: Dual k2) = Apply (Product_6989586621680194406Sym0 :: TyFun (Dual k2) k2 -> Type) a
type Sum (a :: Dual k2)
Instance details Defined in Data.Foldable.Singletons type Sum (a :: Dual k2) = Apply (Sum_6989586621680194415Sym0 :: TyFun (Dual k2) k2 -> Type) a
type ToList (a2 :: Dual a1)
Instance details Defined in Data.Foldable.Singletons type ToList (a2 :: Dual a1) = Apply (ToList_6989586621680194424Sym0 :: TyFun (Dual a1) [a1] -> Type) a2
type Elem (a1 :: k1) (a2 :: Dual k1)
Instance details Defined in Data.Foldable.Singletons type Elem (a1 :: k1) (a2 :: Dual k1) = Apply (Apply (Elem_6989586621680194268Sym0 :: TyFun k1 (Dual k1 ~> Bool) -> Type) a1) a2
type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Dual k2)
Instance details Defined in Data.Foldable.Singletons type Foldl1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Dual k2) = Apply (Apply (Foldl1_6989586621680194317Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (Dual k2 ~> k2) -> Type) a1) a2
type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Dual k2)
Instance details Defined in Data.Foldable.Singletons type Foldr1 (a1 :: k2 ~> (k2 ~> k2)) (a2 :: Dual k2) = Apply (Apply (Foldr1_6989586621680194365Sym0 :: TyFun (k2 ~> (k2 ~> k2)) (Dual k2 ~> k2) -> Type) a1) a2
type Sequence (arg :: Dual (m a))
Instance details Defined in Data.Traversable.Singletons type Sequence (arg :: Dual (m a)) = Apply (Sequence_6989586621680471117Sym0 :: TyFun (Dual (m a)) (m (Dual a)) -> Type) arg
type SequenceA (arg :: Dual (f a))
Instance details Defined in Data.Traversable.Singletons type SequenceA (arg :: Dual (f a)) = Apply (SequenceA_6989586621680471093Sym0 :: TyFun (Dual (f a)) (f (Dual a)) -> Type) arg
type (arg :: Dual a) *> (arg1 :: Dual b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Dual a) *> (arg1 :: Dual b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (Dual a) (Dual b ~> Dual b) -> Type) arg) arg1
type (a1 :: k1) <$ (a2 :: Dual b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a1 :: k1) <$ (a2 :: Dual b) = Apply (Apply (TFHelper_6989586621679624513Sym0 :: TyFun k1 (Dual b ~> Dual k1) -> Type) a1) a2
type (arg :: Dual a) <* (arg1 :: Dual b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Dual a) <* (arg1 :: Dual b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (Dual a) (Dual b ~> Dual a) -> Type) arg) arg1
type (a2 :: Dual (a1 ~> b)) <*> (a3 :: Dual a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Dual (a1 ~> b)) <*> (a3 :: Dual a1) = Apply (Apply (TFHelper_6989586621679624491Sym0 :: TyFun (Dual (a1 ~> b)) (Dual a1 ~> Dual b) -> Type) a2) a3
type (arg :: Dual a) >> (arg1 :: Dual b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Dual a) >> (arg1 :: Dual b) = Apply (Apply (TFHelper_6989586621679287148Sym0 :: TyFun (Dual a) (Dual b ~> Dual b) -> Type) arg) arg1
type (a2 :: Dual a1) >>= (a3 :: a1 ~> Dual b)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Dual a1) >>= (a3 :: a1 ~> Dual b) = Apply (Apply (TFHelper_6989586621679624632Sym0 :: TyFun (Dual a1) ((a1 ~> Dual b) ~> Dual b) -> Type) a2) a3
type Fmap (a2 :: a1 ~> b) (a3 :: Dual a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Fmap (a2 :: a1 ~> b) (a3 :: Dual a1) = Apply (Apply (Fmap_6989586621679624502Sym0 :: TyFun (a1 ~> b) (Dual a1 ~> Dual b) -> Type) a2) a3
type FoldMap (a2 :: a1 ~> k2) (a3 :: Dual a1)
Instance details Defined in Data.Foldable.Singletons type FoldMap (a2 :: a1 ~> k2) (a3 :: Dual a1) = Apply (Apply (FoldMap_6989586621680194257Sym0 :: TyFun (a1 ~> k2) (Dual a1 ~> k2) -> Type) a2) a3
type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Dual a1)
Instance details Defined in Data.Foldable.Singletons type Foldl (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Dual a1) = Apply (Apply (Apply (Foldl_6989586621680194288Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (Dual a1 ~> k2)) -> Type) a2) a3) a4
type Foldl' (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Dual a1)
Instance details Defined in Data.Foldable.Singletons type Foldl' (a2 :: k2 ~> (a1 ~> k2)) (a3 :: k2) (a4 :: Dual a1) = Apply (Apply (Apply (Foldl'_6989586621680194303Sym0 :: TyFun (k2 ~> (a1 ~> k2)) (k2 ~> (Dual a1 ~> k2)) -> Type) a2) a3) a4
type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Dual a1)
Instance details Defined in Data.Foldable.Singletons type Foldr (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Dual a1) = Apply (Apply (Apply (Foldr_6989586621680194330Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Dual a1 ~> k2)) -> Type) a2) a3) a4
type Foldr' (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Dual a1)
Instance details Defined in Data.Foldable.Singletons type Foldr' (a2 :: a1 ~> (k2 ~> k2)) (a3 :: k2) (a4 :: Dual a1) = Apply (Apply (Apply (Foldr'_6989586621680194345Sym0 :: TyFun (a1 ~> (k2 ~> k2)) (k2 ~> (Dual a1 ~> k2)) -> Type) a2) a3) a4
type MapM (arg1 :: a ~> m b) (arg2 :: Dual a)
Instance details Defined in Data.Traversable.Singletons type MapM (arg1 :: a ~> m b) (arg2 :: Dual a) = Apply (Apply (MapM_6989586621680471103Sym0 :: TyFun (a ~> m b) (Dual a ~> m (Dual b)) -> Type) arg1) arg2
type Traverse (a2 :: a1 ~> f b) (a3 :: Dual a1)
Instance details Defined in Data.Traversable.Singletons type Traverse (a2 :: a1 ~> f b) (a3 :: Dual a1) = Apply (Apply (Traverse_6989586621680478769Sym0 :: TyFun (a1 ~> f b) (Dual a1 ~> f (Dual b)) -> Type) a2) a3
type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Dual a) (arg2 :: Dual b)
Instance details Defined in Data.Semigroup.Singletons.Internal type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Dual a) (arg2 :: Dual b) = Apply (Apply (Apply (LiftA2_6989586621679287093Sym0 :: TyFun (a ~> (b ~> c)) (Dual a ~> (Dual b ~> Dual c)) -> Type) arg) arg1) arg2
newtype MVector s (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Dual a) = MV_Dual (MVector s a)
type Apply (DualSym0 :: TyFun a (Dual a) -> Type) (a6989586621679596362 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (DualSym0 :: TyFun a (Dual a) -> Type) (a6989586621679596362 :: a) = 'Dual a6989586621679596362
type Apply (Pure_6989586621679624481Sym0 :: TyFun a (Dual a) -> Type) (a6989586621679624487 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Pure_6989586621679624481Sym0 :: TyFun a (Dual a) -> Type) (a6989586621679624487 :: a) = Pure_6989586621679624481 a6989586621679624487
type Apply (ShowsPrec_6989586621680582180Sym0 :: TyFun Nat (Dual a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680582188 :: Nat)
Instance details Defined in Data.Semigroup.Singletons type Apply (ShowsPrec_6989586621680582180Sym0 :: TyFun Nat (Dual a ~> (Symbol ~> Symbol)) -> Type) (a6989586621680582188 :: Nat) = ShowsPrec_6989586621680582180Sym1 a6989586621680582188 :: TyFun (Dual a) (Symbol ~> Symbol) -> Type
type Apply (Elem_6989586621680194268Sym0 :: TyFun a (Dual a ~> Bool) -> Type) (a6989586621680194277 :: a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194268Sym0 :: TyFun a (Dual a ~> Bool) -> Type) (a6989586621680194277 :: a) = Elem_6989586621680194268Sym1 a6989586621680194277
type Apply (TFHelper_6989586621679624513Sym0 :: TyFun a (Dual b ~> Dual a) -> Type) (a6989586621679624518 :: a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624513Sym0 :: TyFun a (Dual b ~> Dual a) -> Type) (a6989586621679624518 :: a) = TFHelper_6989586621679624513Sym1 a6989586621679624518 :: TyFun (Dual b) (Dual a) -> Type
type Apply (Foldl'_6989586621680194303Sym1 a6989586621680194309 :: TyFun b (Dual a ~> b) -> Type) (a6989586621680194310 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl'_6989586621680194303Sym1 a6989586621680194309 :: TyFun b (Dual a ~> b) -> Type) (a6989586621680194310 :: b) = Foldl'_6989586621680194303Sym2 a6989586621680194309 a6989586621680194310
type Apply (Foldl_6989586621680194288Sym1 a6989586621680194294 :: TyFun b (Dual a ~> b) -> Type) (a6989586621680194295 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194288Sym1 a6989586621680194294 :: TyFun b (Dual a ~> b) -> Type) (a6989586621680194295 :: b) = Foldl_6989586621680194288Sym2 a6989586621680194294 a6989586621680194295
type Apply (Foldr'_6989586621680194345Sym1 a6989586621680194357 :: TyFun b (Dual a ~> b) -> Type) (a6989586621680194358 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr'_6989586621680194345Sym1 a6989586621680194357 :: TyFun b (Dual a ~> b) -> Type) (a6989586621680194358 :: b) = Foldr'_6989586621680194345Sym2 a6989586621680194357 a6989586621680194358
type Apply (Foldr_6989586621680194330Sym1 a6989586621680194336 :: TyFun b (Dual a ~> b) -> Type) (a6989586621680194337 :: b)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194330Sym1 a6989586621680194336 :: TyFun b (Dual a ~> b) -> Type) (a6989586621680194337 :: b) = Foldr_6989586621680194330Sym2 a6989586621680194336 a6989586621680194337
type Apply (Lambda_6989586621680194281Sym0 :: TyFun k1 (TyFun k2 (TyFun (b ~> c) (Dual b ~> c) -> Type) -> Type) -> Type) (a_69895866216801942706989586621680194279 :: k1)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680194281Sym0 :: TyFun k1 (TyFun k2 (TyFun (b ~> c) (Dual b ~> c) -> Type) -> Type) -> Type) (a_69895866216801942706989586621680194279 :: k1) = Lambda_6989586621680194281Sym1 a_69895866216801942706989586621680194279 :: TyFun k2 (TyFun (b ~> c) (Dual b ~> c) -> Type) -> Type
type Apply (Lambda_6989586621680194281Sym1 a_69895866216801942706989586621680194279 :: TyFun k2 (TyFun (b ~> c) (Dual b ~> c) -> Type) -> Type) (a_69895866216801942726989586621680194280 :: k2)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680194281Sym1 a_69895866216801942706989586621680194279 :: TyFun k2 (TyFun (b ~> c) (Dual b ~> c) -> Type) -> Type) (a_69895866216801942726989586621680194280 :: k2) = Lambda_6989586621680194281Sym2 a_69895866216801942706989586621680194279 a_69895866216801942726989586621680194280 :: TyFun (b ~> c) (Dual b ~> c) -> Type
type Rep (Dual a)	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal type Rep (Dual a) = D1 ('MetaData "Dual" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "Dual" 'PrefixI 'True) (S1 ('MetaSel ('Just "getDual") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Unwrapped (Dual a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Dual a) = a
type Demote (Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Demote (Dual a) = Dual (Demote a)
type Sing
Instance details Defined in Data.Semigroup.Singletons.Internal type Sing = SDual :: Dual a -> Type
type Mempty
Instance details Defined in Data.Monoid.Singletons type Mempty = Mempty_6989586621680118246Sym0 :: Dual a
type MaxBound
Instance details Defined in Data.Semigroup.Singletons.Internal type MaxBound = MaxBound_6989586621679603356Sym0 :: Dual a
type MinBound
Instance details Defined in Data.Semigroup.Singletons.Internal type MinBound = MinBound_6989586621679603353Sym0 :: Dual a
type Element (Dual a)
Instance details Defined in Universum.Container.Class type Element (Dual a) = ElementDefault (Dual a)
newtype Vector (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Dual a) = V_Dual (Vector a)
type Rep1 Dual	Since: base-4.7.0.0
Instance details Defined in Data.Semigroup.Internal type Rep1 Dual = D1 ('MetaData "Dual" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "Dual" 'PrefixI 'True) (S1 ('MetaSel ('Just "getDual") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type Mconcat (arg :: [Dual a])
Instance details Defined in Data.Monoid.Singletons type Mconcat (arg :: [Dual a]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [Dual a] (Dual a) -> Type) arg
type Sconcat (arg :: NonEmpty (Dual a))
Instance details Defined in Data.Semigroup.Singletons.Internal type Sconcat (arg :: NonEmpty (Dual a)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (Dual a)) (Dual a) -> Type) arg
type Show_ (arg :: Dual a)
Instance details Defined in Data.Semigroup.Singletons type Show_ (arg :: Dual a) = Apply (Show__6989586621680047550Sym0 :: TyFun (Dual a) Symbol -> Type) arg
type (arg :: Dual a) /= (arg1 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Dual a) /= (arg1 :: Dual a) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type) arg) arg1
type (a2 :: Dual a1) == (a3 :: Dual a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Dual a1) == (a3 :: Dual a1) = Apply (Apply (TFHelper_6989586621679606106Sym0 :: TyFun (Dual a1) (Dual a1 ~> Bool) -> Type) a2) a3
type Mappend (arg1 :: Dual a) (arg2 :: Dual a)
Instance details Defined in Data.Monoid.Singletons type Mappend (arg1 :: Dual a) (arg2 :: Dual a) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (Dual a) (Dual a ~> Dual a) -> Type) arg1) arg2
type (arg :: Dual a) < (arg1 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Dual a) < (arg1 :: Dual a) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type) arg) arg1
type (arg :: Dual a) <= (arg1 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Dual a) <= (arg1 :: Dual a) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type) arg) arg1
type (arg :: Dual a) > (arg1 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Dual a) > (arg1 :: Dual a) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type) arg) arg1
type (arg :: Dual a) >= (arg1 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type (arg :: Dual a) >= (arg1 :: Dual a) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type) arg) arg1
type Compare (a2 :: Dual a1) (a3 :: Dual a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type Compare (a2 :: Dual a1) (a3 :: Dual a1) = Apply (Apply (Compare_6989586621679613565Sym0 :: TyFun (Dual a1) (Dual a1 ~> Ordering) -> Type) a2) a3
type Max (arg :: Dual a) (arg1 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Max (arg :: Dual a) (arg1 :: Dual a) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (Dual a) (Dual a ~> Dual a) -> Type) arg) arg1
type Min (arg :: Dual a) (arg1 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Min (arg :: Dual a) (arg1 :: Dual a) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (Dual a) (Dual a ~> Dual a) -> Type) arg) arg1
type (a2 :: Dual a1) <> (a3 :: Dual a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Dual a1) <> (a3 :: Dual a1) = Apply (Apply (TFHelper_6989586621679624643Sym0 :: TyFun (Dual a1) (Dual a1 ~> Dual a1) -> Type) a2) a3
type ShowList (arg :: [Dual a]) arg1
Instance details Defined in Data.Semigroup.Singletons type ShowList (arg :: [Dual a]) arg1 = Apply (Apply (ShowList_6989586621680047558Sym0 :: TyFun [Dual a] (Symbol ~> Symbol) -> Type) arg) arg1
type ShowsPrec a2 (a3 :: Dual a1) a4
Instance details Defined in Data.Semigroup.Singletons type ShowsPrec a2 (a3 :: Dual a1) a4 = Apply (Apply (Apply (ShowsPrec_6989586621680582180Sym0 :: TyFun Nat (Dual a1 ~> (Symbol ~> Symbol)) -> Type) a2) a3) a4
type Apply (Null_6989586621680194400Sym0 :: TyFun (Dual a) Bool -> Type) (a6989586621680194404 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Null_6989586621680194400Sym0 :: TyFun (Dual a) Bool -> Type) (a6989586621680194404 :: Dual a) = Null_6989586621680194400 a6989586621680194404
type Apply (Length_6989586621680194376Sym0 :: TyFun (Dual a) Nat -> Type) (a6989586621680194380 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Length_6989586621680194376Sym0 :: TyFun (Dual a) Nat -> Type) (a6989586621680194380 :: Dual a) = Length_6989586621680194376 a6989586621680194380
type Apply (Maximum_6989586621680194382Sym0 :: TyFun (Dual a) a -> Type) (a6989586621680194388 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Maximum_6989586621680194382Sym0 :: TyFun (Dual a) a -> Type) (a6989586621680194388 :: Dual a) = Maximum_6989586621680194382 a6989586621680194388
type Apply (Minimum_6989586621680194391Sym0 :: TyFun (Dual a) a -> Type) (a6989586621680194397 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Minimum_6989586621680194391Sym0 :: TyFun (Dual a) a -> Type) (a6989586621680194397 :: Dual a) = Minimum_6989586621680194391 a6989586621680194397
type Apply (Product_6989586621680194406Sym0 :: TyFun (Dual a) a -> Type) (a6989586621680194412 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Product_6989586621680194406Sym0 :: TyFun (Dual a) a -> Type) (a6989586621680194412 :: Dual a) = Product_6989586621680194406 a6989586621680194412
type Apply (Sum_6989586621680194415Sym0 :: TyFun (Dual a) a -> Type) (a6989586621680194421 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Sum_6989586621680194415Sym0 :: TyFun (Dual a) a -> Type) (a6989586621680194421 :: Dual a) = Sum_6989586621680194415 a6989586621680194421
type Apply (GetDualSym0 :: TyFun (Dual a) a -> Type) (a6989586621679596365 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (GetDualSym0 :: TyFun (Dual a) a -> Type) (a6989586621679596365 :: Dual a) = GetDual a6989586621679596365
type Apply (Compare_6989586621679613565Sym1 a6989586621679613570 :: TyFun (Dual a) Ordering -> Type) (a6989586621679613571 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613565Sym1 a6989586621679613570 :: TyFun (Dual a) Ordering -> Type) (a6989586621679613571 :: Dual a) = Compare_6989586621679613565 a6989586621679613570 a6989586621679613571
type Apply (Elem_6989586621680194268Sym1 a6989586621680194277 :: TyFun (Dual a) Bool -> Type) (a6989586621680194278 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Elem_6989586621680194268Sym1 a6989586621680194277 :: TyFun (Dual a) Bool -> Type) (a6989586621680194278 :: Dual a) = Elem_6989586621680194268 a6989586621680194277 a6989586621680194278
type Apply (TFHelper_6989586621679606106Sym1 a6989586621679606111 :: TyFun (Dual a) Bool -> Type) (a6989586621679606112 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606106Sym1 a6989586621679606111 :: TyFun (Dual a) Bool -> Type) (a6989586621679606112 :: Dual a) = TFHelper_6989586621679606106 a6989586621679606111 a6989586621679606112
type Apply (Foldl1_6989586621680194317Sym1 a6989586621680194324 :: TyFun (Dual a) a -> Type) (a6989586621680194325 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl1_6989586621680194317Sym1 a6989586621680194324 :: TyFun (Dual a) a -> Type) (a6989586621680194325 :: Dual a) = Foldl1_6989586621680194317 a6989586621680194324 a6989586621680194325
type Apply (Foldr1_6989586621680194365Sym1 a6989586621680194372 :: TyFun (Dual a) a -> Type) (a6989586621680194373 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr1_6989586621680194365Sym1 a6989586621680194372 :: TyFun (Dual a) a -> Type) (a6989586621680194373 :: Dual a) = Foldr1_6989586621680194365 a6989586621680194372 a6989586621680194373
type Apply (FoldMap_6989586621680194257Sym1 a6989586621680194262 :: TyFun (Dual a) m -> Type) (a6989586621680194263 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194257Sym1 a6989586621680194262 :: TyFun (Dual a) m -> Type) (a6989586621680194263 :: Dual a) = FoldMap_6989586621680194257 a6989586621680194262 a6989586621680194263
type Apply (Foldl'_6989586621680194303Sym2 a6989586621680194309 a6989586621680194310 :: TyFun (Dual a) b -> Type) (a6989586621680194311 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl'_6989586621680194303Sym2 a6989586621680194309 a6989586621680194310 :: TyFun (Dual a) b -> Type) (a6989586621680194311 :: Dual a) = Foldl'_6989586621680194303 a6989586621680194309 a6989586621680194310 a6989586621680194311
type Apply (Foldl_6989586621680194288Sym2 a6989586621680194294 a6989586621680194295 :: TyFun (Dual a) b -> Type) (a6989586621680194296 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194288Sym2 a6989586621680194294 a6989586621680194295 :: TyFun (Dual a) b -> Type) (a6989586621680194296 :: Dual a) = Foldl_6989586621680194288 a6989586621680194294 a6989586621680194295 a6989586621680194296
type Apply (Foldr'_6989586621680194345Sym2 a6989586621680194357 a6989586621680194358 :: TyFun (Dual a) b -> Type) (a6989586621680194359 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr'_6989586621680194345Sym2 a6989586621680194357 a6989586621680194358 :: TyFun (Dual a) b -> Type) (a6989586621680194359 :: Dual a) = Foldr'_6989586621680194345 a6989586621680194357 a6989586621680194358 a6989586621680194359
type Apply (Foldr_6989586621680194330Sym2 a6989586621680194336 a6989586621680194337 :: TyFun (Dual a) b -> Type) (a6989586621680194338 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194330Sym2 a6989586621680194336 a6989586621680194337 :: TyFun (Dual a) b -> Type) (a6989586621680194338 :: Dual a) = Foldr_6989586621680194330 a6989586621680194336 a6989586621680194337 a6989586621680194338
type Apply (ToList_6989586621680194424Sym0 :: TyFun (Dual a) [a] -> Type) (a6989586621680194428 :: Dual a)
Instance details Defined in Data.Foldable.Singletons type Apply (ToList_6989586621680194424Sym0 :: TyFun (Dual a) [a] -> Type) (a6989586621680194428 :: Dual a) = ToList_6989586621680194424 a6989586621680194428
type Apply (TFHelper_6989586621679624643Sym1 a6989586621679624648 :: TyFun (Dual a) (Dual a) -> Type) (a6989586621679624649 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624643Sym1 a6989586621679624648 :: TyFun (Dual a) (Dual a) -> Type) (a6989586621679624649 :: Dual a) = TFHelper_6989586621679624643 a6989586621679624648 a6989586621679624649
type Apply (Fmap_6989586621679624502Sym1 a6989586621679624507 :: TyFun (Dual a) (Dual b) -> Type) (a6989586621679624508 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Fmap_6989586621679624502Sym1 a6989586621679624507 :: TyFun (Dual a) (Dual b) -> Type) (a6989586621679624508 :: Dual a) = Fmap_6989586621679624502 a6989586621679624507 a6989586621679624508
type Apply (TFHelper_6989586621679624491Sym1 a6989586621679624496 :: TyFun (Dual a) (Dual b) -> Type) (a6989586621679624497 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624491Sym1 a6989586621679624496 :: TyFun (Dual a) (Dual b) -> Type) (a6989586621679624497 :: Dual a) = TFHelper_6989586621679624491 a6989586621679624496 a6989586621679624497
type Apply (TFHelper_6989586621679624513Sym1 a6989586621679624518 :: TyFun (Dual b) (Dual a) -> Type) (a6989586621679624519 :: Dual b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624513Sym1 a6989586621679624518 :: TyFun (Dual b) (Dual a) -> Type) (a6989586621679624519 :: Dual b) = TFHelper_6989586621679624513 a6989586621679624518 a6989586621679624519
type Apply (Traverse_6989586621680478769Sym1 a6989586621680478774 :: TyFun (Dual a) (f (Dual b)) -> Type) (a6989586621680478775 :: Dual a)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478769Sym1 a6989586621680478774 :: TyFun (Dual a) (f (Dual b)) -> Type) (a6989586621680478775 :: Dual a) = Traverse_6989586621680478769 a6989586621680478774 a6989586621680478775
type Apply (TFHelper_6989586621679624643Sym0 :: TyFun (Dual a) (Dual a ~> Dual a) -> Type) (a6989586621679624648 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624643Sym0 :: TyFun (Dual a) (Dual a ~> Dual a) -> Type) (a6989586621679624648 :: Dual a) = TFHelper_6989586621679624643Sym1 a6989586621679624648
type Apply (Compare_6989586621679613565Sym0 :: TyFun (Dual a) (Dual a ~> Ordering) -> Type) (a6989586621679613570 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Compare_6989586621679613565Sym0 :: TyFun (Dual a) (Dual a ~> Ordering) -> Type) (a6989586621679613570 :: Dual a) = Compare_6989586621679613565Sym1 a6989586621679613570
type Apply (TFHelper_6989586621679606106Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type) (a6989586621679606111 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679606106Sym0 :: TyFun (Dual a) (Dual a ~> Bool) -> Type) (a6989586621679606111 :: Dual a) = TFHelper_6989586621679606106Sym1 a6989586621679606111
type Apply (TFHelper_6989586621679624491Sym0 :: TyFun (Dual (a ~> b)) (Dual a ~> Dual b) -> Type) (a6989586621679624496 :: Dual (a ~> b))
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624491Sym0 :: TyFun (Dual (a ~> b)) (Dual a ~> Dual b) -> Type) (a6989586621679624496 :: Dual (a ~> b)) = TFHelper_6989586621679624491Sym1 a6989586621679624496
type Apply (TFHelper_6989586621679624632Sym0 :: TyFun (Dual a) ((a ~> Dual b) ~> Dual b) -> Type) (a6989586621679624637 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624632Sym0 :: TyFun (Dual a) ((a ~> Dual b) ~> Dual b) -> Type) (a6989586621679624637 :: Dual a) = TFHelper_6989586621679624632Sym1 a6989586621679624637 :: TyFun (a ~> Dual b) (Dual b) -> Type
type Apply (ShowsPrec_6989586621680582180Sym1 a6989586621680582188 :: TyFun (Dual a) (Symbol ~> Symbol) -> Type) (a6989586621680582189 :: Dual a)
Instance details Defined in Data.Semigroup.Singletons type Apply (ShowsPrec_6989586621680582180Sym1 a6989586621680582188 :: TyFun (Dual a) (Symbol ~> Symbol) -> Type) (a6989586621680582189 :: Dual a) = ShowsPrec_6989586621680582180Sym2 a6989586621680582188 a6989586621680582189
type Apply (TFHelper_6989586621679624632Sym1 a6989586621679624637 :: TyFun (a ~> Dual b) (Dual b) -> Type) (a6989586621679624638 :: a ~> Dual b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679624632Sym1 a6989586621679624637 :: TyFun (a ~> Dual b) (Dual b) -> Type) (a6989586621679624638 :: a ~> Dual b) = TFHelper_6989586621679624632 a6989586621679624637 a6989586621679624638
type Apply (Foldl1_6989586621680194317Sym0 :: TyFun (a ~> (a ~> a)) (Dual a ~> a) -> Type) (a6989586621680194324 :: a ~> (a ~> a))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl1_6989586621680194317Sym0 :: TyFun (a ~> (a ~> a)) (Dual a ~> a) -> Type) (a6989586621680194324 :: a ~> (a ~> a)) = Foldl1_6989586621680194317Sym1 a6989586621680194324
type Apply (Foldr1_6989586621680194365Sym0 :: TyFun (a ~> (a ~> a)) (Dual a ~> a) -> Type) (a6989586621680194372 :: a ~> (a ~> a))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr1_6989586621680194365Sym0 :: TyFun (a ~> (a ~> a)) (Dual a ~> a) -> Type) (a6989586621680194372 :: a ~> (a ~> a)) = Foldr1_6989586621680194365Sym1 a6989586621680194372
type Apply (Foldr'_6989586621680194345Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Dual a ~> b)) -> Type) (a6989586621680194357 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr'_6989586621680194345Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Dual a ~> b)) -> Type) (a6989586621680194357 :: a ~> (b ~> b)) = Foldr'_6989586621680194345Sym1 a6989586621680194357
type Apply (Foldr_6989586621680194330Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Dual a ~> b)) -> Type) (a6989586621680194336 :: a ~> (b ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldr_6989586621680194330Sym0 :: TyFun (a ~> (b ~> b)) (b ~> (Dual a ~> b)) -> Type) (a6989586621680194336 :: a ~> (b ~> b)) = Foldr_6989586621680194330Sym1 a6989586621680194336
type Apply (Fmap_6989586621679624502Sym0 :: TyFun (a ~> b) (Dual a ~> Dual b) -> Type) (a6989586621679624507 :: a ~> b)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (Fmap_6989586621679624502Sym0 :: TyFun (a ~> b) (Dual a ~> Dual b) -> Type) (a6989586621679624507 :: a ~> b) = Fmap_6989586621679624502Sym1 a6989586621679624507
type Apply (FoldMap_6989586621680194257Sym0 :: TyFun (a ~> m) (Dual a ~> m) -> Type) (a6989586621680194262 :: a ~> m)
Instance details Defined in Data.Foldable.Singletons type Apply (FoldMap_6989586621680194257Sym0 :: TyFun (a ~> m) (Dual a ~> m) -> Type) (a6989586621680194262 :: a ~> m) = FoldMap_6989586621680194257Sym1 a6989586621680194262
type Apply (Foldl'_6989586621680194303Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Dual a ~> b)) -> Type) (a6989586621680194309 :: b ~> (a ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl'_6989586621680194303Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Dual a ~> b)) -> Type) (a6989586621680194309 :: b ~> (a ~> b)) = Foldl'_6989586621680194303Sym1 a6989586621680194309
type Apply (Foldl_6989586621680194288Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Dual a ~> b)) -> Type) (a6989586621680194294 :: b ~> (a ~> b))
Instance details Defined in Data.Foldable.Singletons type Apply (Foldl_6989586621680194288Sym0 :: TyFun (b ~> (a ~> b)) (b ~> (Dual a ~> b)) -> Type) (a6989586621680194294 :: b ~> (a ~> b)) = Foldl_6989586621680194288Sym1 a6989586621680194294
type Apply (Traverse_6989586621680478769Sym0 :: TyFun (a ~> f b) (Dual a ~> f (Dual b)) -> Type) (a6989586621680478774 :: a ~> f b)
Instance details Defined in Data.Traversable.Singletons type Apply (Traverse_6989586621680478769Sym0 :: TyFun (a ~> f b) (Dual a ~> f (Dual b)) -> Type) (a6989586621680478774 :: a ~> f b) = Traverse_6989586621680478769Sym1 a6989586621680478774
type Apply (Lambda_6989586621680194281Sym2 a_69895866216801942706989586621680194279 a_69895866216801942726989586621680194280 :: TyFun (b ~> c) (Dual b ~> c) -> Type) (lhs_69895866216801931166989586621680194283 :: b ~> c)
Instance details Defined in Data.Foldable.Singletons type Apply (Lambda_6989586621680194281Sym2 a_69895866216801942706989586621680194279 a_69895866216801942726989586621680194280 :: TyFun (b ~> c) (Dual b ~> c) -> Type) (lhs_69895866216801931166989586621680194283 :: b ~> c) = Lambda_6989586621680194281 a_69895866216801942706989586621680194279 a_69895866216801942726989586621680194280 lhs_69895866216801931166989586621680194283

newtype Alt (f :: k -> Type) (a :: k) #

Monoid under <|>.

>>> getAlt (Alt (Just 12) <> Alt (Just 24))
Just 12

>>> getAlt $ Alt Nothing <> Alt (Just 24)
Just 24

Since: base-4.8.0.0

Constructors

Alt
Fields getAlt :: f a

Instances

Instances details

Generic1 (Alt f :: k -> Type)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 (Alt f) :: k -> Type # Methods from1 :: forall (a :: k0). Alt f a -> Rep1 (Alt f) a # to1 :: forall (a :: k0). Rep1 (Alt f) a -> Alt f a #
Unbox (f a) => Vector Vector (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Alt f a) -> m (Vector (Alt f a)) # basicUnsafeThaw :: PrimMonad m => Vector (Alt f a) -> m (Mutable Vector (PrimState m) (Alt f a)) # basicLength :: Vector (Alt f a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Alt f a) -> Vector (Alt f a) # basicUnsafeIndexM :: Monad m => Vector (Alt f a) -> Int -> m (Alt f a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Alt f a) -> Vector (Alt f a) -> m () # elemseq :: Vector (Alt f a) -> Alt f a -> b -> b #
Unbox (f a) => MVector MVector (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Alt f a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Alt f a) -> MVector s (Alt f a) # basicOverlaps :: MVector s (Alt f a) -> MVector s (Alt f a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Alt f a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Alt f a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Alt f a -> m (MVector (PrimState m) (Alt f a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Alt f a) -> Int -> m (Alt f a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Alt f a) -> Int -> Alt f a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Alt f a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Alt f a) -> Alt f a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Alt f a) -> MVector (PrimState m) (Alt f a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Alt f a) -> MVector (PrimState m) (Alt f a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Alt f a) -> Int -> m (MVector (PrimState m) (Alt f a)) #
Foldable f => Foldable (Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m # foldMap :: Monoid m => (a -> m) -> Alt f a -> m # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m # foldr :: (a -> b -> b) -> b -> Alt f a -> b # foldr' :: (a -> b -> b) -> b -> Alt f a -> b # foldl :: (b -> a -> b) -> b -> Alt f a -> b # foldl' :: (b -> a -> b) -> b -> Alt f a -> b # foldr1 :: (a -> a -> a) -> Alt f a -> a # foldl1 :: (a -> a -> a) -> Alt f a -> a # toList :: Alt f a -> [a] # null :: Alt f a -> Bool # length :: Alt f a -> Int # elem :: Eq a => a -> Alt f a -> Bool # maximum :: Ord a => Alt f a -> a # minimum :: Ord a => Alt f a -> a # sum :: Num a => Alt f a -> a # product :: Num a => Alt f a -> a #
Traversable f => Traversable (Alt f)	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Alt f a -> f0 (Alt f b) # sequenceA :: Applicative f0 => Alt f (f0 a) -> f0 (Alt f a) # mapM :: Monad m => (a -> m b) -> Alt f a -> m (Alt f b) # sequence :: Monad m => Alt f (m a) -> m (Alt f a) #
Alternative f => Alternative (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods empty :: Alt f a # (<\|>) :: Alt f a -> Alt f a -> Alt f a # some :: Alt f a -> Alt f [a] # many :: Alt f a -> Alt f [a] #
Applicative f => Applicative (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods pure :: a -> Alt f a # (<>) :: Alt f (a -> b) -> Alt f a -> Alt f b # liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c # (>) :: Alt f a -> Alt f b -> Alt f b # (<*) :: Alt f a -> Alt f b -> Alt f a #
Functor f => Functor (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Alt f a -> Alt f b # (<$) :: a -> Alt f b -> Alt f a #
Monad f => Monad (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (>>=) :: Alt f a -> (a -> Alt f b) -> Alt f b # (>>) :: Alt f a -> Alt f b -> Alt f b # return :: a -> Alt f a #
MonadPlus f => MonadPlus (Alt f)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods mzero :: Alt f a # mplus :: Alt f a -> Alt f a -> Alt f a #
Alternative f => Monoid (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods mempty :: Alt f a # mappend :: Alt f a -> Alt f a -> Alt f a # mconcat :: [Alt f a] -> Alt f a #
Alternative f => Semigroup (Alt f a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup.Internal Methods (<>) :: Alt f a -> Alt f a -> Alt f a # sconcat :: NonEmpty (Alt f a) -> Alt f a # stimes :: Integral b => b -> Alt f a -> Alt f a #
Enum (f a) => Enum (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods succ :: Alt f a -> Alt f a # pred :: Alt f a -> Alt f a # toEnum :: Int -> Alt f a # fromEnum :: Alt f a -> Int # enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] #
Generic (Alt f a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Alt f a) :: Type -> Type # Methods from :: Alt f a -> Rep (Alt f a) x # to :: Rep (Alt f a) x -> Alt f a #
Num (f a) => Num (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (+) :: Alt f a -> Alt f a -> Alt f a # (-) :: Alt f a -> Alt f a -> Alt f a # (*) :: Alt f a -> Alt f a -> Alt f a # negate :: Alt f a -> Alt f a # abs :: Alt f a -> Alt f a # signum :: Alt f a -> Alt f a # fromInteger :: Integer -> Alt f a #
Read (f a) => Read (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods readsPrec :: Int -> ReadS (Alt f a) # readList :: ReadS [Alt f a] # readPrec :: ReadPrec (Alt f a) # readListPrec :: ReadPrec [Alt f a] #
Show (f a) => Show (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods showsPrec :: Int -> Alt f a -> ShowS # show :: Alt f a -> String # showList :: [Alt f a] -> ShowS #
Eq (f a) => Eq (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Alt f a -> Alt f a -> Bool # (/=) :: Alt f a -> Alt f a -> Bool #
Ord (f a) => Ord (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods compare :: Alt f a -> Alt f a -> Ordering # (<) :: Alt f a -> Alt f a -> Bool # (<=) :: Alt f a -> Alt f a -> Bool # (>) :: Alt f a -> Alt f a -> Bool # (>=) :: Alt f a -> Alt f a -> Bool # max :: Alt f a -> Alt f a -> Alt f a # min :: Alt f a -> Alt f a -> Alt f a #
Wrapped (Alt f a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Alt f a) # Methods _Wrapped' :: Iso' (Alt f a) (Unwrapped (Alt f a)) #
Unbox (f a) => Unbox (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base
t ~ Alt g b => Rewrapped (Alt f a) t
Instance details Defined in Control.Lens.Wrapped
type Rep1 (Alt f :: k -> Type)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal type Rep1 (Alt f :: k -> Type) = D1 ('MetaData "Alt" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "Alt" 'PrefixI 'True) (S1 ('MetaSel ('Just "getAlt") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 f)))
newtype MVector s (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Alt f a) = MV_Alt (MVector s (f a))
type Rep (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal type Rep (Alt f a) = D1 ('MetaData "Alt" "Data.Semigroup.Internal" "base" 'True) (C1 ('MetaCons "Alt" 'PrefixI 'True) (S1 ('MetaSel ('Just "getAlt") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f a))))
type Unwrapped (Alt f a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Alt f a) = f a
newtype Vector (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Alt f a) = V_Alt (Vector (f a))

stimesMonoid :: (Integral b, Monoid a) => b -> a -> a #

This is a valid definition of stimes for a Monoid.

Unlike the default definition of stimes, it is defined for 0 and so it should be preferred where possible.

stimesIdempotent :: Integral b => b -> a -> a #

This is a valid definition of stimes for an idempotent Semigroup.

When x <> x = x, this definition should be preferred, because it works in $\mathcal{O}(1)$ rather than $\mathcal{O}(\log n)$.

newtype Down a #

The Down type allows you to reverse sort order conveniently. A value of type Down a contains a value of type a (represented as Down a).

If a has an Ord instance associated with it then comparing two values thus wrapped will give you the opposite of their normal sort order. This is particularly useful when sorting in generalised list comprehensions, as in: then sortWith by Down x.

>>> compare True False
GT

>>> compare (Down True) (Down False)
LT

If a has a Bounded instance then the wrapped instance also respects the reversed ordering by exchanging the values of minBound and maxBound.

>>> minBound :: Int
-9223372036854775808

>>> minBound :: Down Int
Down 9223372036854775807

All other instances of Down a behave as they do for a.

Since: base-4.6.0.0

Constructors

Down
Fields getDown :: a Since: base-4.14.0.0

Instances

Instances details

Foldable Down	Since: base-4.12.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m # foldMap :: Monoid m => (a -> m) -> Down a -> m # foldMap' :: Monoid m => (a -> m) -> Down a -> m # foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b # foldl :: (b -> a -> b) -> b -> Down a -> b # foldl' :: (b -> a -> b) -> b -> Down a -> b # foldr1 :: (a -> a -> a) -> Down a -> a # foldl1 :: (a -> a -> a) -> Down a -> a # toList :: Down a -> [a] # null :: Down a -> Bool # length :: Down a -> Int # elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # minimum :: Ord a => Down a -> a # sum :: Num a => Down a -> a # product :: Num a => Down a -> a #
Traversable Down	Since: base-4.12.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Down a -> f (Down b) # sequenceA :: Applicative f => Down (f a) -> f (Down a) # mapM :: Monad m => (a -> m b) -> Down a -> m (Down b) # sequence :: Monad m => Down (m a) -> m (Down a) #
Applicative Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods pure :: a -> Down a # (<>) :: Down (a -> b) -> Down a -> Down b # liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c # (>) :: Down a -> Down b -> Down b # (<*) :: Down a -> Down b -> Down a #
Functor Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods fmap :: (a -> b) -> Down a -> Down b # (<$) :: a -> Down b -> Down a #
Monad Down	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (>>=) :: Down a -> (a -> Down b) -> Down b # (>>) :: Down a -> Down b -> Down b # return :: a -> Down a #
NFData1 Down	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Down a -> () #
Unbox a => Vector Vector (Down a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Down a) -> m (Vector (Down a)) # basicUnsafeThaw :: PrimMonad m => Vector (Down a) -> m (Mutable Vector (PrimState m) (Down a)) # basicLength :: Vector (Down a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Down a) -> Vector (Down a) # basicUnsafeIndexM :: Monad m => Vector (Down a) -> Int -> m (Down a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Down a) -> Vector (Down a) -> m () # elemseq :: Vector (Down a) -> Down a -> b -> b #
Unbox a => MVector MVector (Down a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Down a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Down a) -> MVector s (Down a) # basicOverlaps :: MVector s (Down a) -> MVector s (Down a) -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Down a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Down a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Down a -> m (MVector (PrimState m) (Down a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Down a) -> Int -> m (Down a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Down a) -> Int -> Down a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Down a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Down a) -> Down a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Down a) -> MVector (PrimState m) (Down a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Down a) -> MVector (PrimState m) (Down a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Down a) -> Int -> m (MVector (PrimState m) (Down a)) #
Bits a => Bits (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods (.&.) :: Down a -> Down a -> Down a # (.\|.) :: Down a -> Down a -> Down a # xor :: Down a -> Down a -> Down a # complement :: Down a -> Down a # shift :: Down a -> Int -> Down a # rotate :: Down a -> Int -> Down a # zeroBits :: Down a # bit :: Int -> Down a # setBit :: Down a -> Int -> Down a # clearBit :: Down a -> Int -> Down a # complementBit :: Down a -> Int -> Down a # testBit :: Down a -> Int -> Bool # bitSizeMaybe :: Down a -> Maybe Int # bitSize :: Down a -> Int # isSigned :: Down a -> Bool # shiftL :: Down a -> Int -> Down a # unsafeShiftL :: Down a -> Int -> Down a # shiftR :: Down a -> Int -> Down a # unsafeShiftR :: Down a -> Int -> Down a # rotateL :: Down a -> Int -> Down a # rotateR :: Down a -> Int -> Down a # popCount :: Down a -> Int #
FiniteBits a => FiniteBits (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods finiteBitSize :: Down a -> Int # countLeadingZeros :: Down a -> Int # countTrailingZeros :: Down a -> Int #
Storable a => Storable (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods sizeOf :: Down a -> Int # alignment :: Down a -> Int # peekElemOff :: Ptr (Down a) -> Int -> IO (Down a) # pokeElemOff :: Ptr (Down a) -> Int -> Down a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Down a) # pokeByteOff :: Ptr b -> Int -> Down a -> IO () # peek :: Ptr (Down a) -> IO (Down a) # poke :: Ptr (Down a) -> Down a -> IO () #
Monoid a => Monoid (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods mempty :: Down a # mappend :: Down a -> Down a -> Down a # mconcat :: [Down a] -> Down a #
Semigroup a => Semigroup (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (<>) :: Down a -> Down a -> Down a # sconcat :: NonEmpty (Down a) -> Down a # stimes :: Integral b => b -> Down a -> Down a #
Bounded a => Bounded (Down a)	Swaps `minBound` and `maxBound` of the underlying type. Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods minBound :: Down a # maxBound :: Down a #
Floating a => Floating (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods pi :: Down a # exp :: Down a -> Down a # log :: Down a -> Down a # sqrt :: Down a -> Down a # (**) :: Down a -> Down a -> Down a # logBase :: Down a -> Down a -> Down a # sin :: Down a -> Down a # cos :: Down a -> Down a # tan :: Down a -> Down a # asin :: Down a -> Down a # acos :: Down a -> Down a # atan :: Down a -> Down a # sinh :: Down a -> Down a # cosh :: Down a -> Down a # tanh :: Down a -> Down a # asinh :: Down a -> Down a # acosh :: Down a -> Down a # atanh :: Down a -> Down a # log1p :: Down a -> Down a # expm1 :: Down a -> Down a # log1pexp :: Down a -> Down a # log1mexp :: Down a -> Down a #
RealFloat a => RealFloat (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods floatRadix :: Down a -> Integer # floatDigits :: Down a -> Int # floatRange :: Down a -> (Int, Int) # decodeFloat :: Down a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Down a # exponent :: Down a -> Int # significand :: Down a -> Down a # scaleFloat :: Int -> Down a -> Down a # isNaN :: Down a -> Bool # isInfinite :: Down a -> Bool # isDenormalized :: Down a -> Bool # isNegativeZero :: Down a -> Bool # isIEEE :: Down a -> Bool # atan2 :: Down a -> Down a -> Down a #
Generic (Down a)
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type # Methods from :: Down a -> Rep (Down a) x # to :: Rep (Down a) x -> Down a #
Ix a => Ix (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods range :: (Down a, Down a) -> [Down a] # index :: (Down a, Down a) -> Down a -> Int # unsafeIndex :: (Down a, Down a) -> Down a -> Int # inRange :: (Down a, Down a) -> Down a -> Bool # rangeSize :: (Down a, Down a) -> Int # unsafeRangeSize :: (Down a, Down a) -> Int #
Num a => Num (Down a)	Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods (+) :: Down a -> Down a -> Down a # (-) :: Down a -> Down a -> Down a # (*) :: Down a -> Down a -> Down a # negate :: Down a -> Down a # abs :: Down a -> Down a # signum :: Down a -> Down a # fromInteger :: Integer -> Down a #
Read a => Read (Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods readsPrec :: Int -> ReadS (Down a) # readList :: ReadS [Down a] # readPrec :: ReadPrec (Down a) # readListPrec :: ReadPrec [Down a] #
Fractional a => Fractional (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods (/) :: Down a -> Down a -> Down a # recip :: Down a -> Down a # fromRational :: Rational -> Down a #
Real a => Real (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods toRational :: Down a -> Rational #
RealFrac a => RealFrac (Down a)	Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods properFraction :: Integral b => Down a -> (b, Down a) # truncate :: Integral b => Down a -> b # round :: Integral b => Down a -> b # ceiling :: Integral b => Down a -> b # floor :: Integral b => Down a -> b #
Show a => Show (Down a)	This instance would be equivalent to the derived instances of the `Down` newtype if the `getDown` field were removed Since: base-4.7.0.0
Instance details Defined in Data.Ord Methods showsPrec :: Int -> Down a -> ShowS # show :: Down a -> String # showList :: [Down a] -> ShowS #
NFData a => NFData (Down a)	Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Down a -> () #
Eq a => Eq (Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods (==) :: Down a -> Down a -> Bool # (/=) :: Down a -> Down a -> Bool #
Ord a => Ord (Down a)	Since: base-4.6.0.0
Instance details Defined in Data.Ord Methods compare :: Down a -> Down a -> Ordering # (<) :: Down a -> Down a -> Bool # (<=) :: Down a -> Down a -> Bool # (>) :: Down a -> Down a -> Bool # (>=) :: Down a -> Down a -> Bool # max :: Down a -> Down a -> Down a # min :: Down a -> Down a -> Down a #
Wrapped (Down a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Down a) # Methods _Wrapped' :: Iso' (Down a) (Unwrapped (Down a)) #
Ring a => Ring (Down a)
Instance details Defined in Data.Semiring Methods negate :: Down a -> Down a #
Semiring a => Semiring (Down a)
Instance details Defined in Data.Semiring Methods plus :: Down a -> Down a -> Down a # zero :: Down a # times :: Down a -> Down a -> Down a # one :: Down a # fromNatural :: Natural -> Down a #
PMonoid (Down a)
Instance details Defined in Data.Monoid.Singletons Associated Types type Mempty :: a # type Mappend arg arg1 :: a # type Mconcat arg :: a #
SMonoid a => SMonoid (Down a)
Instance details Defined in Data.Monoid.Singletons Methods sMempty :: Sing MemptySym0 # sMappend :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MappendSym0 t1) t2) # sMconcat :: forall (t :: [Down a]). Sing t -> Sing (Apply MconcatSym0 t) #
POrd (Down a)
Instance details Defined in Data.Ord.Singletons Associated Types type Compare arg arg1 :: Ordering # type arg < arg1 :: Bool # type arg <= arg1 :: Bool # type arg > arg1 :: Bool # type arg >= arg1 :: Bool # type Max arg arg1 :: a # type Min arg arg1 :: a #
SOrd a => SOrd (Down a)
Instance details Defined in Data.Ord.Singletons Methods sCompare :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply CompareSym0 t1) t2) # (%<) :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<@#@$) t1) t2) # (%<=) :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<=@#@$) t1) t2) # (%>) :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>@#@$) t1) t2) # (%>=) :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (>=@#@$) t1) t2) # sMax :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MaxSym0 t1) t2) # sMin :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply MinSym0 t1) t2) #
PSemigroup (Down a)
Instance details Defined in Data.Semigroup.Singletons.Internal Associated Types type arg <> arg1 :: a # type Sconcat arg :: a #
SSemigroup a => SSemigroup (Down a)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods (%<>) :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (<>@#@$) t1) t2) # sSconcat :: forall (t :: NonEmpty (Down a)). Sing t -> Sing (Apply SconcatSym0 t) #
PNum (Down a)
Instance details Defined in GHC.Num.Singletons Associated Types type arg + arg1 :: a # type arg - arg1 :: a # type arg * arg1 :: a # type Negate arg :: a # type Abs arg :: a # type Signum arg :: a # type FromInteger arg :: a #
SNum a => SNum (Down a)
Instance details Defined in GHC.Num.Singletons Methods (%+) :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (+@#@$) t1) t2) # (%-) :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (-@#@$) t1) t2) # (%) :: forall (t1 :: Down a) (t2 :: Down a). Sing t1 -> Sing t2 -> Sing (Apply (Apply (@#@$) t1) t2) # sNegate :: forall (t :: Down a). Sing t -> Sing (Apply NegateSym0 t) # sAbs :: forall (t :: Down a). Sing t -> Sing (Apply AbsSym0 t) # sSignum :: forall (t :: Down a). Sing t -> Sing (Apply SignumSym0 t) # sFromInteger :: forall (t :: Nat). Sing t -> Sing (Apply FromIntegerSym0 t) #
Unbox a => Unbox (Down a)
Instance details Defined in Data.Vector.Unboxed.Base
Generic1 Down
Instance details Defined in GHC.Generics Associated Types type Rep1 Down :: k -> Type # Methods from1 :: forall (a :: k). Down a -> Rep1 Down a # to1 :: forall (a :: k). Rep1 Down a -> Down a #
t ~ Down b => Rewrapped (Down a) t
Instance details Defined in Control.Lens.Wrapped
SDecide a => TestCoercion (SDown :: Down a -> Type)
Instance details Defined in Data.Ord.Singletons Methods testCoercion :: forall (a0 :: k) (b :: k). SDown a0 -> SDown b -> Maybe (Coercion a0 b) #
SDecide a => TestEquality (SDown :: Down a -> Type)
Instance details Defined in Data.Ord.Singletons Methods testEquality :: forall (a0 :: k) (b :: k). SDown a0 -> SDown b -> Maybe (a0 :~: b) #
SingI (GetDownSym0 :: TyFun (Down a) a -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing GetDownSym0 #
SingI (DownSym0 :: TyFun a (Down a) -> Type)
Instance details Defined in Data.Ord.Singletons Methods sing :: Sing DownSym0 #
SuppressUnusedWarnings (Abs_6989586621679495702Sym0 :: TyFun (Down a) (Down a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Negate_6989586621679495695Sym0 :: TyFun (Down a) (Down a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Signum_6989586621679495709Sym0 :: TyFun (Down a) (Down a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679584175Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679495663Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679495674Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679495685Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679179242Sym0 :: TyFun (Down a) (Down a ~> Ordering) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679179231Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (GetDownSym0 :: TyFun (Down a) a -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (FromInteger_6989586621679495716Sym0 :: TyFun Nat (Down a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Pure_6989586621680883146Sym0 :: TyFun a (Down a) -> Type)
Instance details Defined in Control.Applicative.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (DownSym0 :: TyFun a (Down a) -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680883156Sym0 :: TyFun (Down (a ~> b)) (Down a ~> Down b) -> Type)
Instance details Defined in Control.Applicative.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679584175Sym1 a6989586621679584180 :: TyFun (Down a) (Down a) -> Type)
Instance details Defined in Data.Semigroup.Singletons.Internal Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679495663Sym1 a6989586621679495668 :: TyFun (Down a) (Down a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679495674Sym1 a6989586621679495679 :: TyFun (Down a) (Down a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679495685Sym1 a6989586621679495690 :: TyFun (Down a) (Down a) -> Type)
Instance details Defined in GHC.Num.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Compare_6989586621679179242Sym1 a6989586621679179247 :: TyFun (Down a) Ordering -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680892758Sym0 :: TyFun (Down a) ((a ~> Down b) ~> Down b) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679179231Sym1 a6989586621679179236 :: TyFun (Down a) Bool -> Type)
Instance details Defined in Data.Ord.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679439337Sym0 :: TyFun (a ~> b) (Down a ~> Down b) -> Type)
Instance details Defined in Data.Functor.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679439348Sym0 :: TyFun a (Down b ~> Down a) -> Type)
Instance details Defined in Data.Functor.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680883156Sym1 a6989586621680883161 :: TyFun (Down a) (Down b) -> Type)
Instance details Defined in Control.Applicative.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (Fmap_6989586621679439337Sym1 a6989586621679439342 :: TyFun (Down a) (Down b) -> Type)
Instance details Defined in Data.Functor.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621679439348Sym1 a6989586621679439353 :: TyFun (Down b) (Down a) -> Type)
Instance details Defined in Data.Functor.Singletons Methods suppressUnusedWarnings :: () #
SuppressUnusedWarnings (TFHelper_6989586621680892758Sym1 a6989586621680892763 :: TyFun (a ~> Down b) (Down b) -> Type)
Instance details Defined in Control.Monad.Singletons Methods suppressUnusedWarnings :: () #
type Pure (a :: k1)
Instance details Defined in Control.Applicative.Singletons type Pure (a :: k1) = Apply (Pure_6989586621680883146Sym0 :: TyFun k1 (Down k1) -> Type) a
type Return (arg :: a)
Instance details Defined in Control.Monad.Singletons type Return (arg :: a) = Apply (Return_6989586621679287165Sym0 :: TyFun a (Down a) -> Type) arg
type (arg :: Down a) *> (arg1 :: Down b)
Instance details Defined in Control.Applicative.Singletons type (arg :: Down a) *> (arg1 :: Down b) = Apply (Apply (TFHelper_6989586621679287109Sym0 :: TyFun (Down a) (Down b ~> Down b) -> Type) arg) arg1
type (a1 :: k1) <$ (a2 :: Down b)
Instance details Defined in Data.Functor.Singletons type (a1 :: k1) <$ (a2 :: Down b) = Apply (Apply (TFHelper_6989586621679439348Sym0 :: TyFun k1 (Down b ~> Down k1) -> Type) a1) a2
type (arg :: Down a) <* (arg1 :: Down b)
Instance details Defined in Control.Applicative.Singletons type (arg :: Down a) <* (arg1 :: Down b) = Apply (Apply (TFHelper_6989586621679287120Sym0 :: TyFun (Down a) (Down b ~> Down a) -> Type) arg) arg1
type (a2 :: Down (a1 ~> b)) <*> (a3 :: Down a1)
Instance details Defined in Control.Applicative.Singletons type (a2 :: Down (a1 ~> b)) <*> (a3 :: Down a1) = Apply (Apply (TFHelper_6989586621680883156Sym0 :: TyFun (Down (a1 ~> b)) (Down a1 ~> Down b) -> Type) a2) a3
type (arg :: Down a) >> (arg1 :: Down b)
Instance details Defined in Control.Monad.Singletons type (arg :: Down a) >> (arg1 :: Down b) = Apply (Apply (TFHelper_6989586621679287148Sym0 :: TyFun (Down a) (Down b ~> Down b) -> Type) arg) arg1
type (a2 :: Down a1) >>= (a3 :: a1 ~> Down b)
Instance details Defined in Control.Monad.Singletons type (a2 :: Down a1) >>= (a3 :: a1 ~> Down b) = Apply (Apply (TFHelper_6989586621680892758Sym0 :: TyFun (Down a1) ((a1 ~> Down b) ~> Down b) -> Type) a2) a3
type Fmap (a2 :: a1 ~> b) (a3 :: Down a1)
Instance details Defined in Data.Functor.Singletons type Fmap (a2 :: a1 ~> b) (a3 :: Down a1) = Apply (Apply (Fmap_6989586621679439337Sym0 :: TyFun (a1 ~> b) (Down a1 ~> Down b) -> Type) a2) a3
type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Down a) (arg2 :: Down b)
Instance details Defined in Control.Applicative.Singletons type LiftA2 (arg :: a ~> (b ~> c)) (arg1 :: Down a) (arg2 :: Down b) = Apply (Apply (Apply (LiftA2_6989586621679287093Sym0 :: TyFun (a ~> (b ~> c)) (Down a ~> (Down b ~> Down c)) -> Type) arg) arg1) arg2
newtype MVector s (Down a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Down a) = MV_Down (MVector s a)
type Apply (FromInteger_6989586621679495716Sym0 :: TyFun Nat (Down a) -> Type) (a6989586621679495720 :: Nat)
Instance details Defined in GHC.Num.Singletons type Apply (FromInteger_6989586621679495716Sym0 :: TyFun Nat (Down a) -> Type) (a6989586621679495720 :: Nat) = FromInteger_6989586621679495716 a6989586621679495720 :: Down a
type Apply (Pure_6989586621680883146Sym0 :: TyFun a (Down a) -> Type) (a6989586621680883152 :: a)
Instance details Defined in Control.Applicative.Singletons type Apply (Pure_6989586621680883146Sym0 :: TyFun a (Down a) -> Type) (a6989586621680883152 :: a) = Pure_6989586621680883146 a6989586621680883152
type Apply (DownSym0 :: TyFun a (Down a) -> Type) (a6989586621679177352 :: a)
Instance details Defined in Data.Ord.Singletons type Apply (DownSym0 :: TyFun a (Down a) -> Type) (a6989586621679177352 :: a) = 'Down a6989586621679177352
type Apply (TFHelper_6989586621679439348Sym0 :: TyFun a (Down b ~> Down a) -> Type) (a6989586621679439353 :: a)
Instance details Defined in Data.Functor.Singletons type Apply (TFHelper_6989586621679439348Sym0 :: TyFun a (Down b ~> Down a) -> Type) (a6989586621679439353 :: a) = TFHelper_6989586621679439348Sym1 a6989586621679439353 :: TyFun (Down b) (Down a) -> Type
type Rep (Down a)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics type Rep (Down a) = D1 ('MetaData "Down" "Data.Ord" "base" 'True) (C1 ('MetaCons "Down" 'PrefixI 'True) (S1 ('MetaSel ('Just "getDown") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Unwrapped (Down a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Down a) = a
type Demote (Down a)
Instance details Defined in Data.Ord.Singletons type Demote (Down a) = Down (Demote a)
type Sing
Instance details Defined in Data.Ord.Singletons type Sing = SDown :: Down a -> Type
type Mempty
Instance details Defined in Data.Monoid.Singletons type Mempty = Mempty_6989586621680118261Sym0 :: Down a
newtype Vector (Down a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Down a) = V_Down (Vector a)
type Rep1 Down	Since: base-4.12.0.0
Instance details Defined in GHC.Generics type Rep1 Down = D1 ('MetaData "Down" "Data.Ord" "base" 'True) (C1 ('MetaCons "Down" 'PrefixI 'True) (S1 ('MetaSel ('Just "getDown") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type Mconcat (arg :: [Down a])
Instance details Defined in Data.Monoid.Singletons type Mconcat (arg :: [Down a]) = Apply (Mconcat_6989586621680102596Sym0 :: TyFun [Down a] (Down a) -> Type) arg
type Sconcat (arg :: NonEmpty (Down a))
Instance details Defined in Data.Semigroup.Singletons.Internal type Sconcat (arg :: NonEmpty (Down a)) = Apply (Sconcat_6989586621679583990Sym0 :: TyFun (NonEmpty (Down a)) (Down a) -> Type) arg
type Abs (a2 :: Down a1)
Instance details Defined in GHC.Num.Singletons type Abs (a2 :: Down a1) = Apply (Abs_6989586621679495702Sym0 :: TyFun (Down a1) (Down a1) -> Type) a2
type FromInteger a2
Instance details Defined in GHC.Num.Singletons type FromInteger a2 = Apply (FromInteger_6989586621679495716Sym0 :: TyFun Nat (Down a1) -> Type) a2
type Negate (a2 :: Down a1)
Instance details Defined in GHC.Num.Singletons type Negate (a2 :: Down a1) = Apply (Negate_6989586621679495695Sym0 :: TyFun (Down a1) (Down a1) -> Type) a2
type Signum (a2 :: Down a1)
Instance details Defined in GHC.Num.Singletons type Signum (a2 :: Down a1) = Apply (Signum_6989586621679495709Sym0 :: TyFun (Down a1) (Down a1) -> Type) a2
type (arg :: Down a) /= (arg1 :: Down a)
Instance details Defined in Data.Ord.Singletons type (arg :: Down a) /= (arg1 :: Down a) = Apply (Apply (TFHelper_6989586621679127817Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type) arg) arg1
type (a2 :: Down a1) == (a3 :: Down a1)
Instance details Defined in Data.Ord.Singletons type (a2 :: Down a1) == (a3 :: Down a1) = Apply (Apply (TFHelper_6989586621679179231Sym0 :: TyFun (Down a1) (Down a1 ~> Bool) -> Type) a2) a3
type Mappend (arg1 :: Down a) (arg2 :: Down a)
Instance details Defined in Data.Monoid.Singletons type Mappend (arg1 :: Down a) (arg2 :: Down a) = Apply (Apply (Mappend_6989586621680102582Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) arg1) arg2
type (arg1 :: Down a) < (arg2 :: Down a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Down a) < (arg2 :: Down a) = Apply (Apply (TFHelper_6989586621679166153Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type) arg1) arg2
type (arg1 :: Down a) <= (arg2 :: Down a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Down a) <= (arg2 :: Down a) = Apply (Apply (TFHelper_6989586621679166169Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type) arg1) arg2
type (arg1 :: Down a) > (arg2 :: Down a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Down a) > (arg2 :: Down a) = Apply (Apply (TFHelper_6989586621679166185Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type) arg1) arg2
type (arg1 :: Down a) >= (arg2 :: Down a)
Instance details Defined in Data.Ord.Singletons type (arg1 :: Down a) >= (arg2 :: Down a) = Apply (Apply (TFHelper_6989586621679166201Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type) arg1) arg2
type Compare (a2 :: Down a1) (a3 :: Down a1)
Instance details Defined in Data.Ord.Singletons type Compare (a2 :: Down a1) (a3 :: Down a1) = Apply (Apply (Compare_6989586621679179242Sym0 :: TyFun (Down a1) (Down a1 ~> Ordering) -> Type) a2) a3
type Max (arg1 :: Down a) (arg2 :: Down a)
Instance details Defined in Data.Ord.Singletons type Max (arg1 :: Down a) (arg2 :: Down a) = Apply (Apply (Max_6989586621679166217Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) arg1) arg2
type Min (arg1 :: Down a) (arg2 :: Down a)
Instance details Defined in Data.Ord.Singletons type Min (arg1 :: Down a) (arg2 :: Down a) = Apply (Apply (Min_6989586621679166233Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) arg1) arg2
type (a2 :: Down a1) <> (a3 :: Down a1)
Instance details Defined in Data.Semigroup.Singletons.Internal type (a2 :: Down a1) <> (a3 :: Down a1) = Apply (Apply (TFHelper_6989586621679584175Sym0 :: TyFun (Down a1) (Down a1 ~> Down a1) -> Type) a2) a3
type (a2 :: Down a1) * (a3 :: Down a1)
Instance details Defined in GHC.Num.Singletons type (a2 :: Down a1) * (a3 :: Down a1) = Apply (Apply (TFHelper_6989586621679495685Sym0 :: TyFun (Down a1) (Down a1 ~> Down a1) -> Type) a2) a3
type (a2 :: Down a1) + (a3 :: Down a1)
Instance details Defined in GHC.Num.Singletons type (a2 :: Down a1) + (a3 :: Down a1) = Apply (Apply (TFHelper_6989586621679495663Sym0 :: TyFun (Down a1) (Down a1 ~> Down a1) -> Type) a2) a3
type (a2 :: Down a1) - (a3 :: Down a1)
Instance details Defined in GHC.Num.Singletons type (a2 :: Down a1) - (a3 :: Down a1) = Apply (Apply (TFHelper_6989586621679495674Sym0 :: TyFun (Down a1) (Down a1 ~> Down a1) -> Type) a2) a3
type Apply (GetDownSym0 :: TyFun (Down a) a -> Type) (a6989586621679177355 :: Down a)
Instance details Defined in Data.Ord.Singletons type Apply (GetDownSym0 :: TyFun (Down a) a -> Type) (a6989586621679177355 :: Down a) = GetDown a6989586621679177355
type Apply (Compare_6989586621679179242Sym1 a6989586621679179247 :: TyFun (Down a) Ordering -> Type) (a6989586621679179248 :: Down a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679179242Sym1 a6989586621679179247 :: TyFun (Down a) Ordering -> Type) (a6989586621679179248 :: Down a) = Compare_6989586621679179242 a6989586621679179247 a6989586621679179248
type Apply (TFHelper_6989586621679179231Sym1 a6989586621679179236 :: TyFun (Down a) Bool -> Type) (a6989586621679179237 :: Down a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679179231Sym1 a6989586621679179236 :: TyFun (Down a) Bool -> Type) (a6989586621679179237 :: Down a) = TFHelper_6989586621679179231 a6989586621679179236 a6989586621679179237
type Apply (Abs_6989586621679495702Sym0 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495706 :: Down a)
Instance details Defined in GHC.Num.Singletons type Apply (Abs_6989586621679495702Sym0 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495706 :: Down a) = Abs_6989586621679495702 a6989586621679495706
type Apply (Negate_6989586621679495695Sym0 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495699 :: Down a)
Instance details Defined in GHC.Num.Singletons type Apply (Negate_6989586621679495695Sym0 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495699 :: Down a) = Negate_6989586621679495695 a6989586621679495699
type Apply (Signum_6989586621679495709Sym0 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495713 :: Down a)
Instance details Defined in GHC.Num.Singletons type Apply (Signum_6989586621679495709Sym0 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495713 :: Down a) = Signum_6989586621679495709 a6989586621679495713
type Apply (TFHelper_6989586621679584175Sym1 a6989586621679584180 :: TyFun (Down a) (Down a) -> Type) (a6989586621679584181 :: Down a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679584175Sym1 a6989586621679584180 :: TyFun (Down a) (Down a) -> Type) (a6989586621679584181 :: Down a) = TFHelper_6989586621679584175 a6989586621679584180 a6989586621679584181
type Apply (TFHelper_6989586621679495663Sym1 a6989586621679495668 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495669 :: Down a)
Instance details Defined in GHC.Num.Singletons type Apply (TFHelper_6989586621679495663Sym1 a6989586621679495668 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495669 :: Down a) = TFHelper_6989586621679495663 a6989586621679495668 a6989586621679495669
type Apply (TFHelper_6989586621679495674Sym1 a6989586621679495679 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495680 :: Down a)
Instance details Defined in GHC.Num.Singletons type Apply (TFHelper_6989586621679495674Sym1 a6989586621679495679 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495680 :: Down a) = TFHelper_6989586621679495674 a6989586621679495679 a6989586621679495680
type Apply (TFHelper_6989586621679495685Sym1 a6989586621679495690 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495691 :: Down a)
Instance details Defined in GHC.Num.Singletons type Apply (TFHelper_6989586621679495685Sym1 a6989586621679495690 :: TyFun (Down a) (Down a) -> Type) (a6989586621679495691 :: Down a) = TFHelper_6989586621679495685 a6989586621679495690 a6989586621679495691
type Apply (TFHelper_6989586621680883156Sym1 a6989586621680883161 :: TyFun (Down a) (Down b) -> Type) (a6989586621680883162 :: Down a)
Instance details Defined in Control.Applicative.Singletons type Apply (TFHelper_6989586621680883156Sym1 a6989586621680883161 :: TyFun (Down a) (Down b) -> Type) (a6989586621680883162 :: Down a) = TFHelper_6989586621680883156 a6989586621680883161 a6989586621680883162
type Apply (Fmap_6989586621679439337Sym1 a6989586621679439342 :: TyFun (Down a) (Down b) -> Type) (a6989586621679439343 :: Down a)
Instance details Defined in Data.Functor.Singletons type Apply (Fmap_6989586621679439337Sym1 a6989586621679439342 :: TyFun (Down a) (Down b) -> Type) (a6989586621679439343 :: Down a) = Fmap_6989586621679439337 a6989586621679439342 a6989586621679439343
type Apply (TFHelper_6989586621679439348Sym1 a6989586621679439353 :: TyFun (Down b) (Down a) -> Type) (a6989586621679439354 :: Down b)
Instance details Defined in Data.Functor.Singletons type Apply (TFHelper_6989586621679439348Sym1 a6989586621679439353 :: TyFun (Down b) (Down a) -> Type) (a6989586621679439354 :: Down b) = TFHelper_6989586621679439348 a6989586621679439353 a6989586621679439354
type Apply (TFHelper_6989586621679584175Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) (a6989586621679584180 :: Down a)
Instance details Defined in Data.Semigroup.Singletons.Internal type Apply (TFHelper_6989586621679584175Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) (a6989586621679584180 :: Down a) = TFHelper_6989586621679584175Sym1 a6989586621679584180
type Apply (TFHelper_6989586621679495663Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) (a6989586621679495668 :: Down a)
Instance details Defined in GHC.Num.Singletons type Apply (TFHelper_6989586621679495663Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) (a6989586621679495668 :: Down a) = TFHelper_6989586621679495663Sym1 a6989586621679495668
type Apply (TFHelper_6989586621679495674Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) (a6989586621679495679 :: Down a)
Instance details Defined in GHC.Num.Singletons type Apply (TFHelper_6989586621679495674Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) (a6989586621679495679 :: Down a) = TFHelper_6989586621679495674Sym1 a6989586621679495679
type Apply (TFHelper_6989586621679495685Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) (a6989586621679495690 :: Down a)
Instance details Defined in GHC.Num.Singletons type Apply (TFHelper_6989586621679495685Sym0 :: TyFun (Down a) (Down a ~> Down a) -> Type) (a6989586621679495690 :: Down a) = TFHelper_6989586621679495685Sym1 a6989586621679495690
type Apply (Compare_6989586621679179242Sym0 :: TyFun (Down a) (Down a ~> Ordering) -> Type) (a6989586621679179247 :: Down a)
Instance details Defined in Data.Ord.Singletons type Apply (Compare_6989586621679179242Sym0 :: TyFun (Down a) (Down a ~> Ordering) -> Type) (a6989586621679179247 :: Down a) = Compare_6989586621679179242Sym1 a6989586621679179247
type Apply (TFHelper_6989586621679179231Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type) (a6989586621679179236 :: Down a)
Instance details Defined in Data.Ord.Singletons type Apply (TFHelper_6989586621679179231Sym0 :: TyFun (Down a) (Down a ~> Bool) -> Type) (a6989586621679179236 :: Down a) = TFHelper_6989586621679179231Sym1 a6989586621679179236
type Apply (TFHelper_6989586621680883156Sym0 :: TyFun (Down (a ~> b)) (Down a ~> Down b) -> Type) (a6989586621680883161 :: Down (a ~> b))
Instance details Defined in Control.Applicative.Singletons type Apply (TFHelper_6989586621680883156Sym0 :: TyFun (Down (a ~> b)) (Down a ~> Down b) -> Type) (a6989586621680883161 :: Down (a ~> b)) = TFHelper_6989586621680883156Sym1 a6989586621680883161
type Apply (TFHelper_6989586621680892758Sym0 :: TyFun (Down a) ((a ~> Down b) ~> Down b) -> Type) (a6989586621680892763 :: Down a)
Instance details Defined in Control.Monad.Singletons type Apply (TFHelper_6989586621680892758Sym0 :: TyFun (Down a) ((a ~> Down b) ~> Down b) -> Type) (a6989586621680892763 :: Down a) = TFHelper_6989586621680892758Sym1 a6989586621680892763 :: TyFun (a ~> Down b) (Down b) -> Type
type Apply (TFHelper_6989586621680892758Sym1 a6989586621680892763 :: TyFun (a ~> Down b) (Down b) -> Type) (a6989586621680892764 :: a ~> Down b)
Instance details Defined in Control.Monad.Singletons type Apply (TFHelper_6989586621680892758Sym1 a6989586621680892763 :: TyFun (a ~> Down b) (Down b) -> Type) (a6989586621680892764 :: a ~> Down b) = TFHelper_6989586621680892758 a6989586621680892763 a6989586621680892764
type Apply (Fmap_6989586621679439337Sym0 :: TyFun (a ~> b) (Down a ~> Down b) -> Type) (a6989586621679439342 :: a ~> b)
Instance details Defined in Data.Functor.Singletons type Apply (Fmap_6989586621679439337Sym0 :: TyFun (a ~> b) (Down a ~> Down b) -> Type) (a6989586621679439342 :: a ~> b) = Fmap_6989586621679439337Sym1 a6989586621679439342

data SomeNat #

This type represents unknown type-level natural numbers.

Since: base-4.10.0.0

Constructors

KnownNat n => SomeNat (Proxy n)

Instances

Instances details

Read SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods readsPrec :: Int -> ReadS SomeNat # readList :: ReadS [SomeNat] # readPrec :: ReadPrec SomeNat # readListPrec :: ReadPrec [SomeNat] #
Show SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods showsPrec :: Int -> SomeNat -> ShowS # show :: SomeNat -> String # showList :: [SomeNat] -> ShowS #
Eq SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods (==) :: SomeNat -> SomeNat -> Bool # (/=) :: SomeNat -> SomeNat -> Bool #
Ord SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods compare :: SomeNat -> SomeNat -> Ordering # (<) :: SomeNat -> SomeNat -> Bool # (<=) :: SomeNat -> SomeNat -> Bool # (>) :: SomeNat -> SomeNat -> Bool # (>=) :: SomeNat -> SomeNat -> Bool # max :: SomeNat -> SomeNat -> SomeNat # min :: SomeNat -> SomeNat -> SomeNat #

someNatVal :: Natural -> SomeNat #

Convert an integer into an unknown type-level natural.

Since: base-4.10.0.0

natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Natural #

Since: base-4.10.0.0

rights :: [Either a b] -> [b] #

Extracts from a list of Either all the Right elements. All the Right elements are extracted in order.

Examples

Expand

Basic usage:

>>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
>>> rights list
[3,7]

lefts :: [Either a b] -> [a] #

Extracts from a list of Either all the Left elements. All the Left elements are extracted in order.

Examples

Expand

Basic usage:

>>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
>>> lefts list
["foo","bar","baz"]

isRight :: Either a b -> Bool #

Return True if the given value is a Right-value, False otherwise.

Examples

Expand

Basic usage:

>>> isRight (Left "foo")
False
>>> isRight (Right 3)
True

Assuming a Left value signifies some sort of error, we can use isRight to write a very simple reporting function that only outputs "SUCCESS" when a computation has succeeded.

This example shows how isRight might be used to avoid pattern matching when one does not care about the value contained in the constructor:

>>> import Control.Monad ( when )
>>> let report e = when (isRight e) $ putStrLn "SUCCESS"
>>> report (Left "parse error")
>>> report (Right 1)
SUCCESS

Since: base-4.7.0.0

isLeft :: Either a b -> Bool #

Return True if the given value is a Left-value, False otherwise.

Examples

Expand

Basic usage:

>>> isLeft (Left "foo")
True
>>> isLeft (Right 3)
False

Assuming a Left value signifies some sort of error, we can use isLeft to write a very simple error-reporting function that does absolutely nothing in the case of success, and outputs "ERROR" if any error occurred.

This example shows how isLeft might be used to avoid pattern matching when one does not care about the value contained in the constructor:

>>> import Control.Monad ( when )
>>> let report e = when (isLeft e) $ putStrLn "ERROR"
>>> report (Right 1)
>>> report (Left "parse error")
ERROR

Since: base-4.7.0.0

data IOMode #

See openFile

Constructors

ReadMode
WriteMode
AppendMode
ReadWriteMode

Instances

Instances details

Enum IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods succ :: IOMode -> IOMode # pred :: IOMode -> IOMode # toEnum :: Int -> IOMode # fromEnum :: IOMode -> Int # enumFrom :: IOMode -> [IOMode] # enumFromThen :: IOMode -> IOMode -> [IOMode] # enumFromTo :: IOMode -> IOMode -> [IOMode] # enumFromThenTo :: IOMode -> IOMode -> IOMode -> [IOMode] #
Ix IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods range :: (IOMode, IOMode) -> [IOMode] # index :: (IOMode, IOMode) -> IOMode -> Int # unsafeIndex :: (IOMode, IOMode) -> IOMode -> Int # inRange :: (IOMode, IOMode) -> IOMode -> Bool # rangeSize :: (IOMode, IOMode) -> Int # unsafeRangeSize :: (IOMode, IOMode) -> Int #
Read IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods readsPrec :: Int -> ReadS IOMode # readList :: ReadS [IOMode] # readPrec :: ReadPrec IOMode # readListPrec :: ReadPrec [IOMode] #
Show IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods showsPrec :: Int -> IOMode -> ShowS # show :: IOMode -> String # showList :: [IOMode] -> ShowS #
Eq IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods (==) :: IOMode -> IOMode -> Bool # (/=) :: IOMode -> IOMode -> Bool #
Ord IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods compare :: IOMode -> IOMode -> Ordering # (<) :: IOMode -> IOMode -> Bool # (<=) :: IOMode -> IOMode -> Bool # (>) :: IOMode -> IOMode -> Bool # (>=) :: IOMode -> IOMode -> Bool # max :: IOMode -> IOMode -> IOMode # min :: IOMode -> IOMode -> IOMode #

underflowError :: a #

reduce :: Integral a => a -> a -> Ratio a #

reduce is a subsidiary function used only in this module. It normalises a ratio by dividing both numerator and denominator by their greatest common divisor.

ratioZeroDenominatorError :: a #

ratioPrec1 :: Int #

ratioPrec :: Int #

overflowError :: a #

numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a] #

numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a] #

numericEnumFromThen :: Fractional a => a -> a -> [a] #

numericEnumFrom :: Fractional a => a -> [a] #

numerator :: Ratio a -> a #

Extract the numerator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.

notANumber :: Rational #

naturalFromInt :: Int -> Natural #

Convert an Int into a Natural, throwing an underflow exception for negative values.

integralEnumFromTo :: Integral a => a -> a -> [a] #

integralEnumFromThenTo :: Integral a => a -> a -> a -> [a] #

integralEnumFromThen :: (Integral a, Bounded a) => a -> a -> [a] #

integralEnumFrom :: (Integral a, Bounded a) => a -> [a] #

infinity :: Rational #

divZeroError :: a #

denominator :: Ratio a -> a #

Extract the denominator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.

(^^%^^) :: Integral a => Rational -> a -> Rational #

(^%^) :: Integral a => Rational -> a -> Rational #

boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a] #

boundedEnumFrom :: (Enum a, Bounded a) => a -> [a] #

bool :: a -> a -> Bool -> a #

Case analysis for the Bool type. bool x y p evaluates to x when p is False, and evaluates to y when p is True.

This is equivalent to if p then y else x; that is, one can think of it as an if-then-else construct with its arguments reordered.

Examples

Expand

Basic usage:

>>> bool "foo" "bar" True
"bar"
>>> bool "foo" "bar" False
"foo"

Confirm that bool x y p and if p then y else x are equivalent:

>>> let p = True; x = "bar"; y = "foo"
>>> bool x y p == if p then y else x
True
>>> let p = False
>>> bool x y p == if p then y else x
True

Since: base-4.7.0.0

(&) :: a -> (a -> b) -> b infixl 1 #

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

(<&>) :: Functor f => f a -> (a -> b) -> f b infixl 1 #

Flipped version of <$>.

(<&>) = flip fmap

Examples

Expand

Apply (+1) to a list, a Just and a Right:

>>> Just 2 <&> (+1)
Just 3

>>> [1,2,3] <&> (+1)
[2,3,4]

>>> Right 3 <&> (+1)
Right 4

Since: base-4.11.0.0

($>) :: Functor f => f a -> b -> f b infixl 4 #

Flipped version of <$.

Examples

Expand

Replace the contents of a Maybe Int with a constant String:

>>> Nothing $> "foo"
Nothing
>>> Just 90210 $> "foo"
Just "foo"

Replace the contents of an Either Int Int with a constant String, resulting in an Either Int String:

>>> Left 8675309 $> "foo"
Left 8675309
>>> Right 8675309 $> "foo"
Right "foo"

Replace each element of a list with a constant String:

>>> [1,2,3] $> "foo"
["foo","foo","foo"]

Replace the second element of a pair with a constant String:

>>> (1,2) $> "foo"
(1,"foo")

Since: base-4.7.0.0

swap :: (a, b) -> (b, a) #

Swap the components of a pair.

currentCallStack :: IO [String] #

Returns a [String] representing the current call stack. This can be useful for debugging.

The implementation uses the call-stack simulation maintained by the profiler, so it only works if the program was compiled with -prof and contains suitable SCC annotations (e.g. by using -fprof-auto). Otherwise, the list returned is likely to be empty or uninformative.

Since: base-4.5.0.0

minInt :: Int #

maxInt :: Int #

liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d #

Lift a ternary function to actions.

(<**>) :: Applicative f => f a -> f (a -> b) -> f b infixl 4 #

A variant of <*> with the arguments reversed.

type HasCallStack = ?callStack :: CallStack #

Request a CallStack.

NOTE: The implicit parameter ?callStack :: CallStack is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.9.0.0

getCallStack :: CallStack -> [([Char], SrcLoc)] #

Extract a list of call-sites from the CallStack.

The list is ordered by most recent call.

Since: base-4.8.1.0

stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a #

This is a valid definition of stimes for an idempotent Monoid.

When mappend x x = x, this definition should be preferred, because it works in $\mathcal{O}(1)$ rather than $\mathcal{O}(\log n)$

data IdentityT (f :: k -> Type) (a :: k) #

The trivial monad transformer, which maps a monad to an equivalent monad.

Instances

Instances details

MonadError e m => MonadError e (IdentityT m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> IdentityT m a # catchError :: IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a #
MonadReader r m => MonadReader r (IdentityT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: IdentityT m r # local :: (r -> r) -> IdentityT m a -> IdentityT m a # reader :: (r -> a) -> IdentityT m a #
MonadState s m => MonadState s (IdentityT m)
Instance details Defined in Control.Monad.State.Class Methods get :: IdentityT m s # put :: s -> IdentityT m () # state :: (s -> (a, s)) -> IdentityT m a #
MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Trans.Identity Methods lift :: Monad m => m a -> IdentityT m a #
Representable m => Representable (IdentityT m)
Instance details Defined in Data.Functor.Rep Associated Types type Rep (IdentityT m) # Methods tabulate :: (Rep (IdentityT m) -> a) -> IdentityT m a # index :: IdentityT m a -> Rep (IdentityT m) -> a #
MonadFail m => MonadFail (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods fail :: String -> IdentityT m a #
MonadFix m => MonadFix (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods mfix :: (a -> IdentityT m a) -> IdentityT m a #
MonadIO m => MonadIO (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a #
MonadZip m => MonadZip (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods mzip :: IdentityT m a -> IdentityT m b -> IdentityT m (a, b) # mzipWith :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c # munzip :: IdentityT m (a, b) -> (IdentityT m a, IdentityT m b) #
Foldable f => Foldable (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods fold :: Monoid m => IdentityT f m -> m # foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m # foldMap' :: Monoid m => (a -> m) -> IdentityT f a -> m # foldr :: (a -> b -> b) -> b -> IdentityT f a -> b # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b # foldl :: (b -> a -> b) -> b -> IdentityT f a -> b # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b # foldr1 :: (a -> a -> a) -> IdentityT f a -> a # foldl1 :: (a -> a -> a) -> IdentityT f a -> a # toList :: IdentityT f a -> [a] # null :: IdentityT f a -> Bool # length :: IdentityT f a -> Int # elem :: Eq a => a -> IdentityT f a -> Bool # maximum :: Ord a => IdentityT f a -> a # minimum :: Ord a => IdentityT f a -> a # sum :: Num a => IdentityT f a -> a # product :: Num a => IdentityT f a -> a #
Eq1 f => Eq1 (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods liftEq :: (a -> b -> Bool) -> IdentityT f a -> IdentityT f b -> Bool #
Ord1 f => Ord1 (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods liftCompare :: (a -> b -> Ordering) -> IdentityT f a -> IdentityT f b -> Ordering #
Read1 f => Read1 (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (IdentityT f a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [IdentityT f a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (IdentityT f a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [IdentityT f a] #
Show1 f => Show1 (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> IdentityT f a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [IdentityT f a] -> ShowS #
Contravariant f => Contravariant (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods contramap :: (a' -> a) -> IdentityT f a -> IdentityT f a' # (>$) :: b -> IdentityT f b -> IdentityT f a #
Traversable f => Traversable (IdentityT f)
Instance details Defined in Control.Monad.Trans.Identity Methods traverse :: Applicative f0 => (a -> f0 b) -> IdentityT f a -> f0 (IdentityT f b) # sequenceA :: Applicative f0 => IdentityT f (f0 a) -> f0 (IdentityT f a) # mapM :: Monad m => (a -> m b) -> IdentityT f a -> m (IdentityT f b) # sequence :: Monad m => IdentityT f (m a) -> m (IdentityT f a) #
Alternative m => Alternative (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods empty :: IdentityT m a # (<\|>) :: IdentityT m a -> IdentityT m a -> IdentityT m a # some :: IdentityT m a -> IdentityT m [a] # many :: IdentityT m a -> IdentityT m [a] #
Applicative m => Applicative (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods pure :: a -> IdentityT m a # (<>) :: IdentityT m (a -> b) -> IdentityT m a -> IdentityT m b # liftA2 :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c # (>) :: IdentityT m a -> IdentityT m b -> IdentityT m b # (<*) :: IdentityT m a -> IdentityT m b -> IdentityT m a #
Functor m => Functor (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods fmap :: (a -> b) -> IdentityT m a -> IdentityT m b # (<$) :: a -> IdentityT m b -> IdentityT m a #
Monad m => Monad (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods (>>=) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b # (>>) :: IdentityT m a -> IdentityT m b -> IdentityT m b # return :: a -> IdentityT m a #
MonadPlus m => MonadPlus (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods mzero :: IdentityT m a # mplus :: IdentityT m a -> IdentityT m a -> IdentityT m a #
MonadCatch m => MonadCatch (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a #
MonadMask m => MonadMask (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b # uninterruptibleMask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b # generalBracket :: IdentityT m a -> (a -> ExitCase b -> IdentityT m c) -> (a -> IdentityT m b) -> IdentityT m (b, c) #
MonadThrow m => MonadThrow (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> IdentityT m a #
PrimBase m => PrimBase (IdentityT m)	Since: primitive-0.6.2.0
Instance details Defined in Control.Monad.Primitive Methods internal :: IdentityT m a -> State# (PrimState (IdentityT m)) -> (# State# (PrimState (IdentityT m)), a #) #
PrimMonad m => PrimMonad (IdentityT m)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState (IdentityT m) # Methods primitive :: (State# (PrimState (IdentityT m)) -> (# State# (PrimState (IdentityT m)), a #)) -> IdentityT m a #
Magnify m n b a => Magnify (IdentityT m) (IdentityT n) b a
Instance details Defined in Control.Lens.Zoom Methods magnify :: ((Functor (Magnified (IdentityT m) c), Contravariant (Magnified (IdentityT m) c)) => LensLike' (Magnified (IdentityT m) c) a b) -> IdentityT m c -> IdentityT n c #
Zoom m n s t => Zoom (IdentityT m) (IdentityT n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (IdentityT m) c) t s -> IdentityT m c -> IdentityT n c #
Magnify m n b a => Magnify (IdentityT m) (IdentityT n) b a
Instance details Defined in Lens.Micro.Mtl.Internal Methods magnify :: LensLike' (Magnified (IdentityT m) c) a b -> IdentityT m c -> IdentityT n c #
Zoom m n s t => Zoom (IdentityT m) (IdentityT n) s t
Instance details Defined in Lens.Micro.Mtl.Internal Methods zoom :: LensLike' (Zoomed (IdentityT m) c) t s -> IdentityT m c -> IdentityT n c #
(Read1 f, Read a) => Read (IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods readsPrec :: Int -> ReadS (IdentityT f a) # readList :: ReadS [IdentityT f a] # readPrec :: ReadPrec (IdentityT f a) # readListPrec :: ReadPrec [IdentityT f a] #
(Show1 f, Show a) => Show (IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods showsPrec :: Int -> IdentityT f a -> ShowS # show :: IdentityT f a -> String # showList :: [IdentityT f a] -> ShowS #
(Eq1 f, Eq a) => Eq (IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods (==) :: IdentityT f a -> IdentityT f a -> Bool # (/=) :: IdentityT f a -> IdentityT f a -> Bool #
(Ord1 f, Ord a) => Ord (IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Methods compare :: IdentityT f a -> IdentityT f a -> Ordering # (<) :: IdentityT f a -> IdentityT f a -> Bool # (<=) :: IdentityT f a -> IdentityT f a -> Bool # (>) :: IdentityT f a -> IdentityT f a -> Bool # (>=) :: IdentityT f a -> IdentityT f a -> Bool # max :: IdentityT f a -> IdentityT f a -> IdentityT f a # min :: IdentityT f a -> IdentityT f a -> IdentityT f a #
Wrapped (IdentityT m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (IdentityT m a) # Methods _Wrapped' :: Iso' (IdentityT m a) (Unwrapped (IdentityT m a)) #
t ~ IdentityT n b => Rewrapped (IdentityT m a) t
Instance details Defined in Control.Lens.Wrapped
type Rep (IdentityT m)
Instance details Defined in Data.Functor.Rep type Rep (IdentityT m) = Rep m
type Magnified (IdentityT m)
Instance details Defined in Control.Lens.Zoom type Magnified (IdentityT m) = Magnified m
type Zoomed (IdentityT m)
Instance details Defined in Control.Lens.Zoom type Zoomed (IdentityT m) = Zoomed m
type Magnified (IdentityT m)
Instance details Defined in Lens.Micro.Mtl.Internal type Magnified (IdentityT m) = Magnified m
type Zoomed (IdentityT m)
Instance details Defined in Lens.Micro.Mtl.Internal type Zoomed (IdentityT m) = Zoomed m
type PrimState (IdentityT m)
Instance details Defined in Control.Monad.Primitive type PrimState (IdentityT m) = PrimState m
type Unwrapped (IdentityT m a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (IdentityT m a) = m a

withDict :: HasDict c e => e -> (c => r) -> r #

From a Dict, takes a value in an environment where the instance witnessed by the Dict is in scope, and evaluates it.

Essentially a deconstruction of a Dict into its continuation-style form.

Can also be used to deconstruct an entailment, a :- b, using a context a.

withDict :: Dict c -> (c => r) -> r
withDict :: a => (a :- c) -> (c => r) -> r

data IntMap a #

A map of integers to values a.

Instances

Instances details

Foldable IntMap	Folds in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m # foldMap :: Monoid m => (a -> m) -> IntMap a -> m # foldMap' :: Monoid m => (a -> m) -> IntMap a -> m # foldr :: (a -> b -> b) -> b -> IntMap a -> b # foldr' :: (a -> b -> b) -> b -> IntMap a -> b # foldl :: (b -> a -> b) -> b -> IntMap a -> b # foldl' :: (b -> a -> b) -> b -> IntMap a -> b # foldr1 :: (a -> a -> a) -> IntMap a -> a # foldl1 :: (a -> a -> a) -> IntMap a -> a # toList :: IntMap a -> [a] # null :: IntMap a -> Bool # length :: IntMap a -> Int # elem :: Eq a => a -> IntMap a -> Bool # maximum :: Ord a => IntMap a -> a # minimum :: Ord a => IntMap a -> a # sum :: Num a => IntMap a -> a # product :: Num a => IntMap a -> a #
Eq1 IntMap	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods liftEq :: (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool #
Ord1 IntMap	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods liftCompare :: (a -> b -> Ordering) -> IntMap a -> IntMap b -> Ordering #
Read1 IntMap	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (IntMap a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [IntMap a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (IntMap a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [IntMap a] #
Show1 IntMap	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> IntMap a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [IntMap a] -> ShowS #
Traversable IntMap	Traverses in order of increasing key.
Instance details Defined in Data.IntMap.Internal Methods traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b) # sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a) # mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b) # sequence :: Monad m => IntMap (m a) -> m (IntMap a) #
Functor IntMap
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> IntMap a -> IntMap b # (<$) :: a -> IntMap b -> IntMap a #
Hashable1 IntMap	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> IntMap a -> Int #
Structured v => Structured (IntMap v)
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy (IntMap v) -> Structure # structureHash' :: Tagged (IntMap v) MD5
Data a => Data (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntMap a -> c (IntMap a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IntMap a) # toConstr :: IntMap a -> Constr # dataTypeOf :: IntMap a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (IntMap a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IntMap a)) # gmapT :: (forall b. Data b => b -> b) -> IntMap a -> IntMap a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntMap a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntMap a -> r # gmapQ :: (forall d. Data d => d -> u) -> IntMap a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IntMap a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a) #
Monoid (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods mempty :: IntMap a # mappend :: IntMap a -> IntMap a -> IntMap a # mconcat :: [IntMap a] -> IntMap a #
Semigroup (IntMap a)	Since: containers-0.5.7
Instance details Defined in Data.IntMap.Internal Methods (<>) :: IntMap a -> IntMap a -> IntMap a # sconcat :: NonEmpty (IntMap a) -> IntMap a # stimes :: Integral b => b -> IntMap a -> IntMap a #
IsList (IntMap a)	Since: containers-0.5.6.2
Instance details Defined in Data.IntMap.Internal Associated Types type Item (IntMap a) # Methods fromList :: [Item (IntMap a)] -> IntMap a # fromListN :: Int -> [Item (IntMap a)] -> IntMap a # toList :: IntMap a -> [Item (IntMap a)] #
Read e => Read (IntMap e)
Instance details Defined in Data.IntMap.Internal Methods readsPrec :: Int -> ReadS (IntMap e) # readList :: ReadS [IntMap e] # readPrec :: ReadPrec (IntMap e) # readListPrec :: ReadPrec [IntMap e] #
Show a => Show (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods showsPrec :: Int -> IntMap a -> ShowS # show :: IntMap a -> String # showList :: [IntMap a] -> ShowS #
NFData a => NFData (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods rnf :: IntMap a -> () #
Eq a => Eq (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods (==) :: IntMap a -> IntMap a -> Bool # (/=) :: IntMap a -> IntMap a -> Bool #
Ord a => Ord (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods compare :: IntMap a -> IntMap a -> Ordering # (<) :: IntMap a -> IntMap a -> Bool # (<=) :: IntMap a -> IntMap a -> Bool # (>) :: IntMap a -> IntMap a -> Bool # (>=) :: IntMap a -> IntMap a -> Bool # max :: IntMap a -> IntMap a -> IntMap a # min :: IntMap a -> IntMap a -> IntMap a #
Hashable v => Hashable (IntMap v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntMap v -> Int # hash :: IntMap v -> Int #
At (IntMap a)
Instance details Defined in Control.Lens.At Methods at :: Index (IntMap a) -> Lens' (IntMap a) (Maybe (IxValue (IntMap a))) #
Ixed (IntMap a)
Instance details Defined in Control.Lens.At Methods ix :: Index (IntMap a) -> Traversal' (IntMap a) (IxValue (IntMap a)) #
Wrapped (IntMap a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (IntMap a) # Methods _Wrapped' :: Iso' (IntMap a) (Unwrapped (IntMap a)) #
Container (IntMap v)
Instance details Defined in Universum.Container.Class Associated Types type Element (IntMap v) # Methods toList :: IntMap v -> [Element (IntMap v)] # null :: IntMap v -> Bool # foldr :: (Element (IntMap v) -> b -> b) -> b -> IntMap v -> b # foldl :: (b -> Element (IntMap v) -> b) -> b -> IntMap v -> b # foldl' :: (b -> Element (IntMap v) -> b) -> b -> IntMap v -> b # length :: IntMap v -> Int # elem :: Element (IntMap v) -> IntMap v -> Bool # foldMap :: Monoid m => (Element (IntMap v) -> m) -> IntMap v -> m # fold :: IntMap v -> Element (IntMap v) # foldr' :: (Element (IntMap v) -> b -> b) -> b -> IntMap v -> b # notElem :: Element (IntMap v) -> IntMap v -> Bool # all :: (Element (IntMap v) -> Bool) -> IntMap v -> Bool # any :: (Element (IntMap v) -> Bool) -> IntMap v -> Bool # and :: IntMap v -> Bool # or :: IntMap v -> Bool # find :: (Element (IntMap v) -> Bool) -> IntMap v -> Maybe (Element (IntMap v)) # safeHead :: IntMap v -> Maybe (Element (IntMap v)) # safeMaximum :: IntMap v -> Maybe (Element (IntMap v)) # safeMinimum :: IntMap v -> Maybe (Element (IntMap v)) # safeFoldr1 :: (Element (IntMap v) -> Element (IntMap v) -> Element (IntMap v)) -> IntMap v -> Maybe (Element (IntMap v)) # safeFoldl1 :: (Element (IntMap v) -> Element (IntMap v) -> Element (IntMap v)) -> IntMap v -> Maybe (Element (IntMap v)) #
FromList (IntMap v)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (IntMap v) # type FromListC (IntMap v) # Methods fromList :: [ListElement (IntMap v)] -> IntMap v #
One (IntMap v)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (IntMap v) # Methods one :: OneItem (IntMap v) -> IntMap v #
ToPairs (IntMap v)
Instance details Defined in Universum.Container.Class Associated Types type Key (IntMap v) # type Val (IntMap v) # Methods toPairs :: IntMap v -> [(Key (IntMap v), Val (IntMap v))] # keys :: IntMap v -> [Key (IntMap v)] # elems :: IntMap v -> [Val (IntMap v)] #
t ~ IntMap a' => Rewrapped (IntMap a) t	Use `wrapping fromList`. unwrapping returns a sorted list.
Instance details Defined in Control.Lens.Wrapped
type Item (IntMap a)
Instance details Defined in Data.IntMap.Internal type Item (IntMap a) = (Key, a)
type Index (IntMap a)
Instance details Defined in Control.Lens.At type Index (IntMap a) = Int
type IxValue (IntMap a)
Instance details Defined in Control.Lens.At type IxValue (IntMap a) = a
type Unwrapped (IntMap a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (IntMap a) = [(Int, a)]
type Element (IntMap v)
Instance details Defined in Universum.Container.Class type Element (IntMap v) = ElementDefault (IntMap v)
type FromListC (IntMap v)
Instance details Defined in Universum.Container.Class type FromListC (IntMap v) = ()
type Key (IntMap v)
Instance details Defined in Universum.Container.Class type Key (IntMap v) = Int
type ListElement (IntMap v)
Instance details Defined in Universum.Container.Class type ListElement (IntMap v) = Item (IntMap v)
type OneItem (IntMap v)
Instance details Defined in Universum.Container.Class type OneItem (IntMap v) = (Int, v)
type Val (IntMap v)
Instance details Defined in Universum.Container.Class type Val (IntMap v) = v

data IntSet #

A set of integers.

Instances

Instances details

Structured IntSet
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy IntSet -> Structure # structureHash' :: Tagged IntSet MD5
Data IntSet
Instance details Defined in Data.IntSet.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntSet -> c IntSet # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntSet # toConstr :: IntSet -> Constr # dataTypeOf :: IntSet -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IntSet) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntSet) # gmapT :: (forall b. Data b => b -> b) -> IntSet -> IntSet # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntSet -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntSet -> r # gmapQ :: (forall d. Data d => d -> u) -> IntSet -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IntSet -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntSet -> m IntSet # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntSet -> m IntSet # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntSet -> m IntSet #
Monoid IntSet
Instance details Defined in Data.IntSet.Internal Methods mempty :: IntSet # mappend :: IntSet -> IntSet -> IntSet # mconcat :: [IntSet] -> IntSet #
Semigroup IntSet	Since: containers-0.5.7
Instance details Defined in Data.IntSet.Internal Methods (<>) :: IntSet -> IntSet -> IntSet # sconcat :: NonEmpty IntSet -> IntSet # stimes :: Integral b => b -> IntSet -> IntSet #
IsList IntSet	Since: containers-0.5.6.2
Instance details Defined in Data.IntSet.Internal Associated Types type Item IntSet # Methods fromList :: [Item IntSet] -> IntSet # fromListN :: Int -> [Item IntSet] -> IntSet # toList :: IntSet -> [Item IntSet] #
Read IntSet
Instance details Defined in Data.IntSet.Internal Methods readsPrec :: Int -> ReadS IntSet # readList :: ReadS [IntSet] # readPrec :: ReadPrec IntSet # readListPrec :: ReadPrec [IntSet] #
Show IntSet
Instance details Defined in Data.IntSet.Internal Methods showsPrec :: Int -> IntSet -> ShowS # show :: IntSet -> String # showList :: [IntSet] -> ShowS #
NFData IntSet
Instance details Defined in Data.IntSet.Internal Methods rnf :: IntSet -> () #
Eq IntSet
Instance details Defined in Data.IntSet.Internal Methods (==) :: IntSet -> IntSet -> Bool # (/=) :: IntSet -> IntSet -> Bool #
Ord IntSet
Instance details Defined in Data.IntSet.Internal Methods compare :: IntSet -> IntSet -> Ordering # (<) :: IntSet -> IntSet -> Bool # (<=) :: IntSet -> IntSet -> Bool # (>) :: IntSet -> IntSet -> Bool # (>=) :: IntSet -> IntSet -> Bool # max :: IntSet -> IntSet -> IntSet # min :: IntSet -> IntSet -> IntSet #
Hashable IntSet	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> IntSet -> Int # hash :: IntSet -> Int #
At IntSet
Instance details Defined in Control.Lens.At Methods at :: Index IntSet -> Lens' IntSet (Maybe (IxValue IntSet)) #
Contains IntSet
Instance details Defined in Control.Lens.At Methods contains :: Index IntSet -> Lens' IntSet Bool #
Ixed IntSet
Instance details Defined in Control.Lens.At Methods ix :: Index IntSet -> Traversal' IntSet (IxValue IntSet) #
Wrapped IntSet
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped IntSet # Methods _Wrapped' :: Iso' IntSet (Unwrapped IntSet) #
Container IntSet
Instance details Defined in Universum.Container.Class Associated Types type Element IntSet # Methods toList :: IntSet -> [Element IntSet] # null :: IntSet -> Bool # foldr :: (Element IntSet -> b -> b) -> b -> IntSet -> b # foldl :: (b -> Element IntSet -> b) -> b -> IntSet -> b # foldl' :: (b -> Element IntSet -> b) -> b -> IntSet -> b # length :: IntSet -> Int # elem :: Element IntSet -> IntSet -> Bool # foldMap :: Monoid m => (Element IntSet -> m) -> IntSet -> m # fold :: IntSet -> Element IntSet # foldr' :: (Element IntSet -> b -> b) -> b -> IntSet -> b # notElem :: Element IntSet -> IntSet -> Bool # all :: (Element IntSet -> Bool) -> IntSet -> Bool # any :: (Element IntSet -> Bool) -> IntSet -> Bool # and :: IntSet -> Bool # or :: IntSet -> Bool # find :: (Element IntSet -> Bool) -> IntSet -> Maybe (Element IntSet) # safeHead :: IntSet -> Maybe (Element IntSet) # safeMaximum :: IntSet -> Maybe (Element IntSet) # safeMinimum :: IntSet -> Maybe (Element IntSet) # safeFoldr1 :: (Element IntSet -> Element IntSet -> Element IntSet) -> IntSet -> Maybe (Element IntSet) # safeFoldl1 :: (Element IntSet -> Element IntSet -> Element IntSet) -> IntSet -> Maybe (Element IntSet) #
FromList IntSet
Instance details Defined in Universum.Container.Class Associated Types type ListElement IntSet # type FromListC IntSet # Methods fromList :: [ListElement IntSet] -> IntSet #
One IntSet
Instance details Defined in Universum.Container.Class Associated Types type OneItem IntSet # Methods one :: OneItem IntSet -> IntSet #
t ~ IntSet => Rewrapped IntSet t	Use `wrapping fromList`. unwrapping returns a sorted list.
Instance details Defined in Control.Lens.Wrapped
type Item IntSet
Instance details Defined in Data.IntSet.Internal type Item IntSet = Key
type Index IntSet
Instance details Defined in Control.Lens.At type Index IntSet = Int
type IxValue IntSet
Instance details Defined in Control.Lens.At type IxValue IntSet = ()
type Unwrapped IntSet
Instance details Defined in Control.Lens.Wrapped type Unwrapped IntSet = [Int]
type Element IntSet
Instance details Defined in Universum.Container.Class type Element IntSet = Int
type FromListC IntSet
Instance details Defined in Universum.Container.Class type FromListC IntSet = ()
type ListElement IntSet
Instance details Defined in Universum.Container.Class type ListElement IntSet = Item IntSet
type OneItem IntSet
Instance details Defined in Universum.Container.Class type OneItem IntSet = Int

data Seq a #

General-purpose finite sequences.

Instances

Instances details

MonadFix Seq	Since: containers-0.5.11
Instance details Defined in Data.Sequence.Internal Methods mfix :: (a -> Seq a) -> Seq a #
MonadZip Seq	`mzipWith` = `zipWith` `munzip` = `unzip`
Instance details Defined in Data.Sequence.Internal Methods mzip :: Seq a -> Seq b -> Seq (a, b) # mzipWith :: (a -> b -> c) -> Seq a -> Seq b -> Seq c # munzip :: Seq (a, b) -> (Seq a, Seq b) #
Foldable Seq
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m # foldMap :: Monoid m => (a -> m) -> Seq a -> m # foldMap' :: Monoid m => (a -> m) -> Seq a -> m # foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b # foldl :: (b -> a -> b) -> b -> Seq a -> b # foldl' :: (b -> a -> b) -> b -> Seq a -> b # foldr1 :: (a -> a -> a) -> Seq a -> a # foldl1 :: (a -> a -> a) -> Seq a -> a # toList :: Seq a -> [a] # null :: Seq a -> Bool # length :: Seq a -> Int # elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # minimum :: Ord a => Seq a -> a # sum :: Num a => Seq a -> a # product :: Num a => Seq a -> a #
Eq1 Seq	Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftEq :: (a -> b -> Bool) -> Seq a -> Seq b -> Bool #
Ord1 Seq	Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftCompare :: (a -> b -> Ordering) -> Seq a -> Seq b -> Ordering #
Read1 Seq	Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Seq a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Seq a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Seq a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Seq a] #
Show1 Seq	Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Seq a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Seq a] -> ShowS #
Traversable Seq
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) # sequenceA :: Applicative f => Seq (f a) -> f (Seq a) # mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) # sequence :: Monad m => Seq (m a) -> m (Seq a) #
Alternative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods empty :: Seq a # (<\|>) :: Seq a -> Seq a -> Seq a # some :: Seq a -> Seq [a] # many :: Seq a -> Seq [a] #
Applicative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods pure :: a -> Seq a # (<>) :: Seq (a -> b) -> Seq a -> Seq b # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c # (>) :: Seq a -> Seq b -> Seq b # (<*) :: Seq a -> Seq b -> Seq a #
Functor Seq
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Seq a -> Seq b # (<$) :: a -> Seq b -> Seq a #
Monad Seq
Instance details Defined in Data.Sequence.Internal Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b # (>>) :: Seq a -> Seq b -> Seq b # return :: a -> Seq a #
MonadPlus Seq
Instance details Defined in Data.Sequence.Internal Methods mzero :: Seq a # mplus :: Seq a -> Seq a -> Seq a #
UnzipWith Seq
Instance details Defined in Data.Sequence.Internal Methods unzipWith' :: (x -> (a, b)) -> Seq x -> (Seq a, Seq b)
Hashable1 Seq	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Seq a -> Int #
Structured v => Structured (Seq v)
Instance details Defined in Distribution.Utils.Structured Methods structure :: Proxy (Seq v) -> Structure # structureHash' :: Tagged (Seq v) MD5
Data a => Data (Seq a)
Instance details Defined in Data.Sequence.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Seq a -> c (Seq a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Seq a) # toConstr :: Seq a -> Constr # dataTypeOf :: Seq a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Seq a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Seq a)) # gmapT :: (forall b. Data b => b -> b) -> Seq a -> Seq a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r # gmapQ :: (forall d. Data d => d -> u) -> Seq a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Seq a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) #
a ~ Char => IsString (Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods fromString :: String -> Seq a #
Monoid (Seq a)
Instance details Defined in Data.Sequence.Internal Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
Semigroup (Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods (<>) :: Seq a -> Seq a -> Seq a # sconcat :: NonEmpty (Seq a) -> Seq a # stimes :: Integral b => b -> Seq a -> Seq a #
IsList (Seq a)
Instance details Defined in Data.Sequence.Internal Associated Types type Item (Seq a) # Methods fromList :: [Item (Seq a)] -> Seq a # fromListN :: Int -> [Item (Seq a)] -> Seq a # toList :: Seq a -> [Item (Seq a)] #
Read a => Read (Seq a)
Instance details Defined in Data.Sequence.Internal Methods readsPrec :: Int -> ReadS (Seq a) # readList :: ReadS [Seq a] # readPrec :: ReadPrec (Seq a) # readListPrec :: ReadPrec [Seq a] #
Show a => Show (Seq a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> Seq a -> ShowS # show :: Seq a -> String # showList :: [Seq a] -> ShowS #
NFData a => NFData (Seq a)
Instance details Defined in Data.Sequence.Internal Methods rnf :: Seq a -> () #
Eq a => Eq (Seq a)
Instance details Defined in Data.Sequence.Internal Methods (==) :: Seq a -> Seq a -> Bool # (/=) :: Seq a -> Seq a -> Bool #
Ord a => Ord (Seq a)
Instance details Defined in Data.Sequence.Internal Methods compare :: Seq a -> Seq a -> Ordering # (<) :: Seq a -> Seq a -> Bool # (<=) :: Seq a -> Seq a -> Bool # (>) :: Seq a -> Seq a -> Bool # (>=) :: Seq a -> Seq a -> Bool # max :: Seq a -> Seq a -> Seq a # min :: Seq a -> Seq a -> Seq a #
Hashable v => Hashable (Seq v)	Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Seq v -> Int # hash :: Seq v -> Int #
Ixed (Seq a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Seq a) -> Traversal' (Seq a) (IxValue (Seq a)) #
Wrapped (Seq a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Seq a) # Methods _Wrapped' :: Iso' (Seq a) (Unwrapped (Seq a)) #
Ord a => Stream (Seq a)	Since: megaparsec-9.0.0
Instance details Defined in Text.Megaparsec.Stream Associated Types type Token (Seq a) # type Tokens (Seq a) # Methods tokenToChunk :: Proxy (Seq a) -> Token (Seq a) -> Tokens (Seq a) # tokensToChunk :: Proxy (Seq a) -> [Token (Seq a)] -> Tokens (Seq a) # chunkToTokens :: Proxy (Seq a) -> Tokens (Seq a) -> [Token (Seq a)] # chunkLength :: Proxy (Seq a) -> Tokens (Seq a) -> Int # chunkEmpty :: Proxy (Seq a) -> Tokens (Seq a) -> Bool # take1_ :: Seq a -> Maybe (Token (Seq a), Seq a) # takeN_ :: Int -> Seq a -> Maybe (Tokens (Seq a), Seq a) # takeWhile_ :: (Token (Seq a) -> Bool) -> Seq a -> (Tokens (Seq a), Seq a) #
Container (Seq a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Seq a) # Methods toList :: Seq a -> [Element (Seq a)] # null :: Seq a -> Bool # foldr :: (Element (Seq a) -> b -> b) -> b -> Seq a -> b # foldl :: (b -> Element (Seq a) -> b) -> b -> Seq a -> b # foldl' :: (b -> Element (Seq a) -> b) -> b -> Seq a -> b # length :: Seq a -> Int # elem :: Element (Seq a) -> Seq a -> Bool # foldMap :: Monoid m => (Element (Seq a) -> m) -> Seq a -> m # fold :: Seq a -> Element (Seq a) # foldr' :: (Element (Seq a) -> b -> b) -> b -> Seq a -> b # notElem :: Element (Seq a) -> Seq a -> Bool # all :: (Element (Seq a) -> Bool) -> Seq a -> Bool # any :: (Element (Seq a) -> Bool) -> Seq a -> Bool # and :: Seq a -> Bool # or :: Seq a -> Bool # find :: (Element (Seq a) -> Bool) -> Seq a -> Maybe (Element (Seq a)) # safeHead :: Seq a -> Maybe (Element (Seq a)) # safeMaximum :: Seq a -> Maybe (Element (Seq a)) # safeMinimum :: Seq a -> Maybe (Element (Seq a)) # safeFoldr1 :: (Element (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Maybe (Element (Seq a)) # safeFoldl1 :: (Element (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Maybe (Element (Seq a)) #
FromList (Seq a)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (Seq a) # type FromListC (Seq a) # Methods fromList :: [ListElement (Seq a)] -> Seq a #
One (Seq a)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Seq a) # Methods one :: OneItem (Seq a) -> Seq a #
t ~ Seq a' => Rewrapped (Seq a) t
Instance details Defined in Control.Lens.Wrapped
type Item (Seq a)
Instance details Defined in Data.Sequence.Internal type Item (Seq a) = a
type Index (Seq a)
Instance details Defined in Control.Lens.At type Index (Seq a) = Int
type IxValue (Seq a)
Instance details Defined in Control.Lens.At type IxValue (Seq a) = a
type Unwrapped (Seq a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Seq a) = [a]
type Token (Seq a)
Instance details Defined in Text.Megaparsec.Stream type Token (Seq a) = a
type Tokens (Seq a)
Instance details Defined in Text.Megaparsec.Stream type Tokens (Seq a) = Seq a
type Element (Seq a)
Instance details Defined in Universum.Container.Class type Element (Seq a) = ElementDefault (Seq a)
type FromListC (Seq a)
Instance details Defined in Universum.Container.Class type FromListC (Seq a) = ()
type ListElement (Seq a)
Instance details Defined in Universum.Container.Class type ListElement (Seq a) = Item (Seq a)
type OneItem (Seq a)
Instance details Defined in Universum.Container.Class type OneItem (Seq a) = a

class Default a where #

A class for types with a default value.

Minimal complete definition

Nothing

Methods

def :: a #

The default value for this type.

Instances

Instances details

Default All
Instance details Defined in Data.Default.Class Methods def :: All #
Default Any
Instance details Defined in Data.Default.Class Methods def :: Any #
Default CClock
Instance details Defined in Data.Default.Class Methods def :: CClock #
Default CDouble
Instance details Defined in Data.Default.Class Methods def :: CDouble #
Default CFloat
Instance details Defined in Data.Default.Class Methods def :: CFloat #
Default CInt
Instance details Defined in Data.Default.Class Methods def :: CInt #
Default CIntMax
Instance details Defined in Data.Default.Class Methods def :: CIntMax #
Default CIntPtr
Instance details Defined in Data.Default.Class Methods def :: CIntPtr #
Default CLLong
Instance details Defined in Data.Default.Class Methods def :: CLLong #
Default CLong
Instance details Defined in Data.Default.Class Methods def :: CLong #
Default CPtrdiff
Instance details Defined in Data.Default.Class Methods def :: CPtrdiff #
Default CSUSeconds
Instance details Defined in Data.Default.Class Methods def :: CSUSeconds #
Default CShort
Instance details Defined in Data.Default.Class Methods def :: CShort #
Default CSigAtomic
Instance details Defined in Data.Default.Class Methods def :: CSigAtomic #
Default CSize
Instance details Defined in Data.Default.Class Methods def :: CSize #
Default CTime
Instance details Defined in Data.Default.Class Methods def :: CTime #
Default CUInt
Instance details Defined in Data.Default.Class Methods def :: CUInt #
Default CUIntMax
Instance details Defined in Data.Default.Class Methods def :: CUIntMax #
Default CUIntPtr
Instance details Defined in Data.Default.Class Methods def :: CUIntPtr #
Default CULLong
Instance details Defined in Data.Default.Class Methods def :: CULLong #
Default CULong
Instance details Defined in Data.Default.Class Methods def :: CULong #
Default CUSeconds
Instance details Defined in Data.Default.Class Methods def :: CUSeconds #
Default CUShort
Instance details Defined in Data.Default.Class Methods def :: CUShort #
Default Int16
Instance details Defined in Data.Default.Class Methods def :: Int16 #
Default Int32
Instance details Defined in Data.Default.Class Methods def :: Int32 #
Default Int64
Instance details Defined in Data.Default.Class Methods def :: Int64 #
Default Int8
Instance details Defined in Data.Default.Class Methods def :: Int8 #
Default Word16
Instance details Defined in Data.Default.Class Methods def :: Word16 #
Default Word32
Instance details Defined in Data.Default.Class Methods def :: Word32 #
Default Word64
Instance details Defined in Data.Default.Class Methods def :: Word64 #
Default Ordering
Instance details Defined in Data.Default.Class Methods def :: Ordering #
Default CommentSettings Source #
Instance details Defined in Indigo.Compilation.Hooks Methods def :: CommentSettings #
Default AnnOptions
Instance details Defined in Lorentz.Annotation Methods def :: AnnOptions #
Default DeriveRPCOptions
Instance details Defined in Morley.AsRPC Methods def :: DeriveRPCOptions #
Default ErrorSrcPos
Instance details Defined in Morley.Michelson.ErrorPos Methods def :: ErrorSrcPos #
Default Pos
Instance details Defined in Morley.Michelson.ErrorPos Methods def :: Pos #
Default SrcPos
Instance details Defined in Morley.Michelson.ErrorPos Methods def :: SrcPos #
Default MorleyLogsBuilder
Instance details Defined in Morley.Michelson.Interpret Methods def :: MorleyLogsBuilder #
Default OptimizerConf
Instance details Defined in Morley.Michelson.Optimizer Methods def :: OptimizerConf #
Default Ruleset
Instance details Defined in Morley.Michelson.Optimizer Methods def :: Ruleset #
Default EntriesOrder
Instance details Defined in Morley.Michelson.Untyped.Contract Methods def :: EntriesOrder #
Default Word8
Instance details Defined in Data.Default.Class Methods def :: Word8 #
Default Integer
Instance details Defined in Data.Default.Class Methods def :: Integer #
Default ()
Instance details Defined in Data.Default.Class Methods def :: () #
Default Double
Instance details Defined in Data.Default.Class Methods def :: Double #
Default Float
Instance details Defined in Data.Default.Class Methods def :: Float #
Default Int
Instance details Defined in Data.Default.Class Methods def :: Int #
Default Word
Instance details Defined in Data.Default.Class Methods def :: Word #
(Default a, RealFloat a) => Default (Complex a)
Instance details Defined in Data.Default.Class Methods def :: Complex a #
Default (First a)
Instance details Defined in Data.Default.Class Methods def :: First a #
Default (Last a)
Instance details Defined in Data.Default.Class Methods def :: Last a #
Default a => Default (Dual a)
Instance details Defined in Data.Default.Class Methods def :: Dual a #
Default (Endo a)
Instance details Defined in Data.Default.Class Methods def :: Endo a #
Num a => Default (Product a)
Instance details Defined in Data.Default.Class Methods def :: Product a #
Num a => Default (Sum a)
Instance details Defined in Data.Default.Class Methods def :: Sum a #
Integral a => Default (Ratio a)
Instance details Defined in Data.Default.Class Methods def :: Ratio a #
Default a => Default (IO a)
Instance details Defined in Data.Default.Class Methods def :: IO a #
(KnownValue x, Default (StackVars xs)) => Default (StackVars (x ': xs)) Source #
Instance details Defined in Indigo.Common.Var Methods def :: StackVars (x ': xs) #
Default (StackVars ('[] :: [Type])) Source #
Instance details Defined in Indigo.Common.Var Methods def :: StackVars '[] #
Default (ViewsSetF a)
Instance details Defined in Morley.Michelson.Internal.ViewsSet Methods def :: ViewsSetF a #
(SingI t, Default (Anns xs)) => Default (Anns (Notes t ': xs))
Instance details Defined in Morley.Michelson.Typed.Annotation Methods def :: Anns (Notes t ': xs) #
(Typeable tag, Default (Anns xs)) => Default (Anns (Annotation tag ': xs))
Instance details Defined in Morley.Michelson.Typed.Annotation Methods def :: Anns (Annotation tag ': xs) #
Default (Anns ('[] :: [Type]))
Instance details Defined in Morley.Michelson.Typed.Annotation Methods def :: Anns '[] #
Default (ViewsSet instr)
Instance details Defined in Morley.Michelson.Untyped.View Methods def :: ViewsSet instr #
Default (Maybe a)
Instance details Defined in Data.Default.Class Methods def :: Maybe a #
Default [a]
Instance details Defined in Data.Default.Class Methods def :: [a] #
Default (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods def :: BigMap k v #
Default (ViewsSet' instr st)
Instance details Defined in Morley.Michelson.Typed.View Methods def :: ViewsSet' instr st #
Default (Annotation tag)
Instance details Defined in Morley.Michelson.Untyped.Annotation Methods def :: Annotation tag #
Default r => Default (e -> r)
Instance details Defined in Data.Default.Class Methods def :: e -> r #
(Default a, Default b) => Default (a, b)
Instance details Defined in Data.Default.Class Methods def :: (a, b) #
(Default a, Default b, Default c) => Default (a, b, c)
Instance details Defined in Data.Default.Class Methods def :: (a, b, c) #
(Default a, Default b, Default c, Default d) => Default (a, b, c, d)
Instance details Defined in Data.Default.Class Methods def :: (a, b, c, d) #
(Default a, Default b, Default c, Default d, Default e) => Default (a, b, c, d, e)
Instance details Defined in Data.Default.Class Methods def :: (a, b, c, d, e) #
(Default a, Default b, Default c, Default d, Default e, Default f) => Default (a, b, c, d, e, f)
Instance details Defined in Data.Default.Class Methods def :: (a, b, c, d, e, f) #
(Default a, Default b, Default c, Default d, Default e, Default f, Default g) => Default (a, b, c, d, e, f, g)
Instance details Defined in Data.Default.Class Methods def :: (a, b, c, d, e, f, g) #

($!!) :: NFData a => (a -> b) -> a -> b infixr 0 #

the deep analogue of $!. In the expression f $!! x, x is fully evaluated before the function f is applied to it.

Since: deepseq-1.2.0.0

runExceptT :: ExceptT e m a -> m (Either e a) #

The inverse of ExceptT.

newtype ExceptT e (m :: Type -> Type) a #

A monad transformer that adds exceptions to other monads.

ExceptT constructs a monad parameterized over two things:

e - The exception type.
m - The inner monad.

The return function yields a computation that produces the given value, while >>= sequences two subcomputations, exiting on the first exception.

Constructors

ExceptT (m (Either e a))

Instances

Instances details

Monad m => MonadError e (ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> ExceptT e m a # catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a #
MonadReader r m => MonadReader r (ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ExceptT e m r # local :: (r -> r) -> ExceptT e m a -> ExceptT e m a # reader :: (r -> a) -> ExceptT e m a #
MonadState s m => MonadState s (ExceptT e m)	Since: mtl-2.2
Instance details Defined in Control.Monad.State.Class Methods get :: ExceptT e m s # put :: s -> ExceptT e m () # state :: (s -> (a, s)) -> ExceptT e m a #
MonadTrans (ExceptT e)
Instance details Defined in Control.Monad.Trans.Except Methods lift :: Monad m => m a -> ExceptT e m a #
MonadFail m => MonadFail (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods fail :: String -> ExceptT e m a #
MonadFix m => MonadFix (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mfix :: (a -> ExceptT e m a) -> ExceptT e m a #
MonadIO m => MonadIO (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a #
MonadZip m => MonadZip (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mzip :: ExceptT e m a -> ExceptT e m b -> ExceptT e m (a, b) # mzipWith :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c # munzip :: ExceptT e m (a, b) -> (ExceptT e m a, ExceptT e m b) #
Foldable f => Foldable (ExceptT e f)
Instance details Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m # foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] # null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # sum :: Num a => ExceptT e f a -> a # product :: Num a => ExceptT e f a -> a #
(Eq e, Eq1 m) => Eq1 (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftEq :: (a -> b -> Bool) -> ExceptT e m a -> ExceptT e m b -> Bool #
(Ord e, Ord1 m) => Ord1 (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftCompare :: (a -> b -> Ordering) -> ExceptT e m a -> ExceptT e m b -> Ordering #
(Read e, Read1 m) => Read1 (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ExceptT e m a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ExceptT e m a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ExceptT e m a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ExceptT e m a] #
(Show e, Show1 m) => Show1 (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ExceptT e m a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ExceptT e m a] -> ShowS #
Contravariant m => Contravariant (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods contramap :: (a' -> a) -> ExceptT e m a -> ExceptT e m a' # (>$) :: b -> ExceptT e m b -> ExceptT e m a #
Traversable f => Traversable (ExceptT e f)
Instance details Defined in Control.Monad.Trans.Except Methods traverse :: Applicative f0 => (a -> f0 b) -> ExceptT e f a -> f0 (ExceptT e f b) # sequenceA :: Applicative f0 => ExceptT e f (f0 a) -> f0 (ExceptT e f a) # mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b) # sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a) #
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods empty :: ExceptT e m a # (<\|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # some :: ExceptT e m a -> ExceptT e m [a] # many :: ExceptT e m a -> ExceptT e m [a] #
(Functor m, Monad m) => Applicative (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods pure :: a -> ExceptT e m a # (<>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b # liftA2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c # (>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # (<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a #
Functor m => Functor (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b # (<$) :: a -> ExceptT e m b -> ExceptT e m a #
Monad m => Monad (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # return :: a -> ExceptT e m a #
(Monad m, Monoid e) => MonadPlus (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mzero :: ExceptT e m a # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
MonadCatch m => MonadCatch (ExceptT e m)	Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e0 => ExceptT e m a -> (e0 -> ExceptT e m a) -> ExceptT e m a #
MonadMask m => MonadMask (ExceptT e m)	Since: exceptions-0.9.0
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b # uninterruptibleMask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b # generalBracket :: ExceptT e m a -> (a -> ExitCase b -> ExceptT e m c) -> (a -> ExceptT e m b) -> ExceptT e m (b, c) #
MonadThrow m => MonadThrow (ExceptT e m)	Throws exceptions into the base monad.
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e0 => e0 -> ExceptT e m a #
InterpreterStateMonad m => InterpreterStateMonad (ExceptT e m)
Instance details Defined in Morley.Michelson.Interpret Methods getInterpreterState :: ExceptT e m InterpreterState # putInterpreterState :: InterpreterState -> ExceptT e m () # stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> ExceptT e m a # modifyInterpreterState :: (InterpreterState -> InterpreterState) -> ExceptT e m () #
PrimMonad m => PrimMonad (ExceptT e m)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState (ExceptT e m) # Methods primitive :: (State# (PrimState (ExceptT e m)) -> (# State# (PrimState (ExceptT e m)), a #)) -> ExceptT e m a #
Zoom m n s t => Zoom (ExceptT e m) (ExceptT e n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (ExceptT e m) c) t s -> ExceptT e m c -> ExceptT e n c #
Zoom m n s t => Zoom (ExceptT e m) (ExceptT e n) s t
Instance details Defined in Lens.Micro.Mtl.Internal Methods zoom :: LensLike' (Zoomed (ExceptT e m) c) t s -> ExceptT e m c -> ExceptT e n c #
(Read e, Read1 m, Read a) => Read (ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods readsPrec :: Int -> ReadS (ExceptT e m a) # readList :: ReadS [ExceptT e m a] # readPrec :: ReadPrec (ExceptT e m a) # readListPrec :: ReadPrec [ExceptT e m a] #
(Show e, Show1 m, Show a) => Show (ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods showsPrec :: Int -> ExceptT e m a -> ShowS # show :: ExceptT e m a -> String # showList :: [ExceptT e m a] -> ShowS #
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods (==) :: ExceptT e m a -> ExceptT e m a -> Bool # (/=) :: ExceptT e m a -> ExceptT e m a -> Bool #
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # max :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # min :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
Wrapped (ExceptT e m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ExceptT e m a) # Methods _Wrapped' :: Iso' (ExceptT e m a) (Unwrapped (ExceptT e m a)) #
t ~ ExceptT e' m' a' => Rewrapped (ExceptT e m a) t
Instance details Defined in Control.Lens.Wrapped
type Zoomed (ExceptT e m)
Instance details Defined in Control.Lens.Zoom type Zoomed (ExceptT e m) = FocusingErr e (Zoomed m)
type Zoomed (ExceptT e m)
Instance details Defined in Lens.Micro.Mtl.Internal type Zoomed (ExceptT e m) = FocusingErr e (Zoomed m)
type PrimState (ExceptT e m)
Instance details Defined in Control.Monad.Primitive type PrimState (ExceptT e m) = PrimState m
type Unwrapped (ExceptT e m a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (ExceptT e m a) = m (Either e a)

newtype MaybeT (m :: Type -> Type) a #

The parameterizable maybe monad, obtained by composing an arbitrary monad with the Maybe monad.

Computations are actions that may produce a value or exit.

The return function yields a computation that produces that value, while >>= sequences two subcomputations, exiting if either computation does.

Constructors

MaybeT
Fields runMaybeT :: m (Maybe a)

Instances

Instances details

MonadTrans MaybeT
Instance details Defined in Control.Monad.Trans.Maybe Methods lift :: Monad m => m a -> MaybeT m a #
MonadError e m => MonadError e (MaybeT m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> MaybeT m a # catchError :: MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a #
MonadReader r m => MonadReader r (MaybeT m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: MaybeT m r # local :: (r -> r) -> MaybeT m a -> MaybeT m a # reader :: (r -> a) -> MaybeT m a #
MonadState s m => MonadState s (MaybeT m)
Instance details Defined in Control.Monad.State.Class Methods get :: MaybeT m s # put :: s -> MaybeT m () # state :: (s -> (a, s)) -> MaybeT m a #
Monad m => MonadFail (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fail :: String -> MaybeT m a #
MonadFix m => MonadFix (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mfix :: (a -> MaybeT m a) -> MaybeT m a #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a #
MonadZip m => MonadZip (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mzip :: MaybeT m a -> MaybeT m b -> MaybeT m (a, b) # mzipWith :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c # munzip :: MaybeT m (a, b) -> (MaybeT m a, MaybeT m b) #
Foldable f => Foldable (MaybeT f)
Instance details Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m # foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m # foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b # foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b # foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # toList :: MaybeT f a -> [a] # null :: MaybeT f a -> Bool # length :: MaybeT f a -> Int # elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # sum :: Num a => MaybeT f a -> a # product :: Num a => MaybeT f a -> a #
Eq1 m => Eq1 (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftEq :: (a -> b -> Bool) -> MaybeT m a -> MaybeT m b -> Bool #
Ord1 m => Ord1 (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftCompare :: (a -> b -> Ordering) -> MaybeT m a -> MaybeT m b -> Ordering #
Read1 m => Read1 (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (MaybeT m a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [MaybeT m a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (MaybeT m a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [MaybeT m a] #
Show1 m => Show1 (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> MaybeT m a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [MaybeT m a] -> ShowS #
Contravariant m => Contravariant (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods contramap :: (a' -> a) -> MaybeT m a -> MaybeT m a' # (>$) :: b -> MaybeT m b -> MaybeT m a #
Traversable f => Traversable (MaybeT f)
Instance details Defined in Control.Monad.Trans.Maybe Methods traverse :: Applicative f0 => (a -> f0 b) -> MaybeT f a -> f0 (MaybeT f b) # sequenceA :: Applicative f0 => MaybeT f (f0 a) -> f0 (MaybeT f a) # mapM :: Monad m => (a -> m b) -> MaybeT f a -> m (MaybeT f b) # sequence :: Monad m => MaybeT f (m a) -> m (MaybeT f a) #
(Functor m, Monad m) => Alternative (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods empty :: MaybeT m a # (<\|>) :: MaybeT m a -> MaybeT m a -> MaybeT m a # some :: MaybeT m a -> MaybeT m [a] # many :: MaybeT m a -> MaybeT m [a] #
(Functor m, Monad m) => Applicative (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods pure :: a -> MaybeT m a # (<>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b # liftA2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c # (>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # (<*) :: MaybeT m a -> MaybeT m b -> MaybeT m a #
Functor m => Functor (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fmap :: (a -> b) -> MaybeT m a -> MaybeT m b # (<$) :: a -> MaybeT m b -> MaybeT m a #
Monad m => Monad (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods (>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b # (>>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # return :: a -> MaybeT m a #
Monad m => MonadPlus (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mzero :: MaybeT m a # mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a #
MonadCatch m => MonadCatch (MaybeT m)	Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a #
MonadMask m => MonadMask (MaybeT m)	Since: exceptions-0.10.0
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b # uninterruptibleMask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b # generalBracket :: MaybeT m a -> (a -> ExitCase b -> MaybeT m c) -> (a -> MaybeT m b) -> MaybeT m (b, c) #
MonadThrow m => MonadThrow (MaybeT m)	Throws exceptions into the base monad.
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> MaybeT m a #
PrimMonad m => PrimMonad (MaybeT m)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState (MaybeT m) # Methods primitive :: (State# (PrimState (MaybeT m)) -> (# State# (PrimState (MaybeT m)), a #)) -> MaybeT m a #
Zoom m n s t => Zoom (MaybeT m) (MaybeT n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (MaybeT m) c) t s -> MaybeT m c -> MaybeT n c #
Zoom m n s t => Zoom (MaybeT m) (MaybeT n) s t
Instance details Defined in Lens.Micro.Mtl.Internal Methods zoom :: LensLike' (Zoomed (MaybeT m) c) t s -> MaybeT m c -> MaybeT n c #
(Read1 m, Read a) => Read (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods readsPrec :: Int -> ReadS (MaybeT m a) # readList :: ReadS [MaybeT m a] # readPrec :: ReadPrec (MaybeT m a) # readListPrec :: ReadPrec [MaybeT m a] #
(Show1 m, Show a) => Show (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods showsPrec :: Int -> MaybeT m a -> ShowS # show :: MaybeT m a -> String # showList :: [MaybeT m a] -> ShowS #
(Eq1 m, Eq a) => Eq (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods (==) :: MaybeT m a -> MaybeT m a -> Bool # (/=) :: MaybeT m a -> MaybeT m a -> Bool #
(Ord1 m, Ord a) => Ord (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Methods compare :: MaybeT m a -> MaybeT m a -> Ordering # (<) :: MaybeT m a -> MaybeT m a -> Bool # (<=) :: MaybeT m a -> MaybeT m a -> Bool # (>) :: MaybeT m a -> MaybeT m a -> Bool # (>=) :: MaybeT m a -> MaybeT m a -> Bool # max :: MaybeT m a -> MaybeT m a -> MaybeT m a # min :: MaybeT m a -> MaybeT m a -> MaybeT m a #
Wrapped (MaybeT m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (MaybeT m a) # Methods _Wrapped' :: Iso' (MaybeT m a) (Unwrapped (MaybeT m a)) #
t ~ MaybeT n b => Rewrapped (MaybeT m a) t
Instance details Defined in Control.Lens.Wrapped
type Zoomed (MaybeT m)
Instance details Defined in Control.Lens.Zoom type Zoomed (MaybeT m) = FocusingMay (Zoomed m)
type Zoomed (MaybeT m)
Instance details Defined in Lens.Micro.Mtl.Internal type Zoomed (MaybeT m) = FocusingMay (Zoomed m)
type PrimState (MaybeT m)
Instance details Defined in Control.Monad.Primitive type PrimState (MaybeT m) = PrimState m
type Unwrapped (MaybeT m a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (MaybeT m a) = m (Maybe a)

class Monad m => MonadThrow (m :: Type -> Type) #

A class for monads in which exceptions may be thrown.

Instances should obey the following law:

throwM e >> x = throwM e

In other words, throwing an exception short-circuits the rest of the monadic computation.

Minimal complete definition

throwM

Instances

Instances details

MonadThrow STM
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> STM a #
MonadThrow IO
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> IO a #
MonadThrow Q
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> Q a #
MonadThrow Maybe
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> Maybe a #
MonadThrow []
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> [a] #
e ~ SomeException => MonadThrow (Either e)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e0 => e0 -> Either e a #
MonadThrow (ST s)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> ST s a #
MonadThrow m => MonadThrow (ListT m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> ListT m a #
MonadThrow m => MonadThrow (MaybeT m)	Throws exceptions into the base monad.
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> MaybeT m a #
(Functor f, MonadThrow m) => MonadThrow (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods throwM :: Exception e => e -> FreeT f m a #
(Error e, MonadThrow m) => MonadThrow (ErrorT e m)	Throws exceptions into the base monad.
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e0 => e0 -> ErrorT e m a #
MonadThrow m => MonadThrow (ExceptT e m)	Throws exceptions into the base monad.
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e0 => e0 -> ExceptT e m a #
MonadThrow m => MonadThrow (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> IdentityT m a #
MonadThrow m => MonadThrow (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> ReaderT r m a #
MonadThrow m => MonadThrow (StateT s m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> StateT s m a #
MonadThrow m => MonadThrow (StateT s m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> StateT s m a #
(MonadThrow m, Monoid w) => MonadThrow (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> WriterT w m a #
(MonadThrow m, Monoid w) => MonadThrow (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> WriterT w m a #
MonadThrow m => MonadThrow (ContT r m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> ContT r m a #
(MonadThrow m, Monoid w) => MonadThrow (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> RWST r w s m a #
(MonadThrow m, Monoid w) => MonadThrow (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> RWST r w s m a #

class MonadCatch m => MonadMask (m :: Type -> Type) where #

A class for monads which provide for the ability to account for all possible exit points from a computation, and to mask asynchronous exceptions. Continuation-based monads are invalid instances of this class.

Instances should ensure that, in the following code:

fg = f `finally` g

The action g is called regardless of what occurs within f, including async exceptions. Some monads allow f to abort the computation via other effects than throwing an exception. For simplicity, we will consider aborting and throwing an exception to be two forms of "throwing an error".

If f and g both throw an error, the error thrown by fg depends on which errors we're talking about. In a monad transformer stack, the deeper layers override the effects of the inner layers; for example, ExceptT e1 (Except e2) a represents a value of type Either e2 (Either e1 a), so throwing both an e1 and an e2 will result in Left e2. If f and g both throw an error from the same layer, instances should ensure that the error from g wins.

Effects other than throwing an error are also overriden by the deeper layers. For example, StateT s Maybe a represents a value of type s -> Maybe (a, s), so if an error thrown from f causes this function to return Nothing, any changes to the state which f also performed will be erased. As a result, g will see the state as it was before f. Once g completes, f's error will be rethrown, so g' state changes will be erased as well. This is the normal interaction between effects in a monad transformer stack.

By contrast, lifted-base's version of finally always discards all of g's non-IO effects, and g never sees any of f's non-IO effects, regardless of the layer ordering and regardless of whether f throws an error. This is not the result of interacting effects, but a consequence of MonadBaseControl's approach.

Methods

mask :: ((forall a. m a -> m a) -> m b) -> m b #

Runs an action with asynchronous exceptions disabled. The action is provided a method for restoring the async. environment to what it was at the mask call. See Control.Exception's mask.

uninterruptibleMask :: ((forall a. m a -> m a) -> m b) -> m b #

Like mask, but the masked computation is not interruptible (see Control.Exception's uninterruptibleMask. WARNING: Only use if you need to mask exceptions around an interruptible operation AND you can guarantee the interruptible operation will only block for a short period of time. Otherwise you render the program/thread unresponsive and/or unkillable.

generalBracket #

Arguments

:: m a	acquire some resource
-> (a -> ExitCase b -> m c)	release the resource, observing the outcome of the inner action
-> (a -> m b)	inner action to perform with the resource
-> m (b, c)

A generalized version of bracket which uses ExitCase to distinguish the different exit cases, and returns the values of both the use and release actions. In practice, this extra information is rarely needed, so it is often more convenient to use one of the simpler functions which are defined in terms of this one, such as bracket, finally, onError, and bracketOnError.

This function exists because in order to thread their effects through the execution of bracket, monad transformers need values to be threaded from use to release and from release to the output value.

NOTE This method was added in version 0.9.0 of this library. Previously, implementation of functions like bracket and finally in this module were based on the mask and uninterruptibleMask functions only, disallowing some classes of tranformers from having MonadMask instances (notably multi-exit-point transformers like ExceptT). If you are a library author, you'll now need to provide an implementation for this method. The StateT implementation demonstrates most of the subtleties:

generalBracket acquire release use = StateT $ s0 -> do
  ((b, _s2), (c, s3)) <- generalBracket
    (runStateT acquire s0)
    ((resource, s1) exitCase -> case exitCase of
      ExitCaseSuccess (b, s2) -> runStateT (release resource (ExitCaseSuccess b)) s2

      -- In the two other cases, the base monad overrides use's state
      -- changes and the state reverts to s1.
      ExitCaseException e     -> runStateT (release resource (ExitCaseException e)) s1
      ExitCaseAbort           -> runStateT (release resource ExitCaseAbort) s1
    )
    ((resource, s1) -> runStateT (use resource) s1)
  return ((b, c), s3)

The StateT s m implementation of generalBracket delegates to the m implementation of generalBracket. The acquire, use, and release arguments given to StateT's implementation produce actions of type StateT s m a, StateT s m b, and StateT s m c. In order to run those actions in the base monad, we need to call runStateT, from which we obtain actions of type m (a, s), m (b, s), and m (c, s). Since each action produces the next state, it is important to feed the state produced by the previous action to the next action.

In the ExitCaseSuccess case, the state starts at s0, flows through acquire to become s1, flows through use to become s2, and finally flows through release to become s3. In the other two cases, release does not receive the value s2, so its action cannot see the state changes performed by use. This is fine, because in those two cases, an error was thrown in the base monad, so as per the usual interaction between effects in a monad transformer stack, those state changes get reverted. So we start from s1 instead.

Finally, the m implementation of generalBracket returns the pairs (b, s) and (c, s). For monad transformers other than StateT, this will be some other type representing the effects and values performed and returned by the use and release actions. The effect part of the use result, in this case _s2, usually needs to be discarded, since those effects have already been incorporated in the release action.

The only effect which is intentionally not incorporated in the release action is the effect of throwing an error. In that case, the error must be re-thrown. One subtlety which is easy to miss is that in the case in which use and release both throw an error, the error from release should take priority. Here is an implementation for ExceptT which demonstrates how to do this.

generalBracket acquire release use = ExceptT $ do
  (eb, ec) <- generalBracket
    (runExceptT acquire)
    (eresource exitCase -> case eresource of
      Left e -> return (Left e) -- nothing to release, acquire didn't succeed
      Right resource -> case exitCase of
        ExitCaseSuccess (Right b) -> runExceptT (release resource (ExitCaseSuccess b))
        ExitCaseException e       -> runExceptT (release resource (ExitCaseException e))
        _                         -> runExceptT (release resource ExitCaseAbort))
    (either (return . Left) (runExceptT . use))
  return $ do
    -- The order in which we perform those two Either effects determines
    -- which error will win if they are both Lefts. We want the error from
    -- release to win.
    c <- ec
    b <- eb
    return (b, c)

Since: exceptions-0.9.0

Instances

Instances details

MonadMask IO
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b # uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b # generalBracket :: IO a -> (a -> ExitCase b -> IO c) -> (a -> IO b) -> IO (b, c) #
e ~ SomeException => MonadMask (Either e)	Since: exceptions-0.8.3
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b # uninterruptibleMask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b # generalBracket :: Either e a -> (a -> ExitCase b -> Either e c) -> (a -> Either e b) -> Either e (b, c) #
MonadMask m => MonadMask (MaybeT m)	Since: exceptions-0.10.0
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b # uninterruptibleMask :: ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b # generalBracket :: MaybeT m a -> (a -> ExitCase b -> MaybeT m c) -> (a -> MaybeT m b) -> MaybeT m (b, c) #
(Error e, MonadMask m) => MonadMask (ErrorT e m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b # uninterruptibleMask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b # generalBracket :: ErrorT e m a -> (a -> ExitCase b -> ErrorT e m c) -> (a -> ErrorT e m b) -> ErrorT e m (b, c) #
MonadMask m => MonadMask (ExceptT e m)	Since: exceptions-0.9.0
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b # uninterruptibleMask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b # generalBracket :: ExceptT e m a -> (a -> ExitCase b -> ExceptT e m c) -> (a -> ExceptT e m b) -> ExceptT e m (b, c) #
MonadMask m => MonadMask (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b # uninterruptibleMask :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b # generalBracket :: IdentityT m a -> (a -> ExitCase b -> IdentityT m c) -> (a -> IdentityT m b) -> IdentityT m (b, c) #
MonadMask m => MonadMask (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b # uninterruptibleMask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b # generalBracket :: ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c) #
MonadMask m => MonadMask (StateT s m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c) #
MonadMask m => MonadMask (StateT s m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c) #
(MonadMask m, Monoid w) => MonadMask (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # generalBracket :: WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c) #
(MonadMask m, Monoid w) => MonadMask (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # generalBracket :: WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c) #
(MonadMask m, Monoid w) => MonadMask (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # generalBracket :: RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c) #
(MonadMask m, Monoid w) => MonadMask (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # generalBracket :: RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c) #

class MonadThrow m => MonadCatch (m :: Type -> Type) #

A class for monads which allow exceptions to be caught, in particular exceptions which were thrown by throwM.

Instances should obey the following law:

catch (throwM e) f = f e

Note that the ability to catch an exception does not guarantee that we can deal with all possible exit points from a computation. Some monads, such as continuation-based stacks, allow for more than just a success/failure strategy, and therefore catch cannot be used by those monads to properly implement a function such as finally. For more information, see MonadMask.

Minimal complete definition

catch

Instances

Instances details

MonadCatch STM
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => STM a -> (e -> STM a) -> STM a #
MonadCatch IO
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => IO a -> (e -> IO a) -> IO a #
e ~ SomeException => MonadCatch (Either e)	Since: exceptions-0.8.3
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e0 => Either e a -> (e0 -> Either e a) -> Either e a #
MonadCatch m => MonadCatch (ListT m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => ListT m a -> (e -> ListT m a) -> ListT m a #
MonadCatch m => MonadCatch (MaybeT m)	Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a #
(Functor f, MonadCatch m) => MonadCatch (FreeT f m)
Instance details Defined in Control.Monad.Trans.Free Methods catch :: Exception e => FreeT f m a -> (e -> FreeT f m a) -> FreeT f m a #
(Error e, MonadCatch m) => MonadCatch (ErrorT e m)	Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e0 => ErrorT e m a -> (e0 -> ErrorT e m a) -> ErrorT e m a #
MonadCatch m => MonadCatch (ExceptT e m)	Catches exceptions from the base monad.
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e0 => ExceptT e m a -> (e0 -> ExceptT e m a) -> ExceptT e m a #
MonadCatch m => MonadCatch (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a #
MonadCatch m => MonadCatch (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a #
MonadCatch m => MonadCatch (StateT s m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadCatch m => MonadCatch (StateT s m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => StateT s m a -> (e -> StateT s m a) -> StateT s m a #
(MonadCatch m, Monoid w) => MonadCatch (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
(MonadCatch m, Monoid w) => MonadCatch (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
(MonadCatch m, Monoid w) => MonadCatch (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #
(MonadCatch m, Monoid w) => MonadCatch (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #

type family IntBaseType a :: IntBaseTypeK #

The (open) type family IntBaseType encodes type-level information about the value range of an integral type.

This module also provides type family instances for the standard Haskell 2010 integral types (including Foreign.C.Types) as well as the Natural type.

Here's a simple example for registering a custom type with the Data.IntCast facilities:

-- user-implemented unsigned 4-bit integer
data Nibble = …

-- declare meta-information
type instance IntBaseType Nibble = FixedWordTag 4

-- user-implemented signed 7-bit integer
data MyInt7 = …

-- declare meta-information
type instance IntBaseType MyInt7 = FixedIntTag 7

The type-level predicate IsIntSubType provides a partial ordering based on the types above. See also intCast.

Instances

Instances details

type IntBaseType Word62
Instance details Defined in Morley.Prelude.Word type IntBaseType Word62 = 'FixedWordTag 62
type IntBaseType Word63
Instance details Defined in Morley.Prelude.Word type IntBaseType Word63 = 'FixedWordTag 63
type IntBaseType CChar
Instance details Defined in Data.IntCast type IntBaseType CChar = IntBaseType Int8
type IntBaseType CInt
Instance details Defined in Data.IntCast type IntBaseType CInt = IntBaseType Int32
type IntBaseType CIntMax
Instance details Defined in Data.IntCast type IntBaseType CIntMax = IntBaseType Int64
type IntBaseType CIntPtr
Instance details Defined in Data.IntCast type IntBaseType CIntPtr = IntBaseType Int64
type IntBaseType CLLong
Instance details Defined in Data.IntCast type IntBaseType CLLong = IntBaseType Int64
type IntBaseType CLong
Instance details Defined in Data.IntCast type IntBaseType CLong = IntBaseType Int64
type IntBaseType CPtrdiff
Instance details Defined in Data.IntCast type IntBaseType CPtrdiff = IntBaseType Int64
type IntBaseType CSChar
Instance details Defined in Data.IntCast type IntBaseType CSChar = IntBaseType Int8
type IntBaseType CShort
Instance details Defined in Data.IntCast type IntBaseType CShort = IntBaseType Int16
type IntBaseType CSigAtomic
Instance details Defined in Data.IntCast type IntBaseType CSigAtomic = IntBaseType Int32
type IntBaseType CSize
Instance details Defined in Data.IntCast type IntBaseType CSize = IntBaseType Word64
type IntBaseType CUChar
Instance details Defined in Data.IntCast type IntBaseType CUChar = IntBaseType Word8
type IntBaseType CUInt
Instance details Defined in Data.IntCast type IntBaseType CUInt = IntBaseType Word32
type IntBaseType CUIntMax
Instance details Defined in Data.IntCast type IntBaseType CUIntMax = IntBaseType Word64
type IntBaseType CUIntPtr
Instance details Defined in Data.IntCast type IntBaseType CUIntPtr = IntBaseType Word64
type IntBaseType CULLong
Instance details Defined in Data.IntCast type IntBaseType CULLong = IntBaseType Word64
type IntBaseType CULong
Instance details Defined in Data.IntCast type IntBaseType CULong = IntBaseType Word64
type IntBaseType CUShort
Instance details Defined in Data.IntCast type IntBaseType CUShort = IntBaseType Word16
type IntBaseType Int16
Instance details Defined in Data.IntCast type IntBaseType Int16 = 'FixedIntTag 16
type IntBaseType Int32
Instance details Defined in Data.IntCast type IntBaseType Int32 = 'FixedIntTag 32
type IntBaseType Int64
Instance details Defined in Data.IntCast type IntBaseType Int64 = 'FixedIntTag 64
type IntBaseType Int8
Instance details Defined in Data.IntCast type IntBaseType Int8 = 'FixedIntTag 8
type IntBaseType Word16
Instance details Defined in Data.IntCast type IntBaseType Word16 = 'FixedWordTag 16
type IntBaseType Word32
Instance details Defined in Data.IntCast type IntBaseType Word32 = 'FixedWordTag 32
type IntBaseType Word64
Instance details Defined in Data.IntCast type IntBaseType Word64 = 'FixedWordTag 64
type IntBaseType Word8
Instance details Defined in Data.IntCast type IntBaseType Word8 = 'FixedWordTag 8
type IntBaseType Integer
Instance details Defined in Data.IntCast type IntBaseType Integer = 'BigIntTag
type IntBaseType Natural
Instance details Defined in Data.IntCast type IntBaseType Natural = 'BigWordTag
type IntBaseType Int
Instance details Defined in Data.IntCast type IntBaseType Int = 'FixedIntTag 64
type IntBaseType Word
Instance details Defined in Data.IntCast type IntBaseType Word = 'FixedWordTag 64
type IntBaseType (StringEncode a)
Instance details Defined in Morley.Micheline.Json type IntBaseType (StringEncode a) = IntBaseType a

toStrict :: Text -> Text #

O(n) Convert a lazy Text into a strict Text.

data HashSet a #

A set of values. A set cannot contain duplicate values.

Instances

Instances details

Foldable HashSet
Instance details Defined in Data.HashSet.Internal Methods fold :: Monoid m => HashSet m -> m # foldMap :: Monoid m => (a -> m) -> HashSet a -> m # foldMap' :: Monoid m => (a -> m) -> HashSet a -> m # foldr :: (a -> b -> b) -> b -> HashSet a -> b # foldr' :: (a -> b -> b) -> b -> HashSet a -> b # foldl :: (b -> a -> b) -> b -> HashSet a -> b # foldl' :: (b -> a -> b) -> b -> HashSet a -> b # foldr1 :: (a -> a -> a) -> HashSet a -> a # foldl1 :: (a -> a -> a) -> HashSet a -> a # toList :: HashSet a -> [a] # null :: HashSet a -> Bool # length :: HashSet a -> Int # elem :: Eq a => a -> HashSet a -> Bool # maximum :: Ord a => HashSet a -> a # minimum :: Ord a => HashSet a -> a # sum :: Num a => HashSet a -> a # product :: Num a => HashSet a -> a #
Eq1 HashSet
Instance details Defined in Data.HashSet.Internal Methods liftEq :: (a -> b -> Bool) -> HashSet a -> HashSet b -> Bool #
Ord1 HashSet
Instance details Defined in Data.HashSet.Internal Methods liftCompare :: (a -> b -> Ordering) -> HashSet a -> HashSet b -> Ordering #
Show1 HashSet
Instance details Defined in Data.HashSet.Internal Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> HashSet a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [HashSet a] -> ShowS #
NFData1 HashSet	Since: unordered-containers-0.2.14.0
Instance details Defined in Data.HashSet.Internal Methods liftRnf :: (a -> ()) -> HashSet a -> () #
Hashable1 HashSet
Instance details Defined in Data.HashSet.Internal Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> HashSet a -> Int #
Lift a => Lift (HashSet a :: Type)	Since: unordered-containers-0.2.17.0
Instance details Defined in Data.HashSet.Internal Methods lift :: Quote m => HashSet a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => HashSet a -> Code m (HashSet a) #
(Data a, Eq a, Hashable a) => Data (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HashSet a -> c (HashSet a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HashSet a) # toConstr :: HashSet a -> Constr # dataTypeOf :: HashSet a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HashSet a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HashSet a)) # gmapT :: (forall b. Data b => b -> b) -> HashSet a -> HashSet a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HashSet a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HashSet a -> r # gmapQ :: (forall d. Data d => d -> u) -> HashSet a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HashSet a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HashSet a -> m (HashSet a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HashSet a -> m (HashSet a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HashSet a -> m (HashSet a) #
(Hashable a, Eq a) => Monoid (HashSet a)	`mempty` = `empty` `mappend` = `union` O(n+m) To obtain good performance, the smaller set must be presented as the first argument. Examples Expand `>>>` `mappend (fromList [1,2]) (fromList [2,3])`fromList [1,2,3]
Instance details Defined in Data.HashSet.Internal Methods mempty :: HashSet a # mappend :: HashSet a -> HashSet a -> HashSet a # mconcat :: [HashSet a] -> HashSet a #
(Hashable a, Eq a) => Semigroup (HashSet a)	`<>` = `union` O(n+m) To obtain good performance, the smaller set must be presented as the first argument. Examples Expand `>>>` `fromList [1,2] <> fromList [2,3]`fromList [1,2,3]
Instance details Defined in Data.HashSet.Internal Methods (<>) :: HashSet a -> HashSet a -> HashSet a # sconcat :: NonEmpty (HashSet a) -> HashSet a # stimes :: Integral b => b -> HashSet a -> HashSet a #
(Eq a, Hashable a) => IsList (HashSet a)
Instance details Defined in Data.HashSet.Internal Associated Types type Item (HashSet a) # Methods fromList :: [Item (HashSet a)] -> HashSet a # fromListN :: Int -> [Item (HashSet a)] -> HashSet a # toList :: HashSet a -> [Item (HashSet a)] #
(Eq a, Hashable a, Read a) => Read (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods readsPrec :: Int -> ReadS (HashSet a) # readList :: ReadS [HashSet a] # readPrec :: ReadPrec (HashSet a) # readListPrec :: ReadPrec [HashSet a] #
Show a => Show (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods showsPrec :: Int -> HashSet a -> ShowS # show :: HashSet a -> String # showList :: [HashSet a] -> ShowS #
NFData a => NFData (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods rnf :: HashSet a -> () #
Eq a => Eq (HashSet a)	Note that, in the presence of hash collisions, equal `HashSet`s may behave differently, i.e. substitutivity may be violated: `>>>` `data D = A \| B deriving (Eq, Show)``>>>` `instance Hashable D where hashWithSalt salt _d = salt` `>>>` `x = fromList [A, B]``>>>` `y = fromList [B, A]` `>>>` `x == y`True `>>>` `toList x`[A,B] `>>>` `toList y`[B,A] In general, the lack of substitutivity can be observed with any function that depends on the key ordering, such as folds and traversals.
Instance details Defined in Data.HashSet.Internal Methods (==) :: HashSet a -> HashSet a -> Bool # (/=) :: HashSet a -> HashSet a -> Bool #
Ord a => Ord (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods compare :: HashSet a -> HashSet a -> Ordering # (<) :: HashSet a -> HashSet a -> Bool # (<=) :: HashSet a -> HashSet a -> Bool # (>) :: HashSet a -> HashSet a -> Bool # (>=) :: HashSet a -> HashSet a -> Bool # max :: HashSet a -> HashSet a -> HashSet a # min :: HashSet a -> HashSet a -> HashSet a #
Hashable a => Hashable (HashSet a)
Instance details Defined in Data.HashSet.Internal Methods hashWithSalt :: Int -> HashSet a -> Int # hash :: HashSet a -> Int #
(Eq k, Hashable k) => At (HashSet k)
Instance details Defined in Control.Lens.At Methods at :: Index (HashSet k) -> Lens' (HashSet k) (Maybe (IxValue (HashSet k))) #
(Eq a, Hashable a) => Contains (HashSet a)
Instance details Defined in Control.Lens.At Methods contains :: Index (HashSet a) -> Lens' (HashSet a) Bool #
(Eq k, Hashable k) => Ixed (HashSet k)
Instance details Defined in Control.Lens.At Methods ix :: Index (HashSet k) -> Traversal' (HashSet k) (IxValue (HashSet k)) #
(Hashable a, Eq a) => Wrapped (HashSet a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (HashSet a) # Methods _Wrapped' :: Iso' (HashSet a) (Unwrapped (HashSet a)) #
(Eq a, Hashable a, Monoid a) => Semiring (HashSet a)	The multiplication laws are satisfied for any underlying `Monoid`, so we require a `Monoid` constraint instead of a `Semiring` constraint since `times` can use the context of either.
Instance details Defined in Data.Semiring Methods plus :: HashSet a -> HashSet a -> HashSet a # zero :: HashSet a # times :: HashSet a -> HashSet a -> HashSet a # one :: HashSet a # fromNatural :: Natural -> HashSet a #
(Eq v, Hashable v) => Container (HashSet v)
Instance details Defined in Universum.Container.Class Associated Types type Element (HashSet v) # Methods toList :: HashSet v -> [Element (HashSet v)] # null :: HashSet v -> Bool # foldr :: (Element (HashSet v) -> b -> b) -> b -> HashSet v -> b # foldl :: (b -> Element (HashSet v) -> b) -> b -> HashSet v -> b # foldl' :: (b -> Element (HashSet v) -> b) -> b -> HashSet v -> b # length :: HashSet v -> Int # elem :: Element (HashSet v) -> HashSet v -> Bool # foldMap :: Monoid m => (Element (HashSet v) -> m) -> HashSet v -> m # fold :: HashSet v -> Element (HashSet v) # foldr' :: (Element (HashSet v) -> b -> b) -> b -> HashSet v -> b # notElem :: Element (HashSet v) -> HashSet v -> Bool # all :: (Element (HashSet v) -> Bool) -> HashSet v -> Bool # any :: (Element (HashSet v) -> Bool) -> HashSet v -> Bool # and :: HashSet v -> Bool # or :: HashSet v -> Bool # find :: (Element (HashSet v) -> Bool) -> HashSet v -> Maybe (Element (HashSet v)) # safeHead :: HashSet v -> Maybe (Element (HashSet v)) # safeMaximum :: HashSet v -> Maybe (Element (HashSet v)) # safeMinimum :: HashSet v -> Maybe (Element (HashSet v)) # safeFoldr1 :: (Element (HashSet v) -> Element (HashSet v) -> Element (HashSet v)) -> HashSet v -> Maybe (Element (HashSet v)) # safeFoldl1 :: (Element (HashSet v) -> Element (HashSet v) -> Element (HashSet v)) -> HashSet v -> Maybe (Element (HashSet v)) #
Hashable v => One (HashSet v)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (HashSet v) # Methods one :: OneItem (HashSet v) -> HashSet v #
(t ~ HashSet a', Hashable a, Eq a) => Rewrapped (HashSet a) t	Use `wrapping fromList`. Unwrapping returns some permutation of the list.
Instance details Defined in Control.Lens.Wrapped
type Item (HashSet a)
Instance details Defined in Data.HashSet.Internal type Item (HashSet a) = a
type Index (HashSet a)
Instance details Defined in Control.Lens.At type Index (HashSet a) = a
type IxValue (HashSet k)
Instance details Defined in Control.Lens.At type IxValue (HashSet k) = ()
type Unwrapped (HashSet a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (HashSet a) = [a]
type Element (HashSet v)
Instance details Defined in Universum.Container.Class type Element (HashSet v) = ElementDefault (HashSet v)
type OneItem (HashSet v)
Instance details Defined in Universum.Container.Class type OneItem (HashSet v) = v

newtype StateT s (m :: Type -> Type) a #

A state transformer monad parameterized by:

s - The state.
m - The inner monad.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

Constructors

StateT
Fields runStateT :: s -> m (a, s)

Instances

Instances details

MonadError e m => MonadError e (StateT s m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadReader r m => MonadReader r (StateT s m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
Monad m => MonadState s (StateT s m)
Instance details Defined in Control.Monad.State.Class Methods get :: StateT s m s # put :: s -> StateT s m () # state :: (s -> (a, s)) -> StateT s m a #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Strict Methods lift :: Monad m => m a -> StateT s m a #
MonadFail m => MonadFail (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods fail :: String -> StateT s m a #
MonadFix m => MonadFix (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods mfix :: (a -> StateT s m a) -> StateT s m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a #
Contravariant m => Contravariant (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods contramap :: (a' -> a) -> StateT s m a -> StateT s m a' # (>$) :: b -> StateT s m b -> StateT s m a #
(Functor m, MonadPlus m) => Alternative (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods empty :: StateT s m a # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
(Functor m, Monad m) => Applicative (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods pure :: a -> StateT s m a # (<>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c # (>) :: StateT s m a -> StateT s m b -> StateT s m b # (<*) :: StateT s m a -> StateT s m b -> StateT s m a #
Functor m => Functor (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Monad m => Monad (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a #
MonadPlus m => MonadPlus (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
MonadCatch m => MonadCatch (StateT s m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadMask m => MonadMask (StateT s m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c) #
MonadThrow m => MonadThrow (StateT s m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> StateT s m a #
Monad m => InterpreterStateMonad (StateT InterpreterState m)
Instance details Defined in Morley.Michelson.Interpret Methods getInterpreterState :: StateT InterpreterState m InterpreterState # putInterpreterState :: InterpreterState -> StateT InterpreterState m () # stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> StateT InterpreterState m a # modifyInterpreterState :: (InterpreterState -> InterpreterState) -> StateT InterpreterState m () #
InterpreterStateMonad m => InterpreterStateMonad (StateT w m)
Instance details Defined in Morley.Michelson.Interpret Methods getInterpreterState :: StateT w m InterpreterState # putInterpreterState :: InterpreterState -> StateT w m () # stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> StateT w m a # modifyInterpreterState :: (InterpreterState -> InterpreterState) -> StateT w m () #
PrimMonad m => PrimMonad (StateT s m)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState (StateT s m) # Methods primitive :: (State# (PrimState (StateT s m)) -> (# State# (PrimState (StateT s m)), a #)) -> StateT s m a #
Monad z => Zoom (StateT s z) (StateT t z) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (StateT s z) c) t s -> StateT s z c -> StateT t z c #
Monad z => Zoom (StateT s z) (StateT t z) s t
Instance details Defined in Lens.Micro.Mtl.Internal Methods zoom :: LensLike' (Zoomed (StateT s z) c) t s -> StateT s z c -> StateT t z c #
Wrapped (StateT s m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (StateT s m a) # Methods _Wrapped' :: Iso' (StateT s m a) (Unwrapped (StateT s m a)) #
t ~ StateT s' m' a' => Rewrapped (StateT s m a) t
Instance details Defined in Control.Lens.Wrapped
type Zoomed (StateT s z)
Instance details Defined in Control.Lens.Zoom type Zoomed (StateT s z) = Focusing z
type Zoomed (StateT s z)
Instance details Defined in Lens.Micro.Mtl.Internal type Zoomed (StateT s z) = Focusing z
type PrimState (StateT s m)
Instance details Defined in Control.Monad.Primitive type PrimState (StateT s m) = PrimState m
type Unwrapped (StateT s m a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (StateT s m a) = s -> m (a, s)

type State s = StateT s Identity #

A state monad parameterized by the type s of the state to carry.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

data Vector a #

Boxed vectors, supporting efficient slicing.

Instances

Instances details

MonadFail Vector	Since: vector-0.12.1.0
Instance details Defined in Data.Vector Methods fail :: String -> Vector a #
MonadFix Vector	Instance has same semantics as one for lists Since: vector-0.12.2.0
Instance details Defined in Data.Vector Methods mfix :: (a -> Vector a) -> Vector a #
MonadZip Vector
Instance details Defined in Data.Vector Methods mzip :: Vector a -> Vector b -> Vector (a, b) # mzipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c # munzip :: Vector (a, b) -> (Vector a, Vector b) #
Foldable Vector
Instance details Defined in Data.Vector Methods fold :: Monoid m => Vector m -> m # foldMap :: Monoid m => (a -> m) -> Vector a -> m # foldMap' :: Monoid m => (a -> m) -> Vector a -> m # foldr :: (a -> b -> b) -> b -> Vector a -> b # foldr' :: (a -> b -> b) -> b -> Vector a -> b # foldl :: (b -> a -> b) -> b -> Vector a -> b # foldl' :: (b -> a -> b) -> b -> Vector a -> b # foldr1 :: (a -> a -> a) -> Vector a -> a # foldl1 :: (a -> a -> a) -> Vector a -> a # toList :: Vector a -> [a] # null :: Vector a -> Bool # length :: Vector a -> Int # elem :: Eq a => a -> Vector a -> Bool # maximum :: Ord a => Vector a -> a # minimum :: Ord a => Vector a -> a # sum :: Num a => Vector a -> a # product :: Num a => Vector a -> a #
Eq1 Vector
Instance details Defined in Data.Vector Methods liftEq :: (a -> b -> Bool) -> Vector a -> Vector b -> Bool #
Ord1 Vector
Instance details Defined in Data.Vector Methods liftCompare :: (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering #
Read1 Vector
Instance details Defined in Data.Vector Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Vector a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Vector a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Vector a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Vector a] #
Show1 Vector
Instance details Defined in Data.Vector Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Vector a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Vector a] -> ShowS #
Traversable Vector
Instance details Defined in Data.Vector Methods traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b) # sequenceA :: Applicative f => Vector (f a) -> f (Vector a) # mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b) # sequence :: Monad m => Vector (m a) -> m (Vector a) #
Alternative Vector
Instance details Defined in Data.Vector Methods empty :: Vector a # (<\|>) :: Vector a -> Vector a -> Vector a # some :: Vector a -> Vector [a] # many :: Vector a -> Vector [a] #
Applicative Vector
Instance details Defined in Data.Vector Methods pure :: a -> Vector a # (<>) :: Vector (a -> b) -> Vector a -> Vector b # liftA2 :: (a -> b -> c) -> Vector a -> Vector b -> Vector c # (>) :: Vector a -> Vector b -> Vector b # (<*) :: Vector a -> Vector b -> Vector a #
Functor Vector
Instance details Defined in Data.Vector Methods fmap :: (a -> b) -> Vector a -> Vector b # (<$) :: a -> Vector b -> Vector a #
Monad Vector
Instance details Defined in Data.Vector Methods (>>=) :: Vector a -> (a -> Vector b) -> Vector b # (>>) :: Vector a -> Vector b -> Vector b # return :: a -> Vector a #
MonadPlus Vector
Instance details Defined in Data.Vector Methods mzero :: Vector a # mplus :: Vector a -> Vector a -> Vector a #
NFData1 Vector	Since: vector-0.12.1.0
Instance details Defined in Data.Vector Methods liftRnf :: (a -> ()) -> Vector a -> () #
Vector Vector a
Instance details Defined in Data.Vector Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a) # basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a) # basicLength :: Vector a -> Int # basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a # basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m () # elemseq :: Vector a -> a -> b -> b #
Data a => Data (Vector a)
Instance details Defined in Data.Vector Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) # toConstr :: Vector a -> Constr # dataTypeOf :: Vector a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) # gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #
Monoid (Vector a)
Instance details Defined in Data.Vector Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
Semigroup (Vector a)
Instance details Defined in Data.Vector Methods (<>) :: Vector a -> Vector a -> Vector a # sconcat :: NonEmpty (Vector a) -> Vector a # stimes :: Integral b => b -> Vector a -> Vector a #
IsList (Vector a)
Instance details Defined in Data.Vector Associated Types type Item (Vector a) # Methods fromList :: [Item (Vector a)] -> Vector a # fromListN :: Int -> [Item (Vector a)] -> Vector a # toList :: Vector a -> [Item (Vector a)] #
Read a => Read (Vector a)
Instance details Defined in Data.Vector Methods readsPrec :: Int -> ReadS (Vector a) # readList :: ReadS [Vector a] # readPrec :: ReadPrec (Vector a) # readListPrec :: ReadPrec [Vector a] #
Show a => Show (Vector a)
Instance details Defined in Data.Vector Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
NFData a => NFData (Vector a)
Instance details Defined in Data.Vector Methods rnf :: Vector a -> () #
Eq a => Eq (Vector a)
Instance details Defined in Data.Vector Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
Ord a => Ord (Vector a)
Instance details Defined in Data.Vector Methods compare :: Vector a -> Vector a -> Ordering # (<) :: Vector a -> Vector a -> Bool # (<=) :: Vector a -> Vector a -> Bool # (>) :: Vector a -> Vector a -> Bool # (>=) :: Vector a -> Vector a -> Bool # max :: Vector a -> Vector a -> Vector a # min :: Vector a -> Vector a -> Vector a #
Ixed (Vector a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a)) #
Wrapped (Vector a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Vector a) # Methods _Wrapped' :: Iso' (Vector a) (Unwrapped (Vector a)) #
Container (Vector a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Vector a) # Methods toList :: Vector a -> [Element (Vector a)] # null :: Vector a -> Bool # foldr :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b # foldl :: (b -> Element (Vector a) -> b) -> b -> Vector a -> b # foldl' :: (b -> Element (Vector a) -> b) -> b -> Vector a -> b # length :: Vector a -> Int # elem :: Element (Vector a) -> Vector a -> Bool # foldMap :: Monoid m => (Element (Vector a) -> m) -> Vector a -> m # fold :: Vector a -> Element (Vector a) # foldr' :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b # notElem :: Element (Vector a) -> Vector a -> Bool # all :: (Element (Vector a) -> Bool) -> Vector a -> Bool # any :: (Element (Vector a) -> Bool) -> Vector a -> Bool # and :: Vector a -> Bool # or :: Vector a -> Bool # find :: (Element (Vector a) -> Bool) -> Vector a -> Maybe (Element (Vector a)) # safeHead :: Vector a -> Maybe (Element (Vector a)) # safeMaximum :: Vector a -> Maybe (Element (Vector a)) # safeMinimum :: Vector a -> Maybe (Element (Vector a)) # safeFoldr1 :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Maybe (Element (Vector a)) # safeFoldl1 :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Maybe (Element (Vector a)) #
FromList (Vector a)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (Vector a) # type FromListC (Vector a) # Methods fromList :: [ListElement (Vector a)] -> Vector a #
One (Vector a)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Vector a) # Methods one :: OneItem (Vector a) -> Vector a #
t ~ Vector a' => Rewrapped (Vector a) t
Instance details Defined in Control.Lens.Wrapped
type Mutable Vector
Instance details Defined in Data.Vector type Mutable Vector = MVector
type Item (Vector a)
Instance details Defined in Data.Vector type Item (Vector a) = a
type Index (Vector a)
Instance details Defined in Control.Lens.At type Index (Vector a) = Int
type IxValue (Vector a)
Instance details Defined in Control.Lens.At type IxValue (Vector a) = a
type Unwrapped (Vector a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (Vector a) = [a]
type Element (Vector a)
Instance details Defined in Universum.Container.Class type Element (Vector a) = ElementDefault (Vector a)
type FromListC (Vector a)
Instance details Defined in Universum.Container.Class type FromListC (Vector a) = ()
type ListElement (Vector a)
Instance details Defined in Universum.Container.Class type ListElement (Vector a) = Item (Vector a)
type OneItem (Vector a)
Instance details Defined in Universum.Container.Class type OneItem (Vector a) = a

type Reader r = ReaderT r Identity #

The parameterizable reader monad.

Computations are functions of a shared environment.

The return function ignores the environment, while >>= passes the inherited environment to both subcomputations.

gets :: MonadState s m => (s -> a) -> m a #

Gets specific component of the state, using a projection function supplied.

preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a) #

Retrieve the first value targeted by a Fold or Traversal (or Just the result from a Getter or Lens) into the current state.

preuse = use . pre

preuse :: MonadState s m => Getter s a     -> m (Maybe a)
preuse :: MonadState s m => Fold s a       -> m (Maybe a)
preuse :: MonadState s m => Lens' s a      -> m (Maybe a)
preuse :: MonadState s m => Iso' s a       -> m (Maybe a)
preuse :: MonadState s m => Traversal' s a -> m (Maybe a)

preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a) #

Retrieve the first value targeted by a Fold or Traversal (or Just the result from a Getter or Lens). See also firstOf and ^?, which are similar with some subtle differences (explained below).

listToMaybe . toList ≡ preview folded

preview = view . pre

Unlike ^?, this function uses a MonadReader to read the value to be focused in on. This allows one to pass the value as the last argument by using the MonadReader instance for (->) s However, it may also be used as part of some deeply nested transformer stack.

preview uses a monoidal value to obtain the result. This means that it generally has good performance, but can occasionally cause space leaks or even stack overflows on some data types. There is another function, firstOf, which avoids these issues at the cost of a slight constant performance cost and a little less flexibility.

It may be helpful to think of preview as having one of the following more specialized types:

preview :: Getter s a     -> s -> Maybe a
preview :: Fold s a       -> s -> Maybe a
preview :: Lens' s a      -> s -> Maybe a
preview :: Iso' s a       -> s -> Maybe a
preview :: Traversal' s a -> s -> Maybe a

preview :: MonadReader s m => Getter s a     -> m (Maybe a)
preview :: MonadReader s m => Fold s a       -> m (Maybe a)
preview :: MonadReader s m => Lens' s a      -> m (Maybe a)
preview :: MonadReader s m => Iso' s a       -> m (Maybe a)
preview :: MonadReader s m => Traversal' s a -> m (Maybe a)

(^..) :: s -> Getting (Endo [a]) s a -> [a] infixl 8 #

A convenient infix (flipped) version of toListOf.

>>> [[1,2],[3]]^..id
[[[1,2],[3]]]
>>> [[1,2],[3]]^..traverse
[[1,2],[3]]
>>> [[1,2],[3]]^..traverse.traverse
[1,2,3]

>>> (1,2)^..both
[1,2]

toList xs ≡ xs ^.. folded
(^..) ≡ flip toListOf

(^..) :: s -> Getter s a     -> a :: s -> Fold s a       -> a :: s -> Lens' s a      -> a :: s -> Iso' s a       -> a :: s -> Traversal' s a -> a :: s -> Prism' s a     -> [a]

use :: MonadState s m => Getting a s a -> m a #

Use the target of a Lens, Iso, or Getter in the current state, or use a summary of a Fold or Traversal that points to a monoidal value.

>>> evalState (use _1) (a,b)
a

>>> evalState (use _1) ("hello","world")
"hello"

use :: MonadState s m             => Getter s a     -> m a
use :: (MonadState s m, Monoid r) => Fold s r       -> m r
use :: MonadState s m             => Iso' s a       -> m a
use :: MonadState s m             => Lens' s a      -> m a
use :: (MonadState s m, Monoid r) => Traversal' s r -> m r

view :: MonadReader s m => Getting a s a -> m a #

View the value pointed to by a Getter, Iso or Lens or the result of folding over all the results of a Fold or Traversal that points at a monoidal value.

view . to ≡ id

>>> view (to f) a
f a

>>> view _2 (1,"hello")
"hello"

>>> view (to succ) 5
6

>>> view (_2._1) ("hello",("world","!!!"))
"world"

As view is commonly used to access the target of a Getter or obtain a monoidal summary of the targets of a Fold, It may be useful to think of it as having one of these more restricted signatures:

view ::             Getter s a     -> s -> a
view :: Monoid m => Fold s m       -> s -> m
view ::             Iso' s a       -> s -> a
view ::             Lens' s a      -> s -> a
view :: Monoid m => Traversal' s m -> s -> m

In a more general setting, such as when working with a Monad transformer stack you can use:

view :: MonadReader s m             => Getter s a     -> m a
view :: (MonadReader s m, Monoid a) => Fold s a       -> m a
view :: MonadReader s m             => Iso' s a       -> m a
view :: MonadReader s m             => Lens' s a      -> m a
view :: (MonadReader s m, Monoid a) => Traversal' s a -> m a

_1 :: Field1 s t a b => Lens s t a b #

Access the 1st field of a tuple (and possibly change its type).

>>> (1,2)^._1
1

>>> _1 .~ "hello" $ (1,2)
("hello",2)

>>> (1,2) & _1 .~ "hello"
("hello",2)

>>> _1 putStrLn ("hello","world")
hello
((),"world")

This can also be used on larger tuples as well:

>>> (1,2,3,4,5) & _1 +~ 41
(42,2,3,4,5)

_1 :: Lens (a,b) (a',b) a a'
_1 :: Lens (a,b,c) (a',b,c) a a'
_1 :: Lens (a,b,c,d) (a',b,c,d) a a'
...
_1 :: Lens (a,b,c,d,e,f,g,h,i) (a',b,c,d,e,f,g,h,i) a a'

_2 :: Field2 s t a b => Lens s t a b #

Access the 2nd field of a tuple.

>>> _2 .~ "hello" $ (1,(),3,4)
(1,"hello",3,4)

>>> (1,2,3,4) & _2 *~ 3
(1,6,3,4)

>>> _2 print (1,2)
2
(1,())

anyOf _2 :: (s -> Bool) -> (a, s) -> Bool
traverse . _2 :: (Applicative f, Traversable t) => (a -> f b) -> t (s, a) -> f (t (s, b))
foldMapOf (traverse . _2) :: (Traversable t, Monoid m) => (s -> m) -> t (b, s) -> m

_3 :: Field3 s t a b => Lens s t a b #

Access the 3rd field of a tuple.

_4 :: Field4 s t a b => Lens s t a b #

Access the 4th field of a tuple.

_5 :: Field5 s t a b => Lens s t a b #

Access the 5th field of a tuple.

(.~) :: ASetter s t a b -> b -> s -> t infixr 4 #

Replace the target of a Lens or all of the targets of a Setter or Traversal with a constant value.

This is an infix version of set, provided for consistency with (.=).

f <$ a ≡ mapped .~ f $ a

>>> (a,b,c,d) & _4 .~ e
(a,b,c,e)

>>> (42,"world") & _1 .~ "hello"
("hello","world")

>>> (a,b) & both .~ c
(c,c)

(.~) :: Setter s t a b    -> b -> s -> t
(.~) :: Iso s t a b       -> b -> s -> t
(.~) :: Lens s t a b      -> b -> s -> t
(.~) :: Traversal s t a b -> b -> s -> t

set :: ASetter s t a b -> b -> s -> t #

Replace the target of a Lens or all of the targets of a Setter or Traversal with a constant value.

(<$) ≡ set mapped

>>> set _2 "hello" (1,())
(1,"hello")

>>> set mapped () [1,2,3,4]
[(),(),(),()]

Note: Attempting to set a Fold or Getter will fail at compile time with an relatively nice error message.

set :: Setter s t a b    -> b -> s -> t
set :: Iso s t a b       -> b -> s -> t
set :: Lens s t a b      -> b -> s -> t
set :: Traversal s t a b -> b -> s -> t

over :: ASetter s t a b -> (a -> b) -> s -> t #

Modify the target of a Lens or all the targets of a Setter or Traversal with a function.

fmap ≡ over mapped
fmapDefault ≡ over traverse
sets . over ≡ id
over . sets ≡ id

Given any valid Setter l, you can also rely on the law:

over l f . over l g = over l (f . g)

e.g.

>>> over mapped f (over mapped g [a,b,c]) == over mapped (f . g) [a,b,c]
True

Another way to view over is to say that it transforms a Setter into a "semantic editor combinator".

>>> over mapped f (Just a)
Just (f a)

>>> over mapped (*10) [1,2,3]
[10,20,30]

>>> over _1 f (a,b)
(f a,b)

>>> over _1 show (10,20)
("10",20)

over :: Setter s t a b -> (a -> b) -> s -> t
over :: ASetter s t a b -> (a -> b) -> s -> t

type Lens s t a b = forall (f :: Type -> Type). Functor f => (a -> f b) -> s -> f t #

A Lens is actually a lens family as described in http://comonad.com/reader/2012/mirrored-lenses/.

With great power comes great responsibility and a Lens is subject to the three common sense Lens laws:

1) You get back what you put in:

view l (set l v s)  ≡ v

2) Putting back what you got doesn't change anything:

set l (view l s) s  ≡ s

3) Setting twice is the same as setting once:

set l v' (set l v s) ≡ set l v' s

These laws are strong enough that the 4 type parameters of a Lens cannot vary fully independently. For more on how they interact, read the "Why is it a Lens Family?" section of http://comonad.com/reader/2012/mirrored-lenses/.

There are some emergent properties of these laws:

1) set l s must be injective for every s This is a consequence of law #1

2) set l must be surjective, because of law #2, which indicates that it is possible to obtain any v from some s such that set s v = s

3) Given just the first two laws you can prove a weaker form of law #3 where the values v that you are setting match:

set l v (set l v s) ≡ set l v s

Every Lens can be used directly as a Setter or Traversal.

You can also use a Lens for Getting as if it were a Fold or Getter.

Since every Lens is a valid Traversal, the Traversal laws are required of any Lens you create:

l pure ≡ pure
fmap (l f) . l g ≡ getCompose . l (Compose . fmap f . g)

type Lens s t a b = forall f. Functor f => LensLike f s t a b

type Lens' s a = Lens s s a a #

type Lens' = Simple Lens

type Traversal s t a b = forall (f :: Type -> Type). Applicative f => (a -> f b) -> s -> f t #

A Traversal can be used directly as a Setter or a Fold (but not as a Lens) and provides the ability to both read and update multiple fields, subject to some relatively weak Traversal laws.

These have also been known as multilenses, but they have the signature and spirit of

traverse :: Traversable f => Traversal (f a) (f b) a b

and the more evocative name suggests their application.

Most of the time the Traversal you will want to use is just traverse, but you can also pass any Lens or Iso as a Traversal, and composition of a Traversal (or Lens or Iso) with a Traversal (or Lens or Iso) using (.) forms a valid Traversal.

The laws for a Traversal t follow from the laws for Traversable as stated in "The Essence of the Iterator Pattern".

t pure ≡ pure
fmap (t f) . t g ≡ getCompose . t (Compose . fmap f . g)

One consequence of this requirement is that a Traversal needs to leave the same number of elements as a candidate for subsequent Traversal that it started with. Another testament to the strength of these laws is that the caveat expressed in section 5.5 of the "Essence of the Iterator Pattern" about exotic Traversable instances that traverse the same entry multiple times was actually already ruled out by the second law in that same paper!

type Traversal' s a = Traversal s s a a #

type Traversal' = Simple Traversal

printLorentzContract :: Bool -> Contract cp st vd -> LText #

Pretty-print a Lorentz contract into Michelson code.

printLorentzValue :: NiceUntypedValue v => Bool -> v -> LText #

Pretty-print a Haskell value as Michelson one.

cdCompilationOptionsL :: Lens' (ContractData cp st vd) CompilationOptions #

cdCodeL :: forall cp st vd cp1. NiceParameterFull cp1 => Lens (ContractData cp st vd) (ContractData cp1 st vd) (ContractCode cp st) (ContractCode cp1 st) #

coStringTransformerL :: Lens' CompilationOptions (Bool, MText -> MText) #

coOptimizerConfL :: Lens' CompilationOptions (Maybe OptimizerConf) #

coBytesTransformerL :: Lens' CompilationOptions (Bool, ByteString -> ByteString) #

analyzeLorentz :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> AnalyzerRes #

Lorentz version of analyzer.

interpretLorentzLambda :: (IsoValue inp, IsoValue out) => ContractEnv -> (IsNotInView => Fn inp out) -> inp -> Either (MichelsonFailureWithStack Void) out #

Like interpretLorentzInstr, but works on singleton input and output stacks.

interpretLorentzInstr :: forall (inp :: [Type]) (out :: [Type]). (IsoValuesStack inp, IsoValuesStack out) => ContractEnv -> (IsNotInView => inp :-> out) -> Rec Identity inp -> Either (MichelsonFailureWithStack Void) (Rec Identity out) #

Interpret a Lorentz instruction, for test purposes. Note that this does not run the optimizer.

noViews :: forall {k1} {k2} contract (cp :: k1) (st :: k2). contract cp st () -> contract cp st () #

Restrict type of Contract, ContractData or other similar type to have no views.

setViewsRec :: forall vd cp st. NiceViewsDescriptor vd => Rec (ContractView st) (RevealViews vd) -> ContractData cp st () -> ContractData cp st vd #

Version of setViews that accepts a Rec.

May be useful if you have too many views or want to combine views sets.

setViews :: forall vd cp st. (RecFromTuple (Rec (ContractView st) (RevealViews vd)), NiceViewsDescriptor vd) => IsoRecTuple (Rec (ContractView st) (RevealViews vd)) -> ContractData cp st () -> ContractData cp st vd #

Set all the contract's views.

compileLorentzContract $
  defaultContractData do
    ...
  & setViews
    ( mkView "myView" () do
        ...
    , mkView "anotherView" Integer do
        ...
    )

compileLorentzContract :: ContractData cp st vd -> Contract cp st vd #

Compile a whole contract to Michelson.

Note that compiled contract can be ill-typed in terms of Michelson code when some of the compilation options are used. However, compilation with defaultCompilationOptions should be valid.

defaultContractData :: (NiceParameterFull cp, NiceStorageFull st) => (IsNotInView => '[(cp, st)] :-> ContractOut st) -> ContractData cp st () #

Compile contract with defaultCompilationOptions.

mkView :: forall (name :: Symbol) arg ret st. (KnownSymbol name, NiceViewable arg, NiceViewable ret, HasAnnotation arg, HasAnnotation ret, TypeHasDoc arg, TypeHasDoc ret) => ViewCode arg st ret -> ContractView st ('ViewTyInfo name arg ret) #

Construct a view.

mkView @"add" @(Integer, Integer) do
 car; unpair; add

mkContractWith :: (NiceParameterFull cp, NiceStorageFull st) => CompilationOptions -> ContractCode cp st -> Contract cp st () #

Version of mkContract that accepts custom compilation options.

mkContract :: (NiceParameterFull cp, NiceStorageFull st) => ContractCode cp st -> Contract cp st () #

Construct and compile Lorentz contract.

Note that this accepts code with initial and final stacks unpaired for simplicity.

defaultContract :: (NiceParameterFull cp, NiceStorageFull st) => (IsNotInView => '[(cp, st)] :-> ContractOut st) -> Contract cp st () #

Construct and compile Lorentz contract.

This is an alias for mkContract.

compileLorentzWithOptions :: forall (inp :: [Type]) (out :: [Type]). CompilationOptions -> (inp :-> out) -> Instr (ToTs inp) (ToTs out) #

Compile Lorentz code, optionally running the optimizer, string and byte transformers.

compileLorentz :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> Instr (ToTs inp) (ToTs out) #

For use outside of Lorentz. Will use defaultCompilationOptions.

intactCompilationOptions :: CompilationOptions #

Leave contract without any modifications. For testing purposes.

defaultCompilationOptions :: CompilationOptions #

Runs Michelson optimizer with default config and does not touch strings and bytes.

data CompilationOptions #

Options to control Lorentz to Michelson compilation.

Constructors

CompilationOptions
Fields coOptimizerConf :: Maybe OptimizerConf Config for Michelson optimizer. coStringTransformer :: (Bool, MText -> MText) Function to transform strings with. See `transformStringsLorentz`. coBytesTransformer :: (Bool, ByteString -> ByteString) Function to transform byte strings with. See `transformBytesLorentz`.

data ContractData cp st vd #

Code for a contract along with compilation options for the Lorentz compiler.

It is expected that a Contract is one packaged entity, wholly controlled by its author. Therefore the author should be able to set all options that control contract's behavior.

This helps ensure that a given contract will be interpreted in the same way in all environments, like production and testing.

Raw ContractCode should not be used for distribution of contracts.

Constructors

(NiceParameterFull cp, NiceStorageFull st, NiceViewsDescriptor vd) => ContractData
Fields cdCode :: ContractCode cp st The contract itself. cdViews :: Rec (ContractView st) (RevealViews vd) Contract views. cdCompilationOptions :: CompilationOptions General compilation options for the Lorentz compiler.

Instances

Instances details

ContainsDoc (ContractData cp st vd)
Instance details Defined in Lorentz.Run Methods buildDocUnfinalized :: ContractData cp st vd -> ContractDoc #
ContainsUpdateableDoc (ContractData cp st vd)
Instance details Defined in Lorentz.Run Methods modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> ContractData cp st vd -> ContractData cp st vd #

data ContractView st (v :: ViewTyInfo) where #

Single contract view.

Constructors

ContractView :: forall (name :: Symbol) arg ret st. (KnownSymbol name, NiceViewable arg, NiceViewable ret, HasAnnotation arg, HasAnnotation ret) => ViewCode arg st ret -> ContractView st ('ViewTyInfo name arg ret)

pbsUParam :: forall (ctorName :: Symbol). KnownSymbol ctorName => ParamBuildingStep #

Note that calling given entrypoints involves constructing UParam.

uparamFromAdt :: UParamLinearize up => up -> UParam (UParamLinearized up) #

Make up UParam from ADT sum.

Entry points template will consist of (constructorName, constructorFieldType) pairs. Each constructor is expected to have exactly one field.

caseUParamT :: forall (entries :: [EntrypointKind]) (inp :: [Type]) (out :: [Type]) clauses. (clauses ~ Rec (CaseClauseU inp out) entries, RecFromTuple clauses, CaseUParam entries) => IsoRecTuple clauses -> UParamFallback inp out -> (UParam entries ': inp) :-> out #

Like caseUParam, but accepts a tuple of clauses, not a Rec.

caseUParam :: forall (entries :: [EntrypointKind]) (inp :: [Type]) (out :: [Type]). (CaseUParam entries, RequireUniqueEntrypoints entries) => Rec (CaseClauseU inp out) entries -> UParamFallback inp out -> (UParam entries ': inp) :-> out #

Pattern-match on given UParam entries.

You have to provide all case branches and a fallback action on case when entrypoint is not found.

uparamFallbackFail :: forall (inp :: [Type]) (out :: [Type]). UParamFallback inp out #

Default implementation for UParamFallback, simply reports an error.

unwrapUParam :: forall (entries :: [EntrypointKind]) (s :: [Type]). (UParam entries ': s) :-> ((MText, ByteString) ': s) #

Helper instruction which extracts content of UParam.

mkUParam :: forall a (name :: Symbol) (entries :: [EntrypointKind]). (NicePackedValue a, LookupEntrypoint name entries ~ a, RequireUniqueEntrypoints entries) => Label name -> a -> UParam entries #

Construct a UParam safely.

type EntrypointKind = (Symbol, Type) #

An entrypoint is described by two types: its name and type of argument.

type (?:) (n :: Symbol) (a :: k) = '(n, a) #

A convenient alias for type-level name-something pair.

newtype UParam (entries :: [EntrypointKind]) #

Encapsulates parameter for one of entry points. It keeps entrypoint name and corresponding argument serialized.

In Haskell world, we keep an invariant of that contained value relates to one of entry points from entries list.

Constructors

UnsafeUParam (MText, ByteString)

Instances

Instances details

Generic (UParam entries)
Instance details Defined in Lorentz.UParam Associated Types type Rep (UParam entries) :: Type -> Type # Methods from :: UParam entries -> Rep (UParam entries) x # to :: Rep (UParam entries) x -> UParam entries #
Show (UParam entries)
Instance details Defined in Lorentz.UParam Methods showsPrec :: Int -> UParam entries -> ShowS # show :: UParam entries -> String # showList :: [UParam entries] -> ShowS #
Eq (UParam entries)
Instance details Defined in Lorentz.UParam Methods (==) :: UParam entries -> UParam entries -> Bool # (/=) :: UParam entries -> UParam entries -> Bool #
HasAnnotation (UParam entries)
Instance details Defined in Lorentz.UParam Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (UParam entries)) # annOptions :: Maybe AnnOptions #
Unwrappable (UParam entries)
Instance details Defined in Lorentz.UParam Associated Types type Unwrappabled (UParam entries) #
HasRPCRepr (UParam entries)
Instance details Defined in Lorentz.UParam Associated Types type AsRPC (UParam entries) #
Typeable interface => TypeHasDoc (UParam interface)
Instance details Defined in Lorentz.UParam Associated Types type TypeDocFieldDescriptions (UParam interface) :: FieldDescriptions # Methods typeDocName :: Proxy (UParam interface) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (UParam interface) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (UParam interface) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (UParam interface) # typeDocMichelsonRep :: TypeDocMichelsonRep (UParam interface) #
IsoValue (UParam entries)
Instance details Defined in Lorentz.UParam Associated Types type ToT (UParam entries) :: T # Methods toVal :: UParam entries -> Value (ToT (UParam entries)) # fromVal :: Value (ToT (UParam entries)) -> UParam entries #
SameEntries entries1 entries2 => CanCastTo (UParam entries1 :: Type) (UParam entries2 :: Type)	Allows casts only between `UParam_` and `UParam`.
Instance details Defined in Lorentz.UParam Methods castDummy :: Proxy (UParam entries1) -> Proxy (UParam entries2) -> () #
type Rep (UParam entries)
Instance details Defined in Lorentz.UParam type Rep (UParam entries) = D1 ('MetaData "UParam" "Lorentz.UParam" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'True) (C1 ('MetaCons "UnsafeUParam" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (MText, ByteString))))
type Unwrappabled (UParam entries)
Instance details Defined in Lorentz.UParam type Unwrappabled (UParam entries) = GUnwrappabled (UParam entries) (Rep (UParam entries))
type AsRPC (UParam entries)
Instance details Defined in Lorentz.UParam type AsRPC (UParam entries) = UParam entries
type TypeDocFieldDescriptions (UParam interface)
Instance details Defined in Lorentz.UParam type TypeDocFieldDescriptions (UParam interface) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (UParam entries)
Instance details Defined in Lorentz.UParam type ToT (UParam entries) = GValueType (Rep (UParam entries))

type SomeInterface = '['("SomeEntrypoints", Void)] #

Pseudo value for UParam type variable.

type UParam_ = UParam SomeInterface #

Homomorphic version of UParam, forgets the exact interface.

type family LookupEntrypoint (name :: Symbol) (entries :: [EntrypointKind]) where ... #

Get type of entrypoint argument by its name.

Equations

LookupEntrypoint name ('(name, a) ': _1) = a
LookupEntrypoint name (_1 ': entries) = LookupEntrypoint name entries
LookupEntrypoint name ('[] :: [EntrypointKind]) = TypeError (('Text "Entry point " :<>: 'ShowType name) :<>: 'Text " in not in the entry points list") :: Type

type family RequireUniqueEntrypoints (entries :: [EntrypointKind]) where ... #

Ensure that given entry points do no contain duplicated names.

Equations

RequireUniqueEntrypoints entries = RequireAllUnique "entrypoint" (Eval (Map (Fst :: (Symbol, Type) -> Symbol -> Type) entries))

data ConstrainedSome (c :: Type -> Constraint) where #

This type can store any value that satisfies a certain constraint.

Constructors

ConstrainedSome :: forall (c :: Type -> Constraint) a. c a => a -> ConstrainedSome c

Instances

Instances details

Show (ConstrainedSome Show)
Instance details Defined in Lorentz.UParam Methods showsPrec :: Int -> ConstrainedSome Show -> ShowS # show :: ConstrainedSome Show -> String # showList :: [ConstrainedSome Show] -> ShowS #
Buildable (ConstrainedSome Buildable)
Instance details Defined in Lorentz.UParam Methods build :: ConstrainedSome Buildable -> Builder #

class UnpackUParam (c :: Type -> Constraint) (entries :: [EntrypointKind]) where #

This class is needed to implement unpackUParam.

Methods

unpackUParam :: UParam entries -> Either EntrypointLookupError (MText, ConstrainedSome c) #

Turn UParam into a Haskell value. Since we don't know its type in compile time, we have to erase it using ConstrainedSome. The user of this function can require arbitrary constraint to hold (depending on how they want to use the result).

Instances

Instances details

UnpackUParam c ('[] :: [EntrypointKind])
Instance details Defined in Lorentz.UParam Methods unpackUParam :: UParam '[] -> Either EntrypointLookupError (MText, ConstrainedSome c) #
(KnownSymbol name, UnpackUParam c entries, NiceUnpackedValue arg, c arg) => UnpackUParam c ((name ?: arg) ': entries)
Instance details Defined in Lorentz.UParam Methods unpackUParam :: UParam ((name ?: arg) ': entries) -> Either EntrypointLookupError (MText, ConstrainedSome c) #

data EntrypointLookupError #

Constructors

NoSuchEntrypoint MText
ArgumentUnpackFailed

Instances

Instances details

Generic EntrypointLookupError
Instance details Defined in Lorentz.UParam Associated Types type Rep EntrypointLookupError :: Type -> Type # Methods from :: EntrypointLookupError -> Rep EntrypointLookupError x # to :: Rep EntrypointLookupError x -> EntrypointLookupError #
Show EntrypointLookupError
Instance details Defined in Lorentz.UParam Methods showsPrec :: Int -> EntrypointLookupError -> ShowS # show :: EntrypointLookupError -> String # showList :: [EntrypointLookupError] -> ShowS #
Buildable EntrypointLookupError
Instance details Defined in Lorentz.UParam Methods build :: EntrypointLookupError -> Builder #
Eq EntrypointLookupError
Instance details Defined in Lorentz.UParam Methods (==) :: EntrypointLookupError -> EntrypointLookupError -> Bool # (/=) :: EntrypointLookupError -> EntrypointLookupError -> Bool #
type Rep EntrypointLookupError
Instance details Defined in Lorentz.UParam type Rep EntrypointLookupError = D1 ('MetaData "EntrypointLookupError" "Lorentz.UParam" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'False) (C1 ('MetaCons "NoSuchEntrypoint" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 MText)) :+: C1 ('MetaCons "ArgumentUnpackFailed" 'PrefixI 'False) (U1 :: Type -> Type))

type EntrypointsImpl (inp :: [Type]) (out :: [Type]) (entries :: [EntrypointKind]) = Rec (CaseClauseU inp out) entries #

Implementations of some entry points.

Note that this thing inherits properties of Rec, e.g. you can Data.Vinyl.Core.rappend implementations for two entrypoint sets when assembling scattered parts of a contract.

type UParamFallback (inp :: [Type]) (out :: [Type]) = ((MText, ByteString) ': inp) :-> out #

An action invoked when user-provided entrypoint is not found.

class CaseUParam (entries :: [EntrypointKind]) #

Make up a "case" over entry points.

Minimal complete definition

unsafeCaseUParam

Instances

Instances details

CaseUParam ('[] :: [EntrypointKind])
Instance details Defined in Lorentz.UParam Methods unsafeCaseUParam :: forall (inp :: [Type]) (out :: [Type]). Rec (CaseClauseU inp out) '[] -> UParamFallback inp out -> (UParam '[] ': inp) :-> out
(KnownSymbol name, CaseUParam entries, Typeable entries, NiceUnpackedValue arg) => CaseUParam ((name ?: arg) ': entries)
Instance details Defined in Lorentz.UParam Methods unsafeCaseUParam :: forall (inp :: [Type]) (out :: [Type]). Rec (CaseClauseU inp out) ((name ?: arg) ': entries) -> UParamFallback inp out -> (UParam ((name ?: arg) ': entries) ': inp) :-> out

type UParamLinearize p = (Generic p, GUParamLinearize (Rep p)) #

Constraint required by uparamFromAdt.

type UParamLinearized p = GUParamLinearized (Rep p) #

Entry points template derived from given ADT sum.

entryCaseFlattenedHiding :: forall (heps :: [Symbol]) cp (out :: [Type]) (inp :: [Type]) clauses. (CaseTC cp out inp clauses, DocumentEntrypoints (FlattenedEntrypointsKindHiding heps) cp, HasEntrypoints (ParameterEntrypointsDerivation cp) cp heps) => IsoRecTuple clauses -> (cp ': inp) :-> out #

Version of entryCase for contracts with recursive delegate parameter that needs to be flattened. Use it with EpdDelegate when you don't need hierarchical entrypoints in autodoc. You can also hide particular entrypoints with the first type parameter. Consider using entryCaseFlattened if you don't want to hide any entrypoints.

 entryCaseFlattenedHiding @'[Ep1, Ep2] ...

entryCaseFlattenedHiding_ :: forall (heps :: [Symbol]) cp (out :: [Type]) (inp :: [Type]). (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints (FlattenedEntrypointsKindHiding heps) cp, HasEntrypoints (ParameterEntrypointsDerivation cp) cp heps) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp ': inp) :-> out #

Version of entryCase_ for contracts with recursive delegate parameter that needs to be flattened. Use it with EpdDelegate when you don't need hierarchical entrypoints in autodoc. You can also hide particular entrypoints with the type parameter. Consider using entryCaseFlattened_ if you don't want to hide any entrypoints.

entryCaseFlattened :: forall cp (out :: [Type]) (inp :: [Type]) clauses. (CaseTC cp out inp clauses, DocumentEntrypoints FlattenedEntrypointsKind cp) => IsoRecTuple clauses -> (cp ': inp) :-> out #

Version of entryCase for contracts with recursive parameter that needs to be flattened. Use it with EpdRecursive when you don't need intermediary nodes in autodoc.

entryCaseFlattened_ :: forall cp (out :: [Type]) (inp :: [Type]). (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints FlattenedEntrypointsKind cp) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp ': inp) :-> out #

Version of entryCase_ for contracts with recursive parameter that needs to be flattened. Use it with EpdRecursive when you don't need intermediary nodes in autodoc.

entryCaseSimple_ :: forall cp (out :: [Type]) (inp :: [Type]). (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints PlainEntrypointsKind cp, RequireFlatParamEps cp) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp ': inp) :-> out #

Version of entryCase_ for contracts with flat parameter.

areFinalizedParamBuildingSteps :: [ParamBuildingStep] -> Bool #

Whether finalizeParamCallingDoc has already been applied to these steps.

finalizeParamCallingDoc' :: forall cp (inp :: [Type]) (out :: [Type]). (NiceParameterFull cp, HasCallStack) => Proxy cp -> (inp :-> out) -> inp :-> out #

Modify param building steps with respect to entrypoints that given parameter declares.

Each contract with entrypoints should eventually call this function, otherwise, in case if contract uses built-in entrypoints feature, the resulting parameter building steps in the generated documentation will not consider entrypoints and thus may be incorrect.

Calling this twice over the same code is also prohibited.

This method is for internal use, if you want to apply it to a contract manually, use finalizeParamCallingDoc.

documentEntrypoint :: forall kind (epName :: Symbol) param (s :: [Type]) (out :: [Type]). (KnownSymbol epName, DocItem (DEntrypoint kind), NiceParameter param, TypeHasDoc param) => ((param ': s) :-> out) -> (param ': s) :-> out #

Wrapper for documenting single entrypoint which parameter isn't going to be unwrapped from some datatype.

entryCase unwraps a datatype, however, sometimes we want to have entrypoint parameter to be not wrapped into some datatype.

clarifyParamBuildingSteps :: forall (inp :: [Type]) (out :: [Type]). ParamBuildingStep -> (inp :-> out) -> inp :-> out #

Go over contract code and update every occurrence of DEntrypointArg documentation item, adding the given step to its "how to build parameter" description.

mkDEntrypointArgSimple :: (NiceParameter t, TypeHasDoc t) => DEntrypointArg #

mkDEpUType :: HasAnnotation t => Ty #

emptyDEpArg :: DEntrypointArg #

mkPbsWrapIn :: Text -> ParamBuilder -> ParamBuildingStep #

Make a ParamBuildingStep that tells about wrapping an argument into a constructor with given name and uses given ParamBuilder as description of Michelson part.

entrypointSection :: forall kind (i :: [Type]) (o :: [Type]). EntrypointKindHasDoc kind => Text -> Proxy kind -> (i :-> o) -> i :-> o #

Mark code as part of entrypoint with given name.

This is automatically called at most of the appropriate situations, like entryCase calls.

diEntrypointToMarkdown :: HeaderLevel -> DEntrypoint level -> Markdown #

Default implementation of docItemToMarkdown for entrypoints.

pattern DEntrypointDocItem :: () => DEntrypoint kind -> SomeDocItem #

Pattern that checks whether given SomeDocItem hides DEntrypoint inside (of any entrypoint kind).

In case a specific kind is necessary, use plain (cast -> Just DEntrypoint{..}) construction instead.

data DEntrypoint kind #

Gathers information about single entrypoint.

We assume that entry points might be of different kinds, which is designated by phantom type parameter. For instance, you may want to have several groups of entry points corresponding to various parts of a contract - specifying different kind type argument for each of those groups will allow you defining different DocItem instances with appropriate custom descriptions for them.

Constructors

DEntrypoint
Fields depName :: Text depSub :: SubDoc

Instances

Instances details

EntrypointKindHasDoc ep => DocItem (DEntrypoint ep)
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type DocItemPlacement (DEntrypoint ep) :: DocItemPlacementKind # type DocItemReferenced (DEntrypoint ep) :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DEntrypoint ep -> DocItemRef (DocItemPlacement (DEntrypoint ep)) (DocItemReferenced (DEntrypoint ep)) # docItemToMarkdown :: HeaderLevel -> DEntrypoint ep -> Markdown # docItemToToc :: HeaderLevel -> DEntrypoint ep -> Markdown # docItemDependencies :: DEntrypoint ep -> [SomeDocDefinitionItem] # docItemsOrder :: [DEntrypoint ep] -> [DEntrypoint ep] #
type DocItemPlacement (DEntrypoint ep)
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemPlacement (DEntrypoint ep) = 'DocItemInlined
type DocItemReferenced (DEntrypoint ep)
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemReferenced (DEntrypoint ep) = 'True

type family EntrypointKindOverride ep #

Can be used to make a kind equivalent to some other kind; if changing this, entrypointKindPos and entrypointKindSectionName will be ignored.

Instances

Instances details

type EntrypointKindOverride CommonContractBehaviourKind
Instance details Defined in Lorentz.Entrypoints.Doc type EntrypointKindOverride CommonContractBehaviourKind = CommonContractBehaviourKind
type EntrypointKindOverride PlainEntrypointsKind
Instance details Defined in Lorentz.Entrypoints.Doc type EntrypointKindOverride PlainEntrypointsKind = PlainEntrypointsKind
type EntrypointKindOverride (FlattenedEntrypointsKindHiding heps)
Instance details Defined in Lorentz.Entrypoints.Doc type EntrypointKindOverride (FlattenedEntrypointsKindHiding heps) = PlainEntrypointsKind
type EntrypointKindOverride (CommonEntrypointsBehaviourKind kind)
Instance details Defined in Lorentz.Entrypoints.Doc type EntrypointKindOverride (CommonEntrypointsBehaviourKind kind) = CommonEntrypointsBehaviourKind kind

class Typeable ep => EntrypointKindHasDoc ep where #

Describes location of entrypoints of the given kind.

All such entrypoints will be placed under the same "entrypoints" section, and this instance defines characteristics of this section.

Minimal complete definition

entrypointKindOverrideSpecified | entrypointKindPos, entrypointKindSectionName

Associated Types

type EntrypointKindOverride ep #

Can be used to make a kind equivalent to some other kind; if changing this, entrypointKindPos and entrypointKindSectionName will be ignored.

type EntrypointKindOverride ep = ep

Methods

entrypointKindOverrideSpecified :: Dict ((EntrypointKindOverride ep == ep) ~ 'False) #

Implement this when specifying EntrypointKindOverride. This should never be normally used, but because MINIMAL pragma can't specify type families, we use this hack.

Default implementation is a bottom (i.e. a runtime error).

If implemented, it should be

entrypointKindOverrideSpecified = Dict

entrypointKindPos :: Natural #

Position of the respective entrypoints section in the doc. This shares the same positions space with all other doc items.

entrypointKindSectionName :: Text #

Name of the respective entrypoints section.

entrypointKindSectionDescription :: Maybe Markdown #

Description in the respective entrypoints section.

Instances

Instances details

EntrypointKindHasDoc CommonContractBehaviourKind
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type EntrypointKindOverride CommonContractBehaviourKind # Methods entrypointKindOverrideSpecified :: Dict ((EntrypointKindOverride CommonContractBehaviourKind == CommonContractBehaviourKind) ~ 'False) # entrypointKindPos :: Natural # entrypointKindSectionName :: Text # entrypointKindSectionDescription :: Maybe Markdown #
EntrypointKindHasDoc PlainEntrypointsKind
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type EntrypointKindOverride PlainEntrypointsKind # Methods entrypointKindOverrideSpecified :: Dict ((EntrypointKindOverride PlainEntrypointsKind == PlainEntrypointsKind) ~ 'False) # entrypointKindPos :: Natural # entrypointKindSectionName :: Text # entrypointKindSectionDescription :: Maybe Markdown #
Typeable heps => EntrypointKindHasDoc (FlattenedEntrypointsKindHiding heps)
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type EntrypointKindOverride (FlattenedEntrypointsKindHiding heps) # Methods entrypointKindOverrideSpecified :: Dict ((EntrypointKindOverride (FlattenedEntrypointsKindHiding heps) == FlattenedEntrypointsKindHiding heps) ~ 'False) # entrypointKindPos :: Natural # entrypointKindSectionName :: Text # entrypointKindSectionDescription :: Maybe Markdown #
EntrypointKindHasDoc kind => EntrypointKindHasDoc (CommonEntrypointsBehaviourKind kind)
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type EntrypointKindOverride (CommonEntrypointsBehaviourKind kind) # Methods entrypointKindOverrideSpecified :: Dict ((EntrypointKindOverride (CommonEntrypointsBehaviourKind kind) == CommonEntrypointsBehaviourKind kind) ~ 'False) # entrypointKindPos :: Natural # entrypointKindSectionName :: Text # entrypointKindSectionDescription :: Maybe Markdown #

data PlainEntrypointsKind #

Default value for DEntrypoint type argument.

Instances

Instances details

EntrypointKindHasDoc PlainEntrypointsKind
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type EntrypointKindOverride PlainEntrypointsKind # Methods entrypointKindOverrideSpecified :: Dict ((EntrypointKindOverride PlainEntrypointsKind == PlainEntrypointsKind) ~ 'False) # entrypointKindPos :: Natural # entrypointKindSectionName :: Text # entrypointKindSectionDescription :: Maybe Markdown #
type EntrypointKindOverride PlainEntrypointsKind
Instance details Defined in Lorentz.Entrypoints.Doc type EntrypointKindOverride PlainEntrypointsKind = PlainEntrypointsKind

data FlattenedEntrypointsKindHiding (hiddenEntrypoints :: [Symbol]) #

Special entrypoint kind that flattens one level of recursive entrypoints.

With EpdRecursive, intermediary nodes are hidden from documentation.

With EpdDelegate, intermediary nodes will still be shown.

Any entrypoints can be omitted from docs by listing those in the type parameter (which is especially helpful with EpdDelegate).

For other entrypoint derivation strategies (e.g. EpdPlain), behaves like PlainEntrypointsKind (with the exception of hiding entrypoints from docs)

If you have several levels of recursion, each level will need to have this kind.

Note that list of entrypoints to be hidden is not checked by default. Use entryCaseFlattenedHiding to have a static check that entrypoints to be hidden do indeed exist.

Instances

Instances details

('CaseClauseParam ctor cf ~ GCaseBranchInput ctor x, KnownSymbol ctor, DeriveCtorFieldDoc ctor cf, SingI heps) => GDocumentEntrypoints ept (FlattenedEntrypointsKindHiding heps) (C1 ('MetaCons ctor _1 _2) x) rest
Instance details Defined in Lorentz.Entrypoints.Doc Methods gDocumentEntrypoints :: forall (inp :: [Type]) (out :: [Type]). ParamBuilder -> Rec (CaseClauseL inp out) (GCaseClauses (C1 ('MetaCons ctor _1 _2) x) rest) -> (Rec (CaseClauseL inp out) rest -> Rec (CaseClauseL inp out) rest) -> Rec (CaseClauseL inp out) (GCaseClauses (C1 ('MetaCons ctor _1 _2) x) rest)
Typeable heps => EntrypointKindHasDoc (FlattenedEntrypointsKindHiding heps)
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type EntrypointKindOverride (FlattenedEntrypointsKindHiding heps) # Methods entrypointKindOverrideSpecified :: Dict ((EntrypointKindOverride (FlattenedEntrypointsKindHiding heps) == FlattenedEntrypointsKindHiding heps) ~ 'False) # entrypointKindPos :: Natural # entrypointKindSectionName :: Text # entrypointKindSectionDescription :: Maybe Markdown #
('CaseClauseParam ctor cf ~ GCaseBranchInput ctor x, KnownSymbol ctor) => GDocumentEntrypoints ('EPNode a b) (FlattenedEntrypointsKindHiding _heps) (C1 ('MetaCons ctor _1 _2) x) rest
Instance details Defined in Lorentz.Entrypoints.Doc Methods gDocumentEntrypoints :: forall (inp :: [Type]) (out :: [Type]). ParamBuilder -> Rec (CaseClauseL inp out) (GCaseClauses (C1 ('MetaCons ctor _1 _2) x) rest) -> (Rec (CaseClauseL inp out) rest -> Rec (CaseClauseL inp out) rest) -> Rec (CaseClauseL inp out) (GCaseClauses (C1 ('MetaCons ctor _1 _2) x) rest)
type EntrypointKindOverride (FlattenedEntrypointsKindHiding heps)
Instance details Defined in Lorentz.Entrypoints.Doc type EntrypointKindOverride (FlattenedEntrypointsKindHiding heps) = PlainEntrypointsKind

type FlattenedEntrypointsKind = FlattenedEntrypointsKindHiding ('[] :: [Symbol]) #

A convenience type synonym for FlattenedEntrypointsKindHiding not hiding any entrypoitns.

data CommonContractBehaviourKind #

Describes the behaviour common for all entrypoints.

For instance, if your contract runs some checks before calling any entrypoint, you probably want to wrap those checks into entrypointSection "Prior checks" (Proxy @CommonContractBehaviourKind).

Instances

Instances details

EntrypointKindHasDoc CommonContractBehaviourKind
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type EntrypointKindOverride CommonContractBehaviourKind # Methods entrypointKindOverrideSpecified :: Dict ((EntrypointKindOverride CommonContractBehaviourKind == CommonContractBehaviourKind) ~ 'False) # entrypointKindPos :: Natural # entrypointKindSectionName :: Text # entrypointKindSectionDescription :: Maybe Markdown #
type EntrypointKindOverride CommonContractBehaviourKind
Instance details Defined in Lorentz.Entrypoints.Doc type EntrypointKindOverride CommonContractBehaviourKind = CommonContractBehaviourKind

data CommonEntrypointsBehaviourKind (kind :: k) #

Describes the behaviour common for entrypoints of given kind.

This has very special use cases, like contracts with mix of upgradeable and permanent entrypoints.

Instances

Instances details

EntrypointKindHasDoc kind => EntrypointKindHasDoc (CommonEntrypointsBehaviourKind kind)
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type EntrypointKindOverride (CommonEntrypointsBehaviourKind kind) # Methods entrypointKindOverrideSpecified :: Dict ((EntrypointKindOverride (CommonEntrypointsBehaviourKind kind) == CommonEntrypointsBehaviourKind kind) ~ 'False) # entrypointKindPos :: Natural # entrypointKindSectionName :: Text # entrypointKindSectionDescription :: Maybe Markdown #
type EntrypointKindOverride (CommonEntrypointsBehaviourKind kind)
Instance details Defined in Lorentz.Entrypoints.Doc type EntrypointKindOverride (CommonEntrypointsBehaviourKind kind) = CommonEntrypointsBehaviourKind kind

data DEntrypointReference #

Inserts a reference to an existing entrypoint.

This helps to avoid duplication in the generated documentation, in order not to overwhelm the reader.

Constructors

DEntrypointReference Text Anchor

Instances

Instances details

DocItem DEntrypointReference
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type DocItemPlacement DEntrypointReference :: DocItemPlacementKind # type DocItemReferenced DEntrypointReference :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DEntrypointReference -> DocItemRef (DocItemPlacement DEntrypointReference) (DocItemReferenced DEntrypointReference) # docItemToMarkdown :: HeaderLevel -> DEntrypointReference -> Markdown # docItemToToc :: HeaderLevel -> DEntrypointReference -> Markdown # docItemDependencies :: DEntrypointReference -> [SomeDocDefinitionItem] # docItemsOrder :: [DEntrypointReference] -> [DEntrypointReference] #
type DocItemPlacement DEntrypointReference
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemPlacement DEntrypointReference = 'DocItemInlined
type DocItemReferenced DEntrypointReference
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemReferenced DEntrypointReference = 'False

newtype ParamBuilder #

When describing the way of parameter construction - piece of incremental builder for this description.

Constructors

ParamBuilder
Fields unParamBuilder :: Markdown -> Markdown Argument stands for previously constructed parameter piece, and returned value - a piece constructed after our step.

Instances

Instances details

Buildable ParamBuilder
Instance details Defined in Lorentz.Entrypoints.Doc Methods build :: ParamBuilder -> Builder #
Eq ParamBuilder
Instance details Defined in Lorentz.Entrypoints.Doc Methods (==) :: ParamBuilder -> ParamBuilder -> Bool # (/=) :: ParamBuilder -> ParamBuilder -> Bool #

data ParamBuildingDesc #

Constructors

ParamBuildingDesc
Fields pbdEnglish :: Markdown Plain english description of this step. pbdHaskell :: ParamBuilder How to construct parameter in Haskell code. pbdMichelson :: ParamBuilder How to construct parameter working on raw Michelson.

Instances

Instances details

Eq ParamBuildingDesc
Instance details Defined in Lorentz.Entrypoints.Doc Methods (==) :: ParamBuildingDesc -> ParamBuildingDesc -> Bool # (/=) :: ParamBuildingDesc -> ParamBuildingDesc -> Bool #

data ParamBuildingStep #

Describes a parameter building step.

This can be wrapping into (Haskell) constructor, or a more complex transformation.

Constructors

PbsWrapIn Text ParamBuildingDesc	Wraps something into constructor with given name. Constructor should be the one which corresponds to an entrypoint defined via field annotation, for more complex cases use `PbsCustom`.
PbsCallEntrypoint EpName	Directly call an entrypoint marked with a field annotation.
PbsCustom ParamBuildingDesc	Other action.
PbsUncallable [ParamBuildingStep]	This entrypoint cannot be called, which is possible when an explicit default entrypoint is present. This is not a true entrypoint but just some intermediate node in `or` tree and neither it nor any of its parents are marked with a field annotation. It contains dummy `ParamBuildingStep`s which were assigned before entrypoints were taken into account.

Instances

Instances details

Buildable ParamBuildingStep
Instance details Defined in Lorentz.Entrypoints.Doc Methods build :: ParamBuildingStep -> Builder #
Eq ParamBuildingStep
Instance details Defined in Lorentz.Entrypoints.Doc Methods (==) :: ParamBuildingStep -> ParamBuildingStep -> Bool # (/=) :: ParamBuildingStep -> ParamBuildingStep -> Bool #

data SomeEntrypointArg #

Entrypoint argument type in typed representation.

Constructors

(NiceParameter a, TypeHasDoc a) => SomeEntrypointArg (Proxy a)

data DEntrypointArg #

Describes argument of an entrypoint.

Constructors

DEntrypointArg

Fields

epaArg :: Maybe SomeEntrypointArg
Argument of the entrypoint. Pass Nothing if no argument is required.
epaBuilding :: [ParamBuildingStep]
Describes a way to lift an entrypoint argument into full parameter which can be passed to the contract.
Steps are supposed to be applied in the order opposite to one in which they are given. E.g. suppose that an entrypoint is called as Run (Service1 arg); then the first step (actual last) should describe wrapping into Run constructor, and the second step (actual first) should be about wrapping into Service1 constructor.

Instances

Instances details

DocItem DEntrypointArg
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type DocItemPlacement DEntrypointArg :: DocItemPlacementKind # type DocItemReferenced DEntrypointArg :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DEntrypointArg -> DocItemRef (DocItemPlacement DEntrypointArg) (DocItemReferenced DEntrypointArg) # docItemToMarkdown :: HeaderLevel -> DEntrypointArg -> Markdown # docItemToToc :: HeaderLevel -> DEntrypointArg -> Markdown # docItemDependencies :: DEntrypointArg -> [SomeDocDefinitionItem] # docItemsOrder :: [DEntrypointArg] -> [DEntrypointArg] #
type DocItemPlacement DEntrypointArg
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemPlacement DEntrypointArg = 'DocItemInlined
type DocItemReferenced DEntrypointArg
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemReferenced DEntrypointArg = 'False

class KnownSymbol con => DeriveCtorFieldDoc (con :: Symbol) (cf :: CtorField) where #

Pick a type documentation from CtorField.

Methods

deriveCtorFieldDoc :: DEntrypointArg #

Instances

Instances details

KnownSymbol con => DeriveCtorFieldDoc con 'NoFields
Instance details Defined in Lorentz.Entrypoints.Doc Methods deriveCtorFieldDoc :: DEntrypointArg #
(NiceParameter ty, TypeHasDoc ty, KnownValue ty, KnownSymbol con) => DeriveCtorFieldDoc con ('OneField ty)
Instance details Defined in Lorentz.Entrypoints.Doc Methods deriveCtorFieldDoc :: DEntrypointArg #

type DocumentEntrypoints kind a = (Generic a, GDocumentEntrypoints (BuildEPTree' a) kind (Rep a) ('[] :: [CaseClauseParam])) #

Constraint for documentEntrypoints.

class EntryArrow (kind :: k) (name :: Symbol) body where #

Provides arror for convenient entrypoint documentation

Methods

(#->) :: (Label name, Proxy kind) -> body -> body #

Lift entrypoint implementation.

Entrypoint names should go with "e" prefix.

Instances

Instances details

(name ~ AppendSymbol "e" epName, body ~ ((param ': s) :-> out), KnownSymbol epName, DocItem (DEntrypoint kind), NiceParameter param, TypeHasDoc param, KnownValue param) => EntryArrow (kind :: Type) name body
Instance details Defined in Lorentz.Entrypoints.Doc Methods (#->) :: (Label name, Proxy kind) -> body -> body #

type family RequireFlatParamEps cp where ... #

Equations

RequireFlatParamEps cp = (NiceParameterFull cp, RequireFlatEpDerivation cp (GetParameterEpDerivation cp), RequireSumType cp)

type family RequireFlatEpDerivation (cp :: t) deriv where ... #

Equations

RequireFlatEpDerivation (_1 :: t) EpdNone = ()
RequireFlatEpDerivation (_1 :: t) EpdPlain = ()
RequireFlatEpDerivation (cp :: t) deriv = TypeError (('Text "Parameter is not flat" :$$: (('Text "For parameter `" :<>: 'ShowType cp) :<>: 'Text "`")) :$$: (('Text "With entrypoints derivation way `" :<>: 'ShowType deriv) :<>: 'Text "`")) :: Constraint

stNickname :: forall (name :: Symbol). Label name -> FieldRef (FieldAlias name) #

Version of stAlias adopted to labels.

stAlias :: forall {k} (alias :: k). FieldRef (FieldAlias alias) #

Construct an alias at term level.

This requires passing the alias via type annotation.

stNested :: StNestedImpl f SelfRef => f #

Provides alternative variadic interface for deep entries access.

Example: stToField (stNested #a #b #c)

this :: forall (p :: FieldRefTag). SelfRef p #

An alias for SelfRef.

Examples:

>>> push 5 # stMem this -$ (mempty :: Map Integer MText)
False

>>> stGetField this # pair -$ (5 :: Integer)
(5,5)

mkStoreEp :: forall (epName :: Symbol) epParam epStore. Label epName -> EntrypointLambda epParam epStore -> EntrypointsField epParam epStore #

Utility to create EntrypointsFields from an entrypoint name (epName) and an EntrypointLambda implementation. Note that you need to merge multiple of these (with <>) if your field contains more than one entrypoint lambda.

zoomStoreSubmapOps :: forall {k1} {k2} store (submapName :: k1) (nameInSubmap :: k2) key value subvalue. (NiceConstant value, NiceConstant subvalue, Dupable key, Dupable store) => FieldRef submapName -> LIso (Maybe value) value -> LIso (Maybe subvalue) subvalue -> StoreSubmapOps store submapName key value -> StoreFieldOps value nameInSubmap subvalue -> StoreSubmapOps store nameInSubmap key subvalue #

Turn submap operations into operations on a part of the submap value.

Normally, if you need this set of operations, it would be better to split your submap into several separate submaps, each operating with its own part of the value. This set of operations is pretty inefficient and exists only as a temporary measure, if due to historical reasons you have to leave storage format intact.

This implementation puts no distinction between value == Nothing and value == Just defValue cases. Getters, when notice a value equal to the default value, report its absence. Setters tend to remove the value from submap when possible.

LIso (Maybe value) value and LIso (Maybe subvalue) subvalue arguments describe how to get a value if it was absent in map and how to detect when it can be safely removed from map.

Example of use: zoomStoreSubmapOps #mySubmap nonDefIso nonDefIso storeSubmapOps storeFieldOpsADT

composeStoreEntrypointOps :: forall {k} store substore (nameInStore :: k) (epName :: Symbol) epParam epStore. (HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreEntrypointOps substore epName epParam epStore -> StoreEntrypointOps store epName epParam epStore #

sequenceStoreSubmapOps :: forall {k1} {k2} store substore value (name :: k1) (subName :: k2) key1 key2. (NiceConstant substore, KnownValue value, Dupable (key1, key2), Dupable store) => FieldRef name -> LIso (Maybe substore) substore -> StoreSubmapOps store name key1 substore -> StoreSubmapOps substore subName key2 value -> StoreSubmapOps store subName (key1, key2) value #

Chain implementations of two submap operations sets. Used to provide shortcut access to a nested submap.

This is very inefficient since on each access to substore it has to be serialized/deserialized. Use this implementation only if due to historical reasons migrating storage is difficult.

LIso (Maybe substore) substore argument describes how to get substore value if it was absent in map and how to detect when it can be safely removed.

Example of use: sequenceStoreSubmapOps #mySubmap nonDefIso storeSubmapOps storeSubmapOps

composeStoreSubmapOps :: forall {k1} {k2} store substore (nameInStore :: k1) (mname :: k2) key value. (HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreSubmapOps substore mname key value -> StoreSubmapOps store mname key value #

Chain implementations of field and submap operations.

This requires Dupable substore for simplicity, in most cases it is possible to use a different chaining (nameInStore :-| mname :-| this) to avoid that constraint. If this constraint is still an issue, please create a ticket.

composeStoreFieldOps :: forall {k1} {k2} substore (nameInStore :: k1) store (nameInSubstore :: k2) field. HasDupableGetters substore => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreFieldOps substore nameInSubstore field -> StoreFieldOps store nameInSubstore field #

Chain two implementations of field operations.

Suits for a case when your store does not contain its fields directly rather has a nested structure.

mapStoreSubmapOpsValue :: forall {k} value1 value2 store (name :: k) key. (KnownValue value1, KnownValue value2) => LIso value1 value2 -> StoreSubmapOps store name key value1 -> StoreSubmapOps store name key value2 #

Change submap operations so that they work on a modified value.

mapStoreSubmapOpsKey :: forall {k} key2 key1 store (name :: k) value. Fn key2 key1 -> StoreSubmapOps store name key1 value -> StoreSubmapOps store name key2 value #

Change submap operations so that they work on a modified key.

mapStoreFieldOps :: forall {k} field1 field2 store (name :: k). KnownValue field1 => LIso field1 field2 -> StoreFieldOps store name field1 -> StoreFieldOps store name field2 #

Change field operations so that they work on a modified field.

For instance, to go from StoreFieldOps Storage "name" Integer to StoreFieldOps Storage "name" (value :! Integer) you can use mapStoreFieldOps (namedIso #value)

storeEntrypointOpsReferTo :: forall (epName :: Symbol) store epParam epStore (desiredName :: Symbol). Label epName -> StoreEntrypointOps store epName epParam epStore -> StoreEntrypointOps store desiredName epParam epStore #

Pretend that given StoreEntrypointOps implementation is made up for entrypoint with name desiredName, not its actual name. Logic of the implementation remains the same.

Instances

Instances details

KnownFieldRef SelfRef
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefObject SelfRef = (fr :: FieldRefKind) # Methods mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject SelfRef p #
StoreHasField store SelfRef store
Instance details Defined in Lorentz.StoreClass Methods storeFieldOps :: StoreFieldOps store SelfRef store #
(StoreHasField store field substore, StoreHasField substore subfield ty, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters substore) => StoreHasField store (field :-\| subfield :: FieldRefTag -> Type) ty
Instance details Defined in Lorentz.StoreClass Methods storeFieldOps :: StoreFieldOps store (field :-\| subfield) ty #
(StoreHasField store field substore, StoreHasSubmap substore subfield key value, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters store, Dupable substore) => StoreHasSubmap store (field :-\| subfield :: FieldRefTag -> Type) key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps store (field :-\| subfield) key value #
(NiceComparable key, Ord key, Dupable key) => StoreHasSubmap (Set key) SelfRef key ()
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (Set key) SelfRef key () #
KnownFieldRef (FieldAlias alias :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefObject (FieldAlias alias) = (fr :: FieldRefKind) # Methods mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (FieldAlias alias) p #
(NiceComparable key, KnownValue value) => StoreHasSubmap (Map key value) SelfRef key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (Map key value) SelfRef key value #
(NiceComparable key, KnownValue value) => StoreHasSubmap (BigMap key value) SelfRef key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (BigMap key value) SelfRef key value #
FieldRefHasFinalName r => FieldRefHasFinalName (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefFinalName (l :-\| r) :: Symbol # Methods fieldRefFinalName :: FieldRef (l :-\| r) -> Label (FieldRefFinalName (l :-\| r)) #
(KnownFieldRef l, KnownFieldRef r) => KnownFieldRef (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefObject (l :-\| r) = (fr :: FieldRefKind) # Methods mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (l :-\| r) p #
type FieldRefObject SelfRef
Instance details Defined in Lorentz.StoreClass type FieldRefObject SelfRef = SelfRef
type FieldRefObject (FieldAlias alias :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass type FieldRefObject (FieldAlias alias :: FieldRefTag -> Type) = FieldAlias alias
type FieldRefFinalName (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass type FieldRefFinalName (l :-\| r :: FieldRefTag -> Type) = FieldRefFinalName r
type FieldRefObject (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass type FieldRefObject (l :-\| r :: FieldRefTag -> Type) = l :-\| r

type family FieldRefObject (ty :: k) = (fr :: FieldRefKind) | fr -> k ty #

Instances

Instances details

type FieldRefObject (name :: Symbol)
Instance details Defined in Lorentz.StoreClass type FieldRefObject (name :: Symbol) = FieldName name
type FieldRefObject SelfRef
Instance details Defined in Lorentz.StoreClass type FieldRefObject SelfRef = SelfRef
type FieldRefObject (FieldAlias alias :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass type FieldRefObject (FieldAlias alias :: FieldRefTag -> Type) = FieldAlias alias
type FieldRefObject (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass type FieldRefObject (l :-\| r :: FieldRefTag -> Type) = l :-\| r

class KnownFieldRef (ty :: k) where #

For a type-level field reference - an associated term-level representation.

This is similar to singletons Sing + SingI pair but has small differences:

Dedicated to field references, thus term-level thing has FieldRefKind kind.
The type of term-level value (FieldRefObject ty) determines the kind of the reference type.

Associated Types

type FieldRefObject (ty :: k) = (fr :: FieldRefKind) | fr -> k ty #

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject ty p #

Instances

Instances details

KnownSymbol name => KnownFieldRef (name :: Symbol)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefObject name = (fr :: FieldRefKind) # Methods mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject name p #
KnownFieldRef SelfRef
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefObject SelfRef = (fr :: FieldRefKind) # Methods mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject SelfRef p #
KnownFieldRef (FieldAlias alias :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefObject (FieldAlias alias) = (fr :: FieldRefKind) # Methods mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (FieldAlias alias) p #
(KnownFieldRef l, KnownFieldRef r) => KnownFieldRef (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefObject (l :-\| r) = (fr :: FieldRefKind) # Methods mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (l :-\| r) p #

type FieldRef (name :: k) = FieldRefObject name 'FieldRefTag #

Some kind of reference to a field.

The idea behind this type is that in trivial case (name :: Symbol) it can be instantiated with a mere label, but it is generic enough to allow complex field references as well.

data FieldName (n :: Symbol) (p :: FieldRefTag) #

The simplest field reference - just a name. Behaves similarly to Label.

type FieldSymRef (name :: Symbol) = FieldRef name #

Version of FieldRef restricted to symbolic labels.

FieldSymRef name ≡ FieldName name 'FieldRefTag

type family FieldRefFinalName (fr :: k) :: Symbol #

Instances

Instances details

type FieldRefFinalName (name :: Symbol)
Instance details Defined in Lorentz.StoreClass type FieldRefFinalName (name :: Symbol) = name
type FieldRefFinalName (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass type FieldRefFinalName (l :-\| r :: FieldRefTag -> Type) = FieldRefFinalName r

class FieldRefHasFinalName (fr :: k) where #

Provides access to the direct name of the referred field.

This is used in stToFieldNamed.

Associated Types

type FieldRefFinalName (fr :: k) :: Symbol #

Methods

fieldRefFinalName :: FieldRef fr -> Label (FieldRefFinalName fr) #

Instances

Instances details

FieldRefHasFinalName (name :: Symbol)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefFinalName name :: Symbol # Methods fieldRefFinalName :: FieldRef name -> Label (FieldRefFinalName name) #
FieldRefHasFinalName r => FieldRefHasFinalName (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefFinalName (l :-\| r) :: Symbol # Methods fieldRefFinalName :: FieldRef (l :-\| r) -> Label (FieldRefFinalName (l :-\| r)) #

data StoreFieldOps store (fname :: k) ftype #

Datatype containing the full implementation of StoreHasField typeclass.

We use this grouping because in most cases the implementation will be chosen among the default ones, and initializing all methods at once is simpler and more consistent. (One can say that we are trying to emulate the DerivingVia extension.)

Constructors

StoreFieldOps

Fields

sopToField :: forall (s :: [Type]). FieldRef fname -> (store ': s) :-> (ftype ': s)
sopGetFieldOpen :: forall res (s :: [Type]). HasDupableGetters store => ('[ftype] :-> '[res, ftype]) -> ('[ftype] :-> '[res]) -> FieldRef fname -> (store ': s) :-> (res ': (store ': s))
See getFieldOpen for explanation of the signature.
sopSetFieldOpen :: forall new (s :: [Type]). ('[new, ftype] :-> '[ftype]) -> FieldRef fname -> (new ': (store ': s)) :-> (store ': s)
See setFieldOpen for explanation of the signature.

class StoreHasField store (fname :: k) ftype | store fname -> ftype where #

Provides operations on fields for storage.

Methods

storeFieldOps :: StoreFieldOps store fname ftype #

Instances

Instances details

HasFieldOfType store fname ftype => StoreHasField store (fname :: Symbol) ftype
Instance details Defined in Lorentz.StoreClass Methods storeFieldOps :: StoreFieldOps store fname ftype #
StoreHasField store SelfRef store
Instance details Defined in Lorentz.StoreClass Methods storeFieldOps :: StoreFieldOps store SelfRef store #
(StoreHasField store field substore, StoreHasField substore subfield ty, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters substore) => StoreHasField store (field :-\| subfield :: FieldRefTag -> Type) ty
Instance details Defined in Lorentz.StoreClass Methods storeFieldOps :: StoreFieldOps store (field :-\| subfield) ty #

data StoreSubmapOps store (mname :: k) key value #

Datatype containing the full implementation of StoreHasSubmap typeclass.

We use this grouping because in most cases the implementation will be chosen among the default ones, and initializing all methods at once is simpler and more consistent. (One can say that we are trying to emulate the DerivingVia extension.)

Constructors

StoreSubmapOps

Fields

sopMem :: forall (s :: [Type]). FieldRef mname -> (key ': (store ': s)) :-> (Bool ': s)
sopGet :: forall (s :: [Type]). KnownValue value => FieldRef mname -> (key ': (store ': s)) :-> (Maybe value ': s)
sopUpdate :: forall (s :: [Type]). FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (store ': s)
sopGetAndUpdate :: forall (s :: [Type]). FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (Maybe value ': (store ': s))
sopDelete :: forall (s :: [Type]). FieldRef mname -> (key ': (store ': s)) :-> (store ': s)
sopInsert :: forall (s :: [Type]). FieldRef mname -> (key ': (value ': (store ': s))) :-> (store ': s)

class StoreHasSubmap store (mname :: k) key value | store mname -> key value where #

Provides operations on submaps of storage.

Methods

storeSubmapOps :: StoreSubmapOps store mname key value #

Instances

Instances details

(StoreHasField store name submap, StoreHasSubmap submap SelfRef key value, KnownSymbol name, HasDupableGetters store, Dupable submap) => StoreHasSubmap store (name :: Symbol) key value	Provides access to the submap via the respective field. Tricky storages that consolidate submaps in a non-trivial way can define instances overlapping this one.
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps store name key value #
(StoreHasField store field substore, StoreHasSubmap substore subfield key value, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters store, Dupable substore) => StoreHasSubmap store (field :-\| subfield :: FieldRefTag -> Type) key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps store (field :-\| subfield) key value #
(NiceComparable key, Ord key, Dupable key) => StoreHasSubmap (Set key) SelfRef key ()
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (Set key) SelfRef key () #
(NiceComparable key, KnownValue value) => StoreHasSubmap (Map key value) SelfRef key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (Map key value) SelfRef key value #
(NiceComparable key, KnownValue value) => StoreHasSubmap (BigMap key value) SelfRef key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (BigMap key value) SelfRef key value #

type EntrypointLambda param store = Lambda (param, store) ([Operation], store) #

Type synonym for a Lambda that can be used as an entrypoint

type EntrypointsField param store = BigMap MText (EntrypointLambda param store) #

Type synonym of a BigMap mapping MText (entrypoint names) to EntrypointLambda.

This is useful when defining instances of StoreHasEntrypoint as a storage field containing one or more entrypoints (lambdas) of the same type.

data StoreEntrypointOps store (epName :: Symbol) epParam epStore #

Datatype containing the full implementation of StoreHasEntrypoint typeclass.

We use this grouping because in most cases the implementation will be chosen among the default ones, and initializing all methods at once is simpler and more consistent. (One can say that we are trying to emulate the DerivingVia extension.)

Constructors

StoreEntrypointOps

Fields

sopToEpLambda :: forall (s :: [Type]). Label epName -> (store ': s) :-> (EntrypointLambda epParam epStore ': s)
sopSetEpLambda :: forall (s :: [Type]). HasDupableGetters store => Label epName -> (EntrypointLambda epParam epStore ': (store ': s)) :-> (store ': s)
sopToEpStore :: forall (s :: [Type]). Label epName -> (store ': s) :-> (epStore ': s)
sopSetEpStore :: forall (s :: [Type]). Label epName -> (epStore ': (store ': s)) :-> (store ': s)

class StoreHasEntrypoint store (epName :: Symbol) epParam epStore | store epName -> epParam epStore where #

Provides operations on stored entrypoints.

store is the storage containing both the entrypoint epName (note: it has to be in a BigMap to take advantage of lazy evaluation) and the epStore field this operates on.

Methods

storeEpOps :: StoreEntrypointOps store epName epParam epStore #

data ((l :: k1) :-| (r :: k2)) (p :: FieldRefTag) infixr 8 #

Refer to a nested entry in storage.

Example: stToField (#a :-| #b) fetches field b in the type under field a.

If not favouring this name much, you can try an alias from Lorentz.StoreClass.Extra.

Constructors

(FieldRef l) :-| (FieldRef r) infixr 8

Instances

Instances details

(StoreHasField store field substore, StoreHasField substore subfield ty, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters substore) => StoreHasField store (field :-\| subfield :: FieldRefTag -> Type) ty
Instance details Defined in Lorentz.StoreClass Methods storeFieldOps :: StoreFieldOps store (field :-\| subfield) ty #
(StoreHasField store field substore, StoreHasSubmap substore subfield key value, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters store, Dupable substore) => StoreHasSubmap store (field :-\| subfield :: FieldRefTag -> Type) key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps store (field :-\| subfield) key value #
FieldRefHasFinalName r => FieldRefHasFinalName (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefFinalName (l :-\| r) :: Symbol # Methods fieldRefFinalName :: FieldRef (l :-\| r) -> Label (FieldRefFinalName (l :-\| r)) #
(KnownFieldRef l, KnownFieldRef r) => KnownFieldRef (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefObject (l :-\| r) = (fr :: FieldRefKind) # Methods mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (l :-\| r) p #
type FieldRefFinalName (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass type FieldRefFinalName (l :-\| r :: FieldRefTag -> Type) = FieldRefFinalName r
type FieldRefObject (l :-\| r :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass type FieldRefObject (l :-\| r :: FieldRefTag -> Type) = l :-\| r

data SelfRef (p :: FieldRefTag) #

Refer to no particular field, access itself.

Constructors

SelfRef

Instances

Instances details

KnownFieldRef SelfRef
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefObject SelfRef = (fr :: FieldRefKind) # Methods mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject SelfRef p #
StoreHasField store SelfRef store
Instance details Defined in Lorentz.StoreClass Methods storeFieldOps :: StoreFieldOps store SelfRef store #
(NiceComparable key, Ord key, Dupable key) => StoreHasSubmap (Set key) SelfRef key ()
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (Set key) SelfRef key () #
(NiceComparable key, KnownValue value) => StoreHasSubmap (Map key value) SelfRef key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (Map key value) SelfRef key value #
(NiceComparable key, KnownValue value) => StoreHasSubmap (BigMap key value) SelfRef key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (BigMap key value) SelfRef key value #
type FieldRefObject SelfRef
Instance details Defined in Lorentz.StoreClass type FieldRefObject SelfRef = SelfRef

data FieldAlias (alias :: k) (p :: FieldRefTag) #

Alias for a field reference.

This allows creating _custom_ field references; you will have to define the respective StoreHasField and StoreHasSubmap instances manually. Since this type occupies a different "namespace" than string labels and :-|, no overlappable instances will be necessary.

Example:

-- Shortcut for a deeply nested field X
data FieldX

instance StoreHasField Storage (FieldAlias FieldX) Integer where
  ...

accessX = stToField (stAlias @FieldX)

Note that alias type argument allows instantiations of any kind.

Instances

Instances details

KnownFieldRef (FieldAlias alias :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass Associated Types type FieldRefObject (FieldAlias alias) = (fr :: FieldRefKind) # Methods mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (FieldAlias alias) p #
type FieldRefObject (FieldAlias alias :: FieldRefTag -> Type)
Instance details Defined in Lorentz.StoreClass type FieldRefObject (FieldAlias alias :: FieldRefTag -> Type) = FieldAlias alias

type FieldNickname (alias :: Symbol) = FieldAlias alias #

Kind-restricted version of FieldAlias to work solely with string labels.

data (k2 :: k) ~> (v :: k1) infix 9 #

Indicates a submap with given key and value types.

data (param :: k) ::-> (store :: k1) infix 9 #

Indicates a stored entrypoint with the given param and store types.

type family StorageContains store (content :: [NamedField]) where ... #

Concise way to write down constraints with expected content of a storage.

Use it like follows:

type StorageConstraint store = StorageContains store
  [ "fieldInt" := Int
  , "fieldNat" := Nat
  , "epsToNat" := Int ::-> Nat
  , "balances" := Address ~> Int
  ]

Note that this won't work with complex field references, they have to be included using e.g. StoreHasField manually.

Equations

StorageContains _1 ('[] :: [NamedField]) = ()
StorageContains store ((n := Identity ty) ': ct) = (StoreHasField store n ty, StorageContains store ct)
StorageContains store ((n := (k ~> v)) ': ct) = (StoreHasSubmap store n k v, StorageContains store ct)
StorageContains store ((n := (ep ::-> es)) ': ct) = (StoreHasEntrypoint store n ep es, StorageContains store ct)
StorageContains store ((n := ty) ': ct) = (StoreHasField store n ty, StorageContains store ct)

baseErrorDocHandlers :: [NumericErrorDocHandler] #

Handlers for most common errors defined in Lorentz.

voidResultDocHandler :: NumericErrorDocHandler #

Handler for VoidResult.

customErrorDocHandler :: NumericErrorDocHandler #

Handler for all CustomErrors.

applyErrorTagToErrorsDocWith :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => [NumericErrorDocHandler] -> ErrorTagMap -> (inp :-> out) -> inp :-> out #

Extended version of applyErrorTagToErrorsDoc which accepts error handlers.

In most cases that function should be enough for your purposes, but it uses a fixed set of base handlers which may be not enough in case when you define your own errors. In this case define and pass all the necessary handlers to this function.

It fails with error if some of the errors used in the contract cannot be handled with given handlers.

applyErrorTagToErrorsDoc :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => ErrorTagMap -> (inp :-> out) -> inp :-> out #

Modify documentation generated for given code so that all CustomError mention not their textual error tag rather respective numeric one from the given map.

If some documented error is not present in the map, it remains unmodified. This function may fail with error if contract uses some uncommon errors, see applyErrorTagToErrorsDocWith for details.

data DDescribeErrorTagMap #

Adds a section which explains error tag mapping.

Constructors

DDescribeErrorTagMap
Fields detmSrcLoc :: Text Describes where the error tag map is defined in Haskell code.

Instances

Instances details

Eq DDescribeErrorTagMap
Instance details Defined in Lorentz.Errors.Numeric.Doc Methods (==) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (/=) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool #
Ord DDescribeErrorTagMap
Instance details Defined in Lorentz.Errors.Numeric.Doc Methods compare :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Ordering # (<) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (<=) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (>) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # (>=) :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> Bool # max :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> DDescribeErrorTagMap # min :: DDescribeErrorTagMap -> DDescribeErrorTagMap -> DDescribeErrorTagMap #
DocItem DDescribeErrorTagMap
Instance details Defined in Lorentz.Errors.Numeric.Doc Associated Types type DocItemPlacement DDescribeErrorTagMap :: DocItemPlacementKind # type DocItemReferenced DDescribeErrorTagMap :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DDescribeErrorTagMap -> DocItemRef (DocItemPlacement DDescribeErrorTagMap) (DocItemReferenced DDescribeErrorTagMap) # docItemToMarkdown :: HeaderLevel -> DDescribeErrorTagMap -> Markdown # docItemToToc :: HeaderLevel -> DDescribeErrorTagMap -> Markdown # docItemDependencies :: DDescribeErrorTagMap -> [SomeDocDefinitionItem] # docItemsOrder :: [DDescribeErrorTagMap] -> [DDescribeErrorTagMap] #
type DocItemPlacement DDescribeErrorTagMap
Instance details Defined in Lorentz.Errors.Numeric.Doc type DocItemPlacement DDescribeErrorTagMap = 'DocItemInDefinitions
type DocItemReferenced DDescribeErrorTagMap
Instance details Defined in Lorentz.Errors.Numeric.Doc type DocItemReferenced DDescribeErrorTagMap = 'True

data NumericErrorDocHandlerError #

Errors for NumericErrorDocHandler

data NumericErrorDocHandler #

Handler which changes documentation for one particular error type.

data NumericErrorWrapper (numTag :: Nat) err #

Some error with a numeric tag attached.

Instances

Instances details

(ErrorHasDoc err, KnownNat numTag, ErrorHasNumericDoc err) => ErrorHasDoc (NumericErrorWrapper numTag err)
Instance details Defined in Lorentz.Errors.Numeric.Doc Associated Types type ErrorRequirements (NumericErrorWrapper numTag err) # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements (NumericErrorWrapper numTag err)) #
type ErrorRequirements (NumericErrorWrapper numTag err)
Instance details Defined in Lorentz.Errors.Numeric.Doc type ErrorRequirements (NumericErrorWrapper numTag err) = ()

voidResultTag :: MText #

data View_ a r #

view type synonym as described in A1.

Instances

Instances details

(CanCastTo a1 a2, CanCastTo r1 r2) => CanCastTo (View_ a1 r1 :: Type) (View_ a2 r2 :: Type)
Instance details Defined in Lorentz.Macro Methods castDummy :: Proxy (View_ a1 r1) -> Proxy (View_ a2 r2) -> () #
Generic (View_ a r)
Instance details Defined in Lorentz.Macro Associated Types type Rep (View_ a r) :: Type -> Type # Methods from :: View_ a r -> Rep (View_ a r) x # to :: Rep (View_ a r) x -> View_ a r #
Show a => Show (View_ a r)
Instance details Defined in Lorentz.Macro Methods showsPrec :: Int -> View_ a r -> ShowS # show :: View_ a r -> String # showList :: [View_ a r] -> ShowS #
(HasNoOpToT r, HasNoNestedBigMaps (ToT r)) => Buildable (View_ () r)
Instance details Defined in Lorentz.Macro Methods build :: View_ () r -> Builder #
(Buildable a, HasNoOpToT r, HasNoNestedBigMaps (ToT r)) => Buildable (View_ a r)
Instance details Defined in Lorentz.Macro Methods build :: View_ a r -> Builder #
Eq a => Eq (View_ a r)
Instance details Defined in Lorentz.Macro Methods (==) :: View_ a r -> View_ a r -> Bool # (/=) :: View_ a r -> View_ a r -> Bool #
(HasAnnotation a, HasAnnotation r) => HasAnnotation (View_ a r)
Instance details Defined in Lorentz.Macro Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (View_ a r)) # annOptions :: Maybe AnnOptions #
HasRPCRepr a => HasRPCRepr (View_ a r)
Instance details Defined in Lorentz.Macro Associated Types type AsRPC (View_ a r) #
Each '[Typeable :: Type -> Constraint, TypeHasDoc] '[a, r] => TypeHasDoc (View_ a r)
Instance details Defined in Lorentz.Macro Associated Types type TypeDocFieldDescriptions (View_ a r) :: FieldDescriptions # Methods typeDocName :: Proxy (View_ a r) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (View_ a r) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (View_ a r) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (View_ a r) # typeDocMichelsonRep :: TypeDocMichelsonRep (View_ a r) #
(HasNoOpToT r, HasNoNestedBigMaps (ToT r), WellTypedToT a) => IsoValue (View_ a r)
Instance details Defined in Lorentz.Macro Associated Types type ToT (View_ a r) :: T # Methods toVal :: View_ a r -> Value (ToT (View_ a r)) # fromVal :: Value (ToT (View_ a r)) -> View_ a r #
type Rep (View_ a r)
Instance details Defined in Lorentz.Macro type Rep (View_ a r) = D1 ('MetaData "View_" "Lorentz.Macro" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'False) (C1 ('MetaCons "View_" 'PrefixI 'True) (S1 ('MetaSel ('Just "viewParam") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "viewCallbackTo") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (ContractRef r))))
type AsRPC (View_ a r)
Instance details Defined in Lorentz.Macro type AsRPC (View_ a r) = View_ (AsRPC a) r
type TypeDocFieldDescriptions (View_ a r)
Instance details Defined in Lorentz.Macro type TypeDocFieldDescriptions (View_ a r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (View_ a r)
Instance details Defined in Lorentz.Macro type ToT (View_ a r) = GValueType (Rep (View_ a r))

data Void_ a b #

void type synonym as described in A1.

Instances

Instances details

(CanCastTo a1 a2, CanCastTo r1 r2) => CanCastTo (Void_ a1 r1 :: Type) (Void_ a2 r2 :: Type)
Instance details Defined in Lorentz.Macro Methods castDummy :: Proxy (Void_ a1 r1) -> Proxy (Void_ a2 r2) -> () #
Generic (Void_ a b)
Instance details Defined in Lorentz.Macro Associated Types type Rep (Void_ a b) :: Type -> Type # Methods from :: Void_ a b -> Rep (Void_ a b) x # to :: Rep (Void_ a b) x -> Void_ a b #
Show a => Show (Void_ a b)
Instance details Defined in Lorentz.Macro Methods showsPrec :: Int -> Void_ a b -> ShowS # show :: Void_ a b -> String # showList :: [Void_ a b] -> ShowS #
Buildable a => Buildable (Void_ a b)
Instance details Defined in Lorentz.Macro Methods build :: Void_ a b -> Builder #
(HasAnnotation a, HasAnnotation b) => HasAnnotation (Void_ a b)
Instance details Defined in Lorentz.Macro Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Void_ a b)) # annOptions :: Maybe AnnOptions #
HasRPCRepr a => HasRPCRepr (Void_ a r)
Instance details Defined in Lorentz.Macro Associated Types type AsRPC (Void_ a r) #
Each '[Typeable :: Type -> Constraint, TypeHasDoc] '[a, r] => TypeHasDoc (Void_ a r)
Instance details Defined in Lorentz.Macro Associated Types type TypeDocFieldDescriptions (Void_ a r) :: FieldDescriptions # Methods typeDocName :: Proxy (Void_ a r) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Void_ a r) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Void_ a r) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Void_ a r) # typeDocMichelsonRep :: TypeDocMichelsonRep (Void_ a r) #
(WellTypedToT r, WellTypedToT a) => IsoValue (Void_ a r)
Instance details Defined in Lorentz.Macro Associated Types type ToT (Void_ a r) :: T # Methods toVal :: Void_ a r -> Value (ToT (Void_ a r)) # fromVal :: Value (ToT (Void_ a r)) -> Void_ a r #
type Rep (Void_ a b)
Instance details Defined in Lorentz.Macro type Rep (Void_ a b) = D1 ('MetaData "Void_" "Lorentz.Macro" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'False) (C1 ('MetaCons "Void_" 'PrefixI 'True) (S1 ('MetaSel ('Just "voidParam") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 a) :*: S1 ('MetaSel ('Just "voidResProxy") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Lambda b b))))
type AsRPC (Void_ a r)
Instance details Defined in Lorentz.Macro type AsRPC (Void_ a r) = Void_ (AsRPC a) r
type TypeDocFieldDescriptions (Void_ a r)
Instance details Defined in Lorentz.Macro type TypeDocFieldDescriptions (Void_ a r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (Void_ a r)
Instance details Defined in Lorentz.Macro type ToT (Void_ a r) = GValueType (Rep (Void_ a r))

data VoidResult r #

Newtype over void result type used in tests to distinguish successful void result from other errors.

Usage example: lExpectFailWith (== VoidResult roleMaster)`

This error is special - it can contain arguments of different types depending on entrypoint which raises it.

Instances

Instances details

Generic (VoidResult r)
Instance details Defined in Lorentz.Macro Associated Types type Rep (VoidResult r) :: Type -> Type # Methods from :: VoidResult r -> Rep (VoidResult r) x # to :: Rep (VoidResult r) x -> VoidResult r #
Eq r => Eq (VoidResult r)
Instance details Defined in Lorentz.Macro Methods (==) :: VoidResult r -> VoidResult r -> Bool # (/=) :: VoidResult r -> VoidResult r -> Bool #
TypeHasDoc r => ErrorHasDoc (VoidResult r)
Instance details Defined in Lorentz.Macro Associated Types type ErrorRequirements (VoidResult r) # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements (VoidResult r)) #
(NiceConstant r, ErrorHasDoc (VoidResult r)) => IsError (VoidResult r)
Instance details Defined in Lorentz.Macro Methods errorToVal :: VoidResult r -> (forall (t :: T). ErrorScope t => Value t -> r0) -> r0 # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text (VoidResult r) # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError (VoidResult r) => VoidResult r -> s :-> t #
ErrorHasDoc (VoidResult res) => ErrorHasNumericDoc (VoidResult res)
Instance details Defined in Lorentz.Errors.Numeric.Doc Methods numericErrorDocHaskellRep :: Text -> Markdown numericErrorDocTextualTag :: Text
(TypeHasDoc r, IsError (VoidResult r)) => TypeHasDoc (VoidResult r)
Instance details Defined in Lorentz.Macro Associated Types type TypeDocFieldDescriptions (VoidResult r) :: FieldDescriptions # Methods typeDocName :: Proxy (VoidResult r) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (VoidResult r) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (VoidResult r) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (VoidResult r) # typeDocMichelsonRep :: TypeDocMichelsonRep (VoidResult r) #
(Bottom, WellTypedToT (VoidResult r), TypeError ('Text "No IsoValue instance for VoidResult " :<>: 'ShowType r) :: Constraint) => IsoValue (VoidResult r)
Instance details Defined in Lorentz.Macro Associated Types type ToT (VoidResult r) :: T # Methods toVal :: VoidResult r -> Value (ToT (VoidResult r)) # fromVal :: Value (ToT (VoidResult r)) -> VoidResult r #
type Rep (VoidResult r)
Instance details Defined in Lorentz.Macro type Rep (VoidResult r) = D1 ('MetaData "VoidResult" "Lorentz.Macro" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'True) (C1 ('MetaCons "VoidResult" 'PrefixI 'True) (S1 ('MetaSel ('Just "unVoidResult") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 r)))
type ErrorRequirements (VoidResult r)
Instance details Defined in Lorentz.Macro type ErrorRequirements (VoidResult r) = ()
type TypeDocFieldDescriptions (VoidResult r)
Instance details Defined in Lorentz.Macro type TypeDocFieldDescriptions (VoidResult r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (VoidResult r)
Instance details Defined in Lorentz.Macro type ToT (VoidResult r) = TypeError ('Text "No IsoValue instance for VoidResult " :<>: 'ShowType r) :: T

class NonZero t #

Minimal complete definition

nonZero

Instances

Instances details

NonZero Integer
Instance details Defined in Lorentz.Macro Methods nonZero :: forall (s :: [Type]). (Integer ': s) :-> (Maybe Integer ': s) #
NonZero Natural
Instance details Defined in Lorentz.Macro Methods nonZero :: forall (s :: [Type]). (Natural ': s) :-> (Maybe Natural ': s) #
NiceComparable d => NonZero (Ticket d)
Instance details Defined in Lorentz.Macro Methods nonZero :: forall (s :: [Type]). (Ticket d ': s) :-> (Maybe (Ticket d) ': s) #

unsafeUnwrap_ :: forall dt (name :: Symbol) (st :: [Type]). InstrUnwrapC dt name => Label name -> (dt ': st) :-> (CtorOnlyField name dt ': st) #

Unwrap a constructor with the given name. Useful for sum types.

>>> unsafeUnwrap_ @TestSum #cTestSumA -$? TestSumA 42
Right 42
>>> first pretty $ unsafeUnwrap_ @TestSum #cTestSumA -$? TestSumB (False, ())
Left "Reached FAILWITH instruction with \"BadCtor\" at Error occurred on line 1 char 1."

wrapOne :: forall dt (name :: Symbol) (st :: [Type]). InstrWrapOneC dt name => Label name -> (CtorOnlyField name dt ': st) :-> (dt ': st) #

Wrap entry in single-field constructor. Useful for sum types.

>>> wrapOne @TestSum #cTestSumA -$ 42
TestSumA 42

wrap_ :: forall dt (name :: Symbol) (st :: [Type]). InstrWrapC dt name => Label name -> AppendCtorField (GetCtorField dt name) st :-> (dt ': st) #

Wrap entry in constructor. Useful for sum types.

>>> wrap_ @TestSum #cTestSumB -$ (False, ())
TestSumB (False,())

fieldCtor :: forall (st :: [Type]) f. HasCallStack => (st :-> (f ': st)) -> FieldConstructor st f #

Lift an instruction to field constructor.

deconstruct :: forall dt (fields :: [Type]) (st :: [Type]). (InstrDeconstructC dt (ToTs st), fields ~ GFieldTypes (Rep dt) ('[] :: [Type]), (ToTs fields ++ ToTs st) ~ ToTs (fields ++ st)) => (dt ': st) :-> (fields ++ st) #

Decompose a complex object into its fields

>>> deconstruct @TestProduct # constructStack @TestProduct -$ testProduct
TestProduct {fieldA = True, fieldB = 42, fieldC = ()}

constructStack :: forall dt (fields :: [Type]) (st :: [Type]). (InstrConstructC dt, fields ~ ConstructorFieldTypes dt, (ToTs fields ++ ToTs st) ~ ToTs (fields ++ st)) => (fields ++ st) :-> (dt ': st) #

Construct an object from fields on the stack.

>>> constructStack @TestProduct -$ True ::: 42 ::: ()
TestProduct {fieldA = True, fieldB = 42, fieldC = ()}

setFieldOpen :: forall dt (name :: Symbol) new (st :: [Type]). InstrSetFieldC dt name => ('[new, GetFieldType dt name] :-> '[GetFieldType dt name]) -> Label name -> (new ': (dt ': st)) :-> (dt ': st) #

"Open" version of setField, an advanced method suitable for chaining setters.

It accepts a continuation accepting the field extracted for the update and the new value that is being set. Normally this continuation is just setField for some nested field.

getFieldOpen :: forall dt (name :: Symbol) res (st :: [Type]). (InstrGetFieldC dt name, HasDupableGetters dt) => ('[GetFieldType dt name] :-> '[res, GetFieldType dt name]) -> ('[GetFieldType dt name] :-> '[res]) -> Label name -> (dt ': st) :-> (res ': (dt ': st)) #

"Open" version of getField, an advanced method suitable for chaining getters.

It accepts two continuations accepting the extracted field, one that leaves the field on stack (and does a duplication of res inside) and another one that consumes the field. Normally these are just getField and toField for some nested field.

Unlike the straightforward chaining of getField/toField methods, getFieldOpen does not require the immediate field to be dupable; rather, in the best case only res has to be dupable.

modifyField :: forall dt (name :: Symbol) (st :: [Type]). (InstrGetFieldC dt name, InstrSetFieldC dt name, Dupable (GetFieldType dt name), HasDupableGetters dt) => Label name -> (forall (st0 :: [Type]). (GetFieldType dt name ': st0) :-> (GetFieldType dt name ': st0)) -> (dt ': st) :-> (dt ': st) #

Apply given modifier to a datatype field.

>>> modifyField @TestProduct #fieldB (dup # mul) -$ testProduct { fieldB = 8 }
TestProduct {fieldA = True, fieldB = 64, fieldC = ()}

getFieldNamed :: forall dt (name :: Symbol) (st :: [Type]). (InstrGetFieldC dt name, Dupable (GetFieldType dt name), HasDupableGetters dt) => Label name -> (dt ': st) :-> ((name :! GetFieldType dt name) ': (dt ': st)) #

Like getField, but leaves field named.

getField :: forall dt (name :: Symbol) (st :: [Type]). (InstrGetFieldC dt name, Dupable (GetFieldType dt name), HasDupableGetters dt) => Label name -> (dt ': st) :-> (GetFieldType dt name ': (dt ': st)) #

Extract a field of a datatype, leaving the original datatype on stack.

>>> :{
 (getField @TestProduct #fieldB # L.swap # toField @TestProduct #fieldB # mul) -$
    testProduct { fieldB = 3 }
:}
9

toFieldNamed :: forall dt (name :: Symbol) (st :: [Type]). InstrGetFieldC dt name => Label name -> (dt ': st) :-> ((name :! GetFieldType dt name) ': st) #

Like toField, but leaves field named.

toField :: forall dt (name :: Symbol) (st :: [Type]). InstrGetFieldC dt name => Label name -> (dt ': st) :-> (GetFieldType dt name ': st) #

Extract a field of a datatype replacing the value of this datatype with the extracted field.

For this and the following functions you have to specify field name which is either record name or name attached with (:!) operator.

>>> :{
 (toField @TestProductWithNonDup #fieldTP -$ testProductWithNonDup) == testProduct
:}
True

type HasFieldOfType dt (fname :: Symbol) fieldTy = (HasField dt fname, GetFieldType dt fname ~ fieldTy) #

Like HasField, but allows constrainting field type.

data NamedField #

A pair of field name and type.

Constructors

NamedField Symbol Type

type (:=) (n :: Symbol) ty = 'NamedField n ty infixr 0 #

type family HasFieldsOfType dt (fs :: [NamedField]) where ... #

Shortcut for multiple HasFieldOfType constraints.

Equations

HasFieldsOfType _1 ('[] :: [NamedField]) = ()
HasFieldsOfType dt ((n := ty) ': fs) = (HasFieldOfType dt n ty, HasFieldsOfType dt fs)

class HasDupableGetters (a :: k) #

This marker typeclass is a requirement for the getField (where it is imposed on the datatype), and it is supposed to be satisfied in two cases:

The entire datatype is Dupable;
When the datatype has non-dupable fields, they are located so that getField remains efficient.

The problem we are trying to solve here: without special care, getField may become multiple times more costly, see instrGetField for the explanation. And this typeclass imposes an invariant: if we ever use getField on a datatype, then we have to pay attention to the datatype's Michelson representation and ensure getField remains optimal.

When you are developing a contract: Lorentz.Layouts.NonDupable module contains utilities to help you provide the necessary Michelson layout. In case you want to use your custom layout but still allow getField for it, you can define an instance for your type manually as an assurance that Michelson layout is optimal enough to use getField on this type.

When you are developing a library: Note that HasDupableGetters resolves to Dupable by default, and when propagating this constraint you can switch to Dupable anytime but this will also make your code unusable in the presence of Tickets and other non-dupable types.

Instances

Instances details

Dupable a => HasDupableGetters (a :: Type)
Instance details Defined in Lorentz.ADT

data CaseClauseL (inp :: [Type]) (out :: [Type]) (param :: CaseClauseParam) where #

Lorentz analogy of CaseClause, it works on plain Type types.

Constructors

CaseClauseL :: forall (x :: CtorField) (inp :: [Type]) (out :: [Type]) (ctor :: Symbol). (AppendCtorField x inp :-> out) -> CaseClauseL inp out ('CaseClauseParam ctor x)

Instances

Instances details

(name ~ AppendSymbol "c" ctor, body ~ (AppendCtorField x inp :-> out)) => CaseArrow name body (CaseClauseL inp out ('CaseClauseParam ctor x))
Instance details Defined in Lorentz.ADT Methods (/->) :: Label name -> body -> CaseClauseL inp out ('CaseClauseParam ctor x) #

class CaseArrow (name :: Symbol) body clause | clause -> name, clause -> body where #

Provides "case" arrow which works on different wrappers for clauses.

Methods

(/->) :: Label name -> body -> clause infixr 0 #

Lift an instruction to case clause.

You should write out constructor name corresponding to the clause explicitly. Prefix constructor name with "c" letter, otherwise your label will not be recognized by Haskell parser. Passing constructor name can be circumvented but doing so is not recomended as mentioning contructor name improves readability and allows avoiding some mistakes.

Instances

Instances details

(name ~ AppendSymbol "c" ctor, body ~ (AppendCtorField x inp :-> out)) => CaseArrow name body (CaseClauseL inp out ('CaseClauseParam ctor x))
Instance details Defined in Lorentz.ADT Methods (/->) :: Label name -> body -> CaseClauseL inp out ('CaseClauseParam ctor x) #
(name ~ name', body ~ ((arg ': inp) :-> out)) => CaseArrow name' body (CaseClauseU inp out '(name, arg))
Instance details Defined in Lorentz.UParam Methods (/->) :: Label name' -> body -> CaseClauseU inp out '(name, arg) #
(name ~ AppendSymbol "c" ctor, KnownValue x) => CaseArrow name (IndigoClause x ret) (IndigoCaseClauseL ret ('CaseClauseParam ctor ('OneField x))) Source #
Instance details Defined in Indigo.Backend.Case Methods (/->) :: Label name -> IndigoClause x ret -> IndigoCaseClauseL ret ('CaseClauseParam ctor ('OneField x)) #

type CaseTC dt (out :: [Type]) (inp :: [Type]) clauses = (InstrCaseC dt, RMap (CaseClauses dt), RecFromTuple clauses, clauses ~ Rec (CaseClauseL inp out) (CaseClauses dt)) #

errorToValNumeric :: IsError e => ErrorTagMap -> e -> (forall (t :: T). ConstantScope t => Value t -> r) -> r #

If you apply numeric error representation in your contract, errorToVal will stop working because it doesn't know about this transformation. This function takes this transformation into account. If a string is used as a tag, but it is not found in the passed map, we conservatively preserve that string (because this whole approach is rather a heuristic).

errorFromValNumeric :: forall (t :: T) e. (SingI t, IsError e) => ErrorTagMap -> Value t -> Either Text e #

If you apply numeric error representation in your contract, errorFromVal will stop working because it doesn't know about this transformation. This function takes this transformation into account. If a number is used as a tag, but it is not found in the passed map, we conservatively preserve that number (because this whole approach is rather a heuristic).

useNumericErrors :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => (inp :-> out) -> (inp :-> out, ErrorTagMap) #

This function implements the simplest scenario of using this module's functionality: 1. Gather all error tags from a single instruction. 2. Turn them into error conversion map. 3. Apply this conversion.

applyErrorTagMapWithExclusions :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => ErrorTagMap -> ErrorTagExclusions -> (inp :-> out) -> inp :-> out #

Similar to applyErrorTagMap, but for case when you have excluded some tags from map via excludeErrorTags. Needed, because both excludeErrorTags and this function do not tolerate unknown errors in contract code (for your safety).

applyErrorTagMap :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => ErrorTagMap -> (inp :-> out) -> inp :-> out #

For each typical FAILWITH that uses a string to represent error tag this function changes error tag to be a number using the supplied conversion map. It assumes that supplied map contains all such strings (and will error out if it does not). It will always be the case if you gather all error tags using gatherErrorTags and build ErrorTagMap from them using addNewErrorTags.

excludeErrorTags :: HasCallStack => ErrorTagExclusions -> ErrorTagMap -> ErrorTagMap #

Remove some error tags from map. This way you say to remain these string tags intact, while others will be converted to numbers when this map is applied.

Note that later you have to apply this map using applyErrorTagMapWithExclusions, otherwise an error would be raised.

buildErrorTagMap :: HashSet MText -> ErrorTagMap #

Build ErrorTagMap from a set of textual tags.

addNewErrorTags :: ErrorTagMap -> HashSet MText -> ErrorTagMap #

Add more error tags to an existing ErrorTagMap. It is useful when your contract consists of multiple parts (e. g. in case of contract upgrade), you have existing map for some part and want to add tags from another part to it. You can pass empty map as existing one if you just want to build ErrorTagMap from a set of textual tags. See buildErrorTagMap.

gatherErrorTags :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> HashSet MText #

Find all textual error tags that are used in typical FAILWITH patterns within given instruction. Map them to natural numbers.

type ErrorTagMap = Bimap Natural MText #

This is a bidirectional map with correspondence between numeric and textual error tags.

type ErrorTagExclusions = HashSet MText #

Tags excluded from map.

typeDoc :: QuasiQuoter #

QuasiQuote that helps generating TypeHasDoc instance.

Usage:

[typeDoc| <type> <description> [<field naming strategy>] |]
[typeDoc| Storage "This is storage description" |]
[typeDoc| Storage "This is storage description" stripFieldPrefix |]

field naming strategy is optional, and is a function with signature Text -> Text. Common strategies include id and stripFieldPrefix. If unspecified, ultimately defaults to id.

See this tutorial which includes this quasiquote.

errorDocArg :: QuasiQuoter #

QuasiQuote that helps generating CustomErrorHasDoc instance.

Usage:

[errorDocArg| <error-name> <error-type> <error-description> [<error-arg-type>] |]
[errorDocArg| "errorName" exception "Error description" |]
[errorDocArg| "errorName" contract-internal "Error description" () |]
[errorDocArg| "errorName" bad-argument "Error description" Integer |]

The default argument type is NoErrorArg. Only a type name can be used, if you need complex type, define a type synonym.

See this tutorial which includes this quasiquote.

entrypointDoc :: QuasiQuoter #

QuasiQuote that helps generating ParameterHasEntrypoints instance.

Usage:

[entrypointDoc| Parameter <parameter-type> [<root-annotation>] |]
[entrypointDoc| Parameter plain |]
[entrypointDoc| Parameter plain "root"|]

See this tutorial which includes this quasiquote.

typeDocMdDescriptionReferToError :: IsError e => Markdown #

Implementation of typeDocMdDescription (of TypeHasDoc typeclass) for Haskell types which sole purpose is to be error.

isInternalErrorClass :: ErrorClass -> Bool #

Whether given error class is about internal errors.

Internal errors are not enlisted on per-entrypoint basis, only once for the entire contract.

errorTagToText :: forall (tag :: Symbol). KnownSymbol tag => Text #

errorTagToMText :: forall (tag :: Symbol). Label tag -> MText #

Demote error tag to term level.

failUnexpected :: forall (s :: [Type]) (t :: [Type]). MText -> s :-> t #

Fail, providing a reference to the place in the code where this function is called.

Like error in Haskell code, this instruction is for internal errors only.

simpleFailUsing :: forall e (s :: [Type]) (t :: [Type]). IsError e => e -> s :-> t #

Basic implementation for failUsing.

isoErrorFromVal :: forall (t :: T) e. (SingI t, KnownIsoT e, IsoValue e) => Value t -> Either Text e #

Implementation of errorFromVal via IsoValue.

isoErrorToVal :: (KnownError e, IsoValue e) => e -> (forall (t :: T). ErrorScope t => Value t -> r) -> r #

Implementation of errorToVal via IsoValue.

type ErrorScope (t :: T) = ConstantScope t #

Since 008 it's prohibited to fail with non-packable values and with the 'Contract t' type values, which is equivalent to our ConstantScope constraint. See https://gitlab.com/tezos/tezos/-/issues/1093#note_496066354 for more information.

class ErrorHasDoc e => IsError e where #

Haskell type representing error.

Minimal complete definition

errorToVal, errorFromVal

Methods

errorToVal :: e -> (forall (t :: T). ErrorScope t => Value t -> r) -> r #

Converts a Haskell error into Value representation.

errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text e #

Converts a Value into Haskell error.

failUsing :: forall (s :: [Type]) (t :: [Type]). IsError e => e -> s :-> t #

Fail with the given Haskell value.

Instances

Instances details

IsError UnspecifiedError
Instance details Defined in Lorentz.Errors Methods errorToVal :: UnspecifiedError -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text UnspecifiedError # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError UnspecifiedError => UnspecifiedError -> s :-> t #
IsError MText	Use this for internal errors only. "Normal" error scenarios should use the mechanism of custom errors, see below.
Instance details Defined in Lorentz.Errors Methods errorToVal :: MText -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text MText # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError MText => MText -> s :-> t #
(Bottom, TypeError ('Text "Use representative error messages") :: Constraint) => IsError ()
Instance details Defined in Lorentz.Errors Methods errorToVal :: () -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text () # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError () => () -> s :-> t #
(CustomErrorHasDoc tag, KnownError (CustomErrorRep tag), IsoValue (CustomErrorRep tag), IsCustomErrorArgRep (CustomErrorRep tag)) => IsError (CustomError tag)
Instance details Defined in Lorentz.Errors Methods errorToVal :: CustomError tag -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text (CustomError tag) # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError (CustomError tag) => CustomError tag -> s :-> t #
KnownSymbol reason => IsError (Impossible reason)
Instance details Defined in Lorentz.Errors Methods errorToVal :: Impossible reason -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text (Impossible reason) # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError (Impossible reason) => Impossible reason -> s :-> t #
(NiceConstant r, ErrorHasDoc (VoidResult r)) => IsError (VoidResult r)
Instance details Defined in Lorentz.Macro Methods errorToVal :: VoidResult r -> (forall (t :: T). ErrorScope t => Value t -> r0) -> r0 # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text (VoidResult r) # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError (VoidResult r) => VoidResult r -> s :-> t #
(Typeable arg, IsError (CustomError tag), arg ~ ErrorArg tag, FailUnlessEqual arg () ('Text "This error requires argument of type " :<>: 'ShowType (ErrorArg tag))) => IsError (arg -> CustomError tag)	If `CustomError` constructor is not provided its argument, we assume that this is unit-arg error and interpret the passed value as complete.
Instance details Defined in Lorentz.Errors Methods errorToVal :: (arg -> CustomError tag) -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text (arg -> CustomError tag) # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError (arg -> CustomError tag) => (arg -> CustomError tag) -> s :-> t #

type family ErrorRequirements e #

Constraints which we require in a particular instance. You are not oblidged to often instantiate this correctly, it is only useful for some utilities.

Instances

Instances details

type ErrorRequirements UnspecifiedError
Instance details Defined in Lorentz.Errors type ErrorRequirements UnspecifiedError = ()
type ErrorRequirements NumericTextError
Instance details Defined in Lorentz.Errors.Numeric.Doc type ErrorRequirements NumericTextError = ()
type ErrorRequirements MText
Instance details Defined in Lorentz.Errors type ErrorRequirements MText = ()
type ErrorRequirements ()
Instance details Defined in Lorentz.Errors type ErrorRequirements () = ()
type ErrorRequirements (CustomError tag)
Instance details Defined in Lorentz.Errors type ErrorRequirements (CustomError tag) = (CustomErrorHasDoc tag, IsCustomErrorArgRep (CustomErrorRep tag))
type ErrorRequirements (Impossible reason)
Instance details Defined in Lorentz.Errors type ErrorRequirements (Impossible reason) = ()
type ErrorRequirements (VoidResult r)
Instance details Defined in Lorentz.Macro type ErrorRequirements (VoidResult r) = ()
type ErrorRequirements (NumericErrorWrapper numTag err)
Instance details Defined in Lorentz.Errors.Numeric.Doc type ErrorRequirements (NumericErrorWrapper numTag err) = ()
type ErrorRequirements (arg -> CustomError tag)
Instance details Defined in Lorentz.Errors type ErrorRequirements (arg -> CustomError tag) = ()

class Typeable e => ErrorHasDoc e where #

Minimal complete definition

errorDocName, errorDocMdCause, errorDocHaskellRep, errorDocDependencies

Associated Types

type ErrorRequirements e #

Constraints which we require in a particular instance. You are not oblidged to often instantiate this correctly, it is only useful for some utilities.

type ErrorRequirements e = ()

Methods

errorDocName :: Text #

Name of error as it appears in the corresponding section title.

errorDocMdCause :: Markdown #

What should happen for this error to be raised.

errorDocMdCauseInEntrypoint :: Markdown #

Brief version of errorDocMdCause.

This will appear along with the error when mentioned in entrypoint description. By default, the first sentence of the full description is used.

errorDocHaskellRep :: Markdown #

How this error is represented in Haskell.

errorDocClass :: ErrorClass #

Error class.

errorDocDependencies :: [SomeDocDefinitionItem] #

Which definitions documentation for this error mentions.

errorDocRequirements :: Dict (ErrorRequirements e) #

Captured constraints which we require in a particular instance. This is a way to encode a bidirectional instance in the nowaday Haskell, for class MyConstraint => ErrorHasDoc MyType instance it lets deducing MyConstraint by ErrorHasDoc MyType.

You are not oblidged to always instantiate, it is only useful for some utilities which otherwise would not compile.

Instances

Instances details

ErrorHasDoc UnspecifiedError
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements UnspecifiedError # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements UnspecifiedError) #
ErrorHasDoc NumericTextError
Instance details Defined in Lorentz.Errors.Numeric.Doc Associated Types type ErrorRequirements NumericTextError # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements NumericTextError) #
ErrorHasDoc MText
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements MText # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements MText) #
(Bottom, TypeError ('Text "Use representative error messages") :: Constraint) => ErrorHasDoc ()
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements () # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements ()) #
(CustomErrorHasDoc tag, IsCustomErrorArgRep (CustomErrorRep tag)) => ErrorHasDoc (CustomError tag)
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements (CustomError tag) # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements (CustomError tag)) #
KnownSymbol reason => ErrorHasDoc (Impossible reason)
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements (Impossible reason) # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements (Impossible reason)) #
TypeHasDoc r => ErrorHasDoc (VoidResult r)
Instance details Defined in Lorentz.Macro Associated Types type ErrorRequirements (VoidResult r) # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements (VoidResult r)) #
(ErrorHasDoc err, KnownNat numTag, ErrorHasNumericDoc err) => ErrorHasDoc (NumericErrorWrapper numTag err)
Instance details Defined in Lorentz.Errors.Numeric.Doc Associated Types type ErrorRequirements (NumericErrorWrapper numTag err) # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements (NumericErrorWrapper numTag err)) #
(Typeable arg, ErrorHasDoc (CustomError tag)) => ErrorHasDoc (arg -> CustomError tag)
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements (arg -> CustomError tag) # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements (arg -> CustomError tag)) #

data UnspecifiedError #

Use this type as replacement for () when you really want to leave error cause unspecified.

Constructors

UnspecifiedError

Instances

Instances details

Generic UnspecifiedError
Instance details Defined in Lorentz.Errors Associated Types type Rep UnspecifiedError :: Type -> Type # Methods from :: UnspecifiedError -> Rep UnspecifiedError x # to :: Rep UnspecifiedError x -> UnspecifiedError #
ErrorHasDoc UnspecifiedError
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements UnspecifiedError # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements UnspecifiedError) #
IsError UnspecifiedError
Instance details Defined in Lorentz.Errors Methods errorToVal :: UnspecifiedError -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text UnspecifiedError # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError UnspecifiedError => UnspecifiedError -> s :-> t #
IsoValue UnspecifiedError
Instance details Defined in Lorentz.Errors Associated Types type ToT UnspecifiedError :: T # Methods toVal :: UnspecifiedError -> Value (ToT UnspecifiedError) # fromVal :: Value (ToT UnspecifiedError) -> UnspecifiedError #
type Rep UnspecifiedError
Instance details Defined in Lorentz.Errors type Rep UnspecifiedError = D1 ('MetaData "UnspecifiedError" "Lorentz.Errors" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'False) (C1 ('MetaCons "UnspecifiedError" 'PrefixI 'False) (U1 :: Type -> Type))
type ErrorRequirements UnspecifiedError
Instance details Defined in Lorentz.Errors type ErrorRequirements UnspecifiedError = ()
type ToT UnspecifiedError
Instance details Defined in Lorentz.Errors type ToT UnspecifiedError = GValueType (Rep UnspecifiedError)

data Impossible (reason :: Symbol) #

Use this error when sure that failing at the current position is possible in no curcumstances (including invalid user input or misconfigured storage).

To use this as error, you have to briefly specify the reason why the error scenario is impossible (experimental feature).

Constructors

HasCallStack => Impossible

Instances

Instances details

KnownSymbol reason => ErrorHasDoc (Impossible reason)
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements (Impossible reason) # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements (Impossible reason)) #
KnownSymbol reason => IsError (Impossible reason)
Instance details Defined in Lorentz.Errors Methods errorToVal :: Impossible reason -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text (Impossible reason) # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError (Impossible reason) => Impossible reason -> s :-> t #
type ErrorRequirements (Impossible reason)
Instance details Defined in Lorentz.Errors type ErrorRequirements (Impossible reason) = ()

data SomeError #

Type wrapper for an IsError.

Constructors

(IsError e, Eq e) => SomeError e

Instances

Instances details

Buildable SomeError
Instance details Defined in Lorentz.Errors Methods build :: SomeError -> Builder #
Eq SomeError
Instance details Defined in Lorentz.Errors Methods (==) :: SomeError -> SomeError -> Bool # (/=) :: SomeError -> SomeError -> Bool #

type family ErrorArg (tag :: Symbol) #

Declares a custom error, defining error name - error argument relation.

If your error is supposed to carry no argument, then provide ().

Note that this relation is defined globally rather than on per-contract basis, so define errors accordingly. If your error has argument specific to your contract, call it such that error name reflects its belonging to this contract.

This is the basic [error format].

Instances

Instances details

type ErrorArg "no_view"
Instance details Defined in Lorentz.Macro type ErrorArg "no_view" = MText
type ErrorArg "uparamArgumentUnpackFailed"
Instance details Defined in Lorentz.UParam type ErrorArg "uparamArgumentUnpackFailed" = UnitErrorArg
type ErrorArg "uparamNoSuchEntrypoint"
Instance details Defined in Lorentz.UParam type ErrorArg "uparamNoSuchEntrypoint" = MText

data CustomError (tag :: Symbol) #

Material custom error.

Use this in pattern matches against error (e.g. in tests).

Constructors

CustomError
Fields ceTag :: Label tag ceArg :: CustomErrorRep tag

Instances

Instances details

Show (CustomErrorRep tag) => Show (CustomError tag)
Instance details Defined in Lorentz.Errors Methods showsPrec :: Int -> CustomError tag -> ShowS # show :: CustomError tag -> String # showList :: [CustomError tag] -> ShowS #
Buildable (CustomError tag)
Instance details Defined in Lorentz.Errors Methods build :: CustomError tag -> Builder #
Eq (CustomErrorRep tag) => Eq (CustomError tag)
Instance details Defined in Lorentz.Errors Methods (==) :: CustomError tag -> CustomError tag -> Bool # (/=) :: CustomError tag -> CustomError tag -> Bool #
(CustomErrorHasDoc tag, IsCustomErrorArgRep (CustomErrorRep tag)) => ErrorHasDoc (CustomError tag)
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements (CustomError tag) # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements (CustomError tag)) #
(CustomErrorHasDoc tag, KnownError (CustomErrorRep tag), IsoValue (CustomErrorRep tag), IsCustomErrorArgRep (CustomErrorRep tag)) => IsError (CustomError tag)
Instance details Defined in Lorentz.Errors Methods errorToVal :: CustomError tag -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text (CustomError tag) # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError (CustomError tag) => CustomError tag -> s :-> t #
ErrorHasNumericDoc (CustomError tag)
Instance details Defined in Lorentz.Errors.Numeric.Doc Methods numericErrorDocHaskellRep :: Text -> Markdown numericErrorDocTextualTag :: Text
(Bottom, WellTypedToT (CustomErrorRep tag), TypeError ('Text "CustomError has no IsoValue instance") :: Constraint) => IsoValue (CustomError tag)	This instance cannot be implemented, use `IsError` instance instead.
Instance details Defined in Lorentz.Errors Associated Types type ToT (CustomError tag) :: T # Methods toVal :: CustomError tag -> Value (ToT (CustomError tag)) # fromVal :: Value (ToT (CustomError tag)) -> CustomError tag #
(Typeable arg, ErrorHasDoc (CustomError tag)) => ErrorHasDoc (arg -> CustomError tag)
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements (arg -> CustomError tag) # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements (arg -> CustomError tag)) #
(Typeable arg, IsError (CustomError tag), arg ~ ErrorArg tag, FailUnlessEqual arg () ('Text "This error requires argument of type " :<>: 'ShowType (ErrorArg tag))) => IsError (arg -> CustomError tag)	If `CustomError` constructor is not provided its argument, we assume that this is unit-arg error and interpret the passed value as complete.
Instance details Defined in Lorentz.Errors Methods errorToVal :: (arg -> CustomError tag) -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text (arg -> CustomError tag) # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError (arg -> CustomError tag) => (arg -> CustomError tag) -> s :-> t #
type ErrorRequirements (CustomError tag)
Instance details Defined in Lorentz.Errors type ErrorRequirements (CustomError tag) = (CustomErrorHasDoc tag, IsCustomErrorArgRep (CustomErrorRep tag))
type ToT (CustomError tag)
Instance details Defined in Lorentz.Errors type ToT (CustomError tag) = ToT (CustomErrorRep tag)
type ErrorRequirements (arg -> CustomError tag)
Instance details Defined in Lorentz.Errors type ErrorRequirements (arg -> CustomError tag) = ()

data NoErrorArg #

To be used as ErrorArg instance when failing with just a string instead of pair string x

data UnitErrorArg #

To be used as ErrorArg instances. This is equivalent to using () but using UnitErrorArg is preferred since () behavior could be changed in the future.

type CustomErrorRep (tag :: Symbol) = CustomErrorArgRep (ErrorArg tag) #

How CustomError is actually represented in Michelson.

class IsCustomErrorArgRep a where #

Typeclass implements various method that work with CustomErrorArgRep.

Methods

verifyErrorTag :: MText -> a -> Either Text a #

customErrorRepDocDeps :: [SomeDocDefinitionItem] #

customErrorHaskellRep :: forall (tag :: Symbol). (KnownSymbol tag, CustomErrorHasDoc tag) => Proxy tag -> Markdown #

Instances

Instances details

IsCustomErrorArgRep MText
Instance details Defined in Lorentz.Errors Methods verifyErrorTag :: MText -> MText -> Either Text MText # customErrorRepDocDeps :: [SomeDocDefinitionItem] # customErrorHaskellRep :: forall (tag :: Symbol). (KnownSymbol tag, CustomErrorHasDoc tag) => Proxy tag -> Markdown #
TypeHasDoc errArg => IsCustomErrorArgRep (MText, errArg)
Instance details Defined in Lorentz.Errors Methods verifyErrorTag :: MText -> (MText, errArg) -> Either Text (MText, errArg) # customErrorRepDocDeps :: [SomeDocDefinitionItem] # customErrorHaskellRep :: forall (tag :: Symbol). (KnownSymbol tag, CustomErrorHasDoc tag) => Proxy tag -> Markdown #

type MustHaveErrorArg (errorTag :: Symbol) expectedArgRep = FailUnlessEqual (CustomErrorRep errorTag) expectedArgRep ((('Text "Error argument type is " :<>: 'ShowType expectedArgRep) :<>: 'Text " but given error requires argument of type ") :<>: 'ShowType (CustomErrorRep errorTag)) #

data ErrorClass #

Error class on how the error should be handled by the client.

Constructors

ErrClassActionException	Normal expected error. Examples: "insufficient balance", "wallet does not exist".
ErrClassBadArgument	Invalid argument passed to entrypoint. Examples: your entrypoint accepts an enum represented as `nat`, and unknown value is provided. This includes more complex cases which involve multiple entrypoints. E.g. API provides iterator interface, middleware should care about using it hiding complex details and exposing a simpler API to user; then an attempt to request non-existing element would also correspond to an error from this class.
ErrClassContractInternal	Unexpected error. Most likely it means that there is a bug in the contract or the contract has been deployed incorrectly.
ErrClassUnknown	It's possible to leave error class unspecified.

Instances

Instances details

Buildable ErrorClass
Instance details Defined in Lorentz.Errors Methods build :: ErrorClass -> Builder #
Lift ErrorClass
Instance details Defined in Lorentz.Errors Methods lift :: Quote m => ErrorClass -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => ErrorClass -> Code m ErrorClass #

class (KnownSymbol tag, TypeHasDoc (CustomErrorRep tag), IsError (CustomError tag)) => CustomErrorHasDoc (tag :: Symbol) where #

Minimal complete definition

customErrDocMdCause, customErrClass

Methods

customErrDocMdCause :: Markdown #

What should happen for this error to be raised.

customErrDocMdCauseInEntrypoint :: Markdown #

Brief version of customErrDocMdCause. This will appear along with the error when mentioned in entrypoint description.

By default, the first sentence of the full description is used.

customErrClass :: ErrorClass #

Error class.

By default this returns "unknown error" class; though you should provide explicit implementation in order to avoid a warning.

customErrArgumentSemantics :: Maybe Markdown #

Clarification of error argument meaning.

Provide when it's not obvious, e.g. argument is not named with :!.

NOTE: This should not be an entire sentence, rather just the semantic backbone.

Bad: * Error argument stands for the previous value of approval.

Good: * the previous value of approval * pair, first argument of which is one thing, and the second is another

data DError where #

Mentions that contract uses given error.

Constructors

DError :: forall e. ErrorHasDoc e => Proxy e -> DError

Instances

Instances details

Eq DError
Instance details Defined in Lorentz.Errors Methods (==) :: DError -> DError -> Bool # (/=) :: DError -> DError -> Bool #
Ord DError
Instance details Defined in Lorentz.Errors Methods compare :: DError -> DError -> Ordering # (<) :: DError -> DError -> Bool # (<=) :: DError -> DError -> Bool # (>) :: DError -> DError -> Bool # (>=) :: DError -> DError -> Bool # max :: DError -> DError -> DError # min :: DError -> DError -> DError #
DocItem DError
Instance details Defined in Lorentz.Errors Associated Types type DocItemPlacement DError :: DocItemPlacementKind # type DocItemReferenced DError :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DError -> DocItemRef (DocItemPlacement DError) (DocItemReferenced DError) # docItemToMarkdown :: HeaderLevel -> DError -> Markdown # docItemToToc :: HeaderLevel -> DError -> Markdown # docItemDependencies :: DError -> [SomeDocDefinitionItem] # docItemsOrder :: [DError] -> [DError] #
type DocItemPlacement DError
Instance details Defined in Lorentz.Errors type DocItemPlacement DError = 'DocItemInDefinitions
type DocItemReferenced DError
Instance details Defined in Lorentz.Errors type DocItemReferenced DError = 'True

data DThrows where #

Documentation for custom errors.

Mentions that entrypoint throws given error.

Constructors

DThrows :: forall e. ErrorHasDoc e => Proxy e -> DThrows

Instances

Instances details

Eq DThrows
Instance details Defined in Lorentz.Errors Methods (==) :: DThrows -> DThrows -> Bool # (/=) :: DThrows -> DThrows -> Bool #
DocItem DThrows
Instance details Defined in Lorentz.Errors Associated Types type DocItemPlacement DThrows :: DocItemPlacementKind # type DocItemReferenced DThrows :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DThrows -> DocItemRef (DocItemPlacement DThrows) (DocItemReferenced DThrows) # docItemToMarkdown :: HeaderLevel -> DThrows -> Markdown # docItemToToc :: HeaderLevel -> DThrows -> Markdown # docItemDependencies :: DThrows -> [SomeDocDefinitionItem] # docItemsOrder :: [DThrows] -> [DThrows] #
type DocItemPlacement DThrows
Instance details Defined in Lorentz.Errors type DocItemPlacement DThrows = 'DocItemInlined
type DocItemReferenced DThrows
Instance details Defined in Lorentz.Errors type DocItemReferenced DThrows = 'False

dropT :: forall a (inp :: [Type]) (dinp :: [Type]) (dout :: [Type]) (out :: [Type]). (DipT a inp dinp dout out, dinp ~ (a ': dout)) => inp :-> out #

Remove element with the given type from the stack.

>>> :{
dropSample1 :: [Integer, (), Natural] :-> [Integer, Natural]
dropSample1 = dropT @()
:}

>>> pretty $ dropSample1 # zipInstr -$ 123 ::: () ::: 321
123 : 321

>>> :{
dropSampleErr1 :: [Integer, Natural] :-> [Integer, Natural]
dropSampleErr1 = dropT @()
:}
...
... • Element of type '()' is not present on stack
...   '[Integer, Natural]
...

>>> :{
dropSampleErr1 :: [Integer, Integer] :-> '[Integer]
dropSampleErr1 = dropT @Integer
:}
...
... • Ambiguous reference to element of type 'Integer' for stack
...   '[Integer, Integer]
...

class st ~ (Head st ': Tail st) => DupT a (st :: [Type]) where #

Allows duplicating stack elements referring them by type.

>>> :{
dupSample1 :: [Integer, MText, ()] :-> [MText, Integer, MText, ()]
dupSample1 = dupT @MText
:}

>>> pretty $ dupSample1 # zipInstr -$ 123 ::: [mt|Hello|] ::: ()
Hello : 123 : Hello : ()

>>> :{
dupSample2 :: [Integer, MText, ()] :-> [MText, Integer, MText, ()]
dupSample2 = dupT
:}

>>> pretty $ dupSample2 # zipInstr -$ 123 ::: [mt|Hello|] ::: ()
Hello : 123 : Hello : ()

>>> :{
dupSampleErr1 :: '[] :-> a
dupSampleErr1 = dupT @Bool
:}
...
... • Element of type 'Bool' is not present on stack
...   '[]
...

>>> :{
-- Should fully infer both wildcards
dupSampleErr2 :: _ :-> [Bool, Integer, _, ()]
dupSampleErr2 = dupT
:}
...
... • Found type wildcard ‘_’
...    standing for ‘'[Integer, Bool, ()] :: [*]’
...
... • Found type wildcard ‘_’ standing for ‘Bool’
...   To use the inferred type, enable PartialTypeSignatures
...

>>> :{
-- Should fully infer both wildcards
_dupSampleErr3 :: [Integer, _, ()] :-> (Bool ': _)
_dupSampleErr3 = dupT
:}
...
... • Found type wildcard ‘_’ standing for ‘Bool’
...
... • Found type wildcard ‘_’
...     standing for ‘'[Integer, Bool, ()] :: [*]’
...

Methods

dupT :: st :-> (a ': st) #

Duplicate an element of stack referring it by type.

If stack contains multiple entries of this type, compile error is raised.

Instances

Instances details

(EnsureElem a st, TheOnlyC (StackElemNotFound st a) (StackElemAmbiguous st a) (FindIndices (DefaultEqSym1 a) st) indexGHC, succ_index ~ 'S (ToPeano indexGHC), ConstraintDUPNLorentz succ_index st (a ': st) a, Dupable a) => DupT a st
Instance details Defined in Lorentz.Referenced Methods dupT :: st :-> (a ': st) #

class dipInp ~ (a ': Tail dipInp) => DipT a (inp :: [Type]) (dipInp :: [Type]) (dipOut :: [Type]) (out :: [Type]) | inp a -> dipInp, dipOut inp a -> out, inp out a -> dipOut where #

Allows diving into stack referring expected new tip by type.

>>> :{
dipSample1
  :: [Natural, ()] :-> '[()]
  -> [Integer, MText, Natural, ()] :-> [Integer, MText, ()]
dipSample1 = dipT @Natural
:}

>>> pretty $ dipSample1 drop # zipInstr -$ 123 ::: [mt|Hello|] ::: 321 ::: ()
123 : Hello : ()

>>> :{
dipSample2
  :: [Natural, ()] :-> '[()]
  -> [Integer, MText, Natural, ()] :-> [Integer, MText, ()]
dipSample2 = dipT -- No type application needed
:}

>>> pretty $ dipSample2 drop # zipInstr -$ 123 ::: [mt|Hello|] ::: 321 ::: ()
123 : Hello : ()

>>> :{
-- An implementation of dropT that demands a bit more from inference.
dipSample3
  :: forall a inp dinp dout out.
     ( DipT a inp dinp dout out
     , dinp ~ (a ': dout)
     )
  => inp :-> out
dipSample3 = dipT (drop @a)
:}

>>> :{
pretty $ dipSample3 @Natural @'[Integer, MText, Natural, ()] # zipInstr
  -$ 123 ::: [mt|Hello|] ::: 321 ::: ()
:}
123 : Hello : ()

>>> :{
_dipSampleErr1
  :: [Natural, ()] :-> '[()]
  -> [Integer, MText, ()] :-> [Integer, MText, ()]
_dipSampleErr1 = dipT @Natural
:}
...
... • Element of type 'Natural' is not present on stack
...   '[Integer, MText, ()]
...

>>> :{
_dipSampleErr2
  :: [Natural, ()] :-> '[()]
  -> [Integer, MText, Natural, (), Natural] :-> [Integer, MText, ()]
_dipSampleErr2 = dipT @Natural
:}
...
... • Ambiguous reference to element of type 'Natural' for stack
...   '[Integer, MText, Natural, (), Natural]
...

>>> :{
_dipSampleErr3
  :: '[] :-> '[()]
  -> [Integer, MText, Natural, ()] :-> [Integer, MText, ()]
_dipSampleErr3 = dipT @Natural
:}
...
... • dipT requires a Lorentz instruction that takes input on the stack.
...

Methods

dipT :: (dipInp :-> dipOut) -> inp :-> out #

Dip down until an element of the given type is on top of the stack.

If the stack does not contain an element of this type, or contains more than one, then a compile-time error is raised.

Instances

Instances details

(dipInp ~ (a ': tail_dipInp), EnsureElem a inp, RequireNonEmpty ('Text "dipT requires a Lorentz instruction that takes input on the stack.") dipInp, TheOnlyC (StackElemNotFound inp a) (StackElemAmbiguous inp a) (FindIndices (DefaultEqSym1 a) inp) indexGHC, index ~ ToPeano indexGHC, ConstraintDIPNLorentz index inp out dipInp dipOut) => DipT a inp dipInp dipOut out
Instance details Defined in Lorentz.Referenced Methods dipT :: (dipInp :-> dipOut) -> inp :-> out #

mkLambdaRec :: forall (i :: [Type]) (o :: [Type]). (IsNotInView => (i ++ '[WrappedLambda i o]) :-> o) -> WrappedLambda i o #

A constructor providing the required constraint for WrappedLambda. This is the only way to construct a lambda that uses operations forbidden in views.

mkLambda :: forall (i :: [Type]) (o :: [Type]). (IsNotInView => i :-> o) -> WrappedLambda i o #

A constructor providing the required constraint for WrappedLambda. This is the only way to construct a lambda that uses operations forbidden in views.

data WrappedLambda (i :: [Type]) (o :: [Type]) #

A helper type to construct Lorentz lambda values; Use this for lambda values outside of Lorentz contracts or with push.

Constructors

WrappedLambda (i :-> o)
RecLambda ((i ++ '[WrappedLambda i o]) :-> o)

Instances

Instances details

(CanCastTo (ZippedStack inp1) (ZippedStack inp2), CanCastTo (ZippedStack out1) (ZippedStack out2), CanCastTo (ZippedStack (inp1 ++ '[WrappedLambda inp1 out1])) (ZippedStack (inp2 ++ '[WrappedLambda inp2 out2]))) => CanCastTo (WrappedLambda inp1 out1 :: Type) (WrappedLambda inp2 out2 :: Type)
Instance details Defined in Lorentz.Lambda Methods castDummy :: Proxy (WrappedLambda inp1 out1) -> Proxy (WrappedLambda inp2 out2) -> () #
Generic (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Associated Types type Rep (WrappedLambda i o) :: Type -> Type # Methods from :: WrappedLambda i o -> Rep (WrappedLambda i o) x # to :: Rep (WrappedLambda i o) x -> WrappedLambda i o #
Show (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Methods showsPrec :: Int -> WrappedLambda i o -> ShowS # show :: WrappedLambda i o -> String # showList :: [WrappedLambda i o] -> ShowS #
Eq (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Methods (==) :: WrappedLambda i o -> WrappedLambda i o -> Bool # (/=) :: WrappedLambda i o -> WrappedLambda i o -> Bool #
Each '[HasAnnotation] '[ZippedStack i, ZippedStack o] => HasAnnotation (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (WrappedLambda i o)) # annOptions :: Maybe AnnOptions #
MapLorentzInstr (WrappedLambda inp out)
Instance details Defined in Lorentz.Lambda Methods mapLorentzInstr :: (forall (i :: [Type]) (o :: [Type]). (i :-> o) -> i :-> o) -> WrappedLambda inp out -> WrappedLambda inp out #
HasRPCRepr (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Associated Types type AsRPC (WrappedLambda i o) #
Each '[Typeable :: [Type] -> Constraint, ReifyList TypeHasDoc] '[i, o] => TypeHasDoc (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Associated Types type TypeDocFieldDescriptions (WrappedLambda i o) :: FieldDescriptions # Methods typeDocName :: Proxy (WrappedLambda i o) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (WrappedLambda i o) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (WrappedLambda i o) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (WrappedLambda i o) # typeDocMichelsonRep :: TypeDocMichelsonRep (WrappedLambda i o) #
(KnownList i, ZipInstr i, ZipInstr o) => IsoValue (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Associated Types type ToT (WrappedLambda i o) :: T # Methods toVal :: WrappedLambda i o -> Value (ToT (WrappedLambda i o)) # fromVal :: Value (ToT (WrappedLambda i o)) -> WrappedLambda i o #
type Rep (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda type Rep (WrappedLambda i o) = D1 ('MetaData "WrappedLambda" "Lorentz.Lambda" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'False) (C1 ('MetaCons "WrappedLambda" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (i :-> o))) :+: C1 ('MetaCons "RecLambda" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ((i ++ '[WrappedLambda i o]) :-> o))))
type AsRPC (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda type AsRPC (WrappedLambda i o) = WrappedLambda i o
type TypeDocFieldDescriptions (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda type TypeDocFieldDescriptions (WrappedLambda i o) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda type ToT (WrappedLambda i o) = 'TLambda (ToT (ZippedStack i)) (ToT (ZippedStack o))

type Lambda i o = WrappedLambda '[i] '[o] #

A type synonym representing Michelson lambdas.

castDummyG :: (Generic a, Generic b, GCanCastTo (Rep a) (Rep b)) => Proxy a -> Proxy b -> () #

Implementation of castDummy for types composed from smaller types. It helps to ensure that all necessary constraints are requested in instance head.

allowCheckedCoerce :: forall {k1} {k2} (a :: k1) (b :: k2). Dict (CanCastTo a b, CanCastTo b a) #

Locally provide bidirectional CanCastTo instance.

allowCheckedCoerceTo :: forall {k1} {k2} (b :: k1) (a :: k2). Dict (CanCastTo a b) #

Locally provide given CanCastTo instance.

checkedCoercing_ :: forall a b (s :: [Type]). Coercible_ a b => ((b ': s) :-> (b ': s)) -> (a ': s) :-> (a ': s) #

Pretends that the top item of the stack was coerced.

checkedCoerce_ :: forall a b (s :: [Type]). Castable_ a b => (a ': s) :-> (b ': s) #

Coerce between types which have an explicit permission for that in the face of CanCastTo constraint.

checkedCoerce :: (CanCastTo a b, Coercible a b) => a -> b #

Coercion in Haskell world which respects CanCastTo.

fromNamed :: forall (name :: Symbol) a (s :: [Type]). Label name -> ((name :! a) ': s) :-> (a ': s) #

Unpack named value.

toNamed :: forall (name :: Symbol) a (s :: [Type]). Label name -> (a ': s) :-> ((name :! a) ': s) #

Lift given value to a named value.

coerceWrap :: forall a (s :: [Type]). Wrappable a => (Unwrappabled a ': s) :-> (a ': s) #

Specialized version of forcedCoerce_ to wrap into a haskell newtype.

Requires Wrappable constraint.

unsafeCoerceWrap :: forall a (s :: [Type]). Unwrappable a => (Unwrappabled a ': s) :-> (a ': s) #

Specialized version of forcedCoerce_ to wrap a haskell newtype.

Works under Unwrappable constraint, thus is not safe.

coerceUnwrap :: forall a (s :: [Type]). Unwrappable a => (a ': s) :-> (Unwrappabled a ': s) #

Specialized version of forcedCoerce_ to unwrap a haskell newtype.

fakeCoercing :: forall (s1 :: [Type]) (s2 :: [Type]) (s1' :: [Type]) (s2' :: [Type]). (s1 :-> s2) -> s1' :-> s2' #

fakeCoerce :: forall (s1 :: [Type]) (s2 :: [Type]). s1 :-> s2 #

Convert between two stacks via failing.

gForcedCoerce_ :: forall {k} t (a :: k) (b :: k) (s :: [Type]). MichelsonCoercible (t a) (t b) => (t a ': s) :-> (t b ': s) #

forcedCoerce_ :: forall a b (s :: [Type]). MichelsonCoercible a b => (a ': s) :-> (b ': s) #

Convert between values of types that have the same representation.

This function is not safe in a sense that this allows * breaking invariants of casted type (example: UStore from morley-upgradeable), or * may stop compile on code changes (example: coercion of pair to a datatype with two fields will break if new field is added). Still, produced Michelson code will always be valid.

Prefer using one of more specific functions from this module.

type MichelsonCoercible a b = ToT a ~ ToT b #

Whether two types have the same Michelson representation.

class CanCastTo (a :: k) (b :: k1) where #

Explicitly allowed coercions.

a CanCastTo b proclaims that a can be casted to b without violating any invariants of b.

This relation is reflexive; it may be symmetric or not. It tends to be composable: casting complex types usually requires permission to cast their respective parts; for such types consider using castDummyG as implementation of the method of this typeclass.

For cases when a cast from a to b requires some validation, consider rather making a dedicated function which performs the necessary checks and then calls forcedCoerce.

Minimal complete definition

Nothing

Methods

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

An optional method which helps passing -Wredundant-constraints check. Also, you can set specific implementation for it with specific sanity checks.

Instances

Instances details

CanCastTo (a :: k) (a :: k)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy a -> Proxy a -> () #
CanCastTo Address (TAddress p vd :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy Address -> Proxy (TAddress p vd) -> () #
CanCastTo (TAddress p vd :: Type) Address
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (TAddress p vd) -> Proxy Address -> () #
CanCastTo (FutureContract p :: Type) EpAddress
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (FutureContract p) -> Proxy EpAddress -> () #
CanCastTo (Packed a :: Type) ByteString
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Packed a) -> Proxy ByteString -> () #
CanCastTo (TSignature a :: Type) ByteString
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (TSignature a) -> Proxy ByteString -> () #
CanCastTo k1 k2 => CanCastTo (Set k1 :: Type) (Set k2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Set k1) -> Proxy (Set k2) -> () #
CanCastTo a b => CanCastTo (Packed a :: Type) (Packed b :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Packed a) -> Proxy (Packed b) -> () #
CanCastTo a b => CanCastTo (TSignature a :: Type) (TSignature b :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (TSignature a) -> Proxy (TSignature b) -> () #
SameEntries entries1 entries2 => CanCastTo (UParam entries1 :: Type) (UParam entries2 :: Type)	Allows casts only between `UParam_` and `UParam`.
Instance details Defined in Lorentz.UParam Methods castDummy :: Proxy (UParam entries1) -> Proxy (UParam entries2) -> () #
CanCastTo a1 a2 => CanCastTo (ContractRef a1 :: Type) (ContractRef a2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (ContractRef a1) -> Proxy (ContractRef a2) -> () #
CanCastTo a b => CanCastTo (Maybe a :: Type) (Maybe b :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Maybe a) -> Proxy (Maybe b) -> () #
CanCastTo a b => CanCastTo ([a] :: Type) ([b] :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy [a] -> Proxy [b] -> () #
CanCastTo (Hash alg a :: Type) ByteString
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Hash alg a) -> Proxy ByteString -> () #
(CanCastTo l1 l2, CanCastTo r1 r2) => CanCastTo (Either l1 r1 :: Type) (Either l2 r2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Either l1 r1) -> Proxy (Either l2 r2) -> () #
(CanCastTo k1 k2, CanCastTo v1 v2) => CanCastTo (Map k1 v1 :: Type) (Map k2 v2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Map k1 v1) -> Proxy (Map k2 v2) -> () #
(CanCastTo (ZippedStack i1) (ZippedStack i2), CanCastTo (ZippedStack o1) (ZippedStack o2)) => CanCastTo (i1 :-> o1 :: Type) (i2 :-> o2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (i1 :-> o1) -> Proxy (i2 :-> o2) -> () #
(CanCastTo alg1 alg2, CanCastTo a1 a2) => CanCastTo (Hash alg1 a1 :: Type) (Hash alg2 a2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Hash alg1 a1) -> Proxy (Hash alg2 a2) -> () #
(CanCastTo (ZippedStack inp1) (ZippedStack inp2), CanCastTo (ZippedStack out1) (ZippedStack out2), CanCastTo (ZippedStack (inp1 ++ '[WrappedLambda inp1 out1])) (ZippedStack (inp2 ++ '[WrappedLambda inp2 out2]))) => CanCastTo (WrappedLambda inp1 out1 :: Type) (WrappedLambda inp2 out2 :: Type)
Instance details Defined in Lorentz.Lambda Methods castDummy :: Proxy (WrappedLambda inp1 out1) -> Proxy (WrappedLambda inp2 out2) -> () #
(CanCastTo a1 a2, CanCastTo r1 r2) => CanCastTo (View_ a1 r1 :: Type) (View_ a2 r2 :: Type)
Instance details Defined in Lorentz.Macro Methods castDummy :: Proxy (View_ a1 r1) -> Proxy (View_ a2 r2) -> () #
(CanCastTo a1 a2, CanCastTo r1 r2) => CanCastTo (Void_ a1 r1 :: Type) (Void_ a2 r2 :: Type)
Instance details Defined in Lorentz.Macro Methods castDummy :: Proxy (Void_ a1 r1) -> Proxy (Void_ a2 r2) -> () #
(CanCastTo a1 a2, CanCastTo b1 b2) => CanCastTo (ZippedStackRepr a1 b1 :: Type) (ZippedStackRepr a2 b2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (ZippedStackRepr a1 b1) -> Proxy (ZippedStackRepr a2 b2) -> () #
(CanCastTo k1 k2, CanCastTo v1 v2) => CanCastTo (BigMap k1 v1 :: Type) (BigMap k2 v2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (BigMap k1 v1) -> Proxy (BigMap k2 v2) -> () #
(CanCastTo a1 a2, CanCastTo b1 b2) => CanCastTo ((a1, b1) :: Type) ((a2, b2) :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (a1, b1) -> Proxy (a2, b2) -> () #
CanCastTo (f a) (g b) => CanCastTo (NamedF f a n :: Type) (NamedF g b m :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (NamedF f a n) -> Proxy (NamedF g b m) -> () #
(CanCastTo a1 a2, CanCastTo b1 b2, CanCastTo c1 c2) => CanCastTo ((a1, b1, c1) :: Type) ((a2, b2, c2) :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (a1, b1, c1) -> Proxy (a2, b2, c2) -> () #
(CanCastTo a1 a2, CanCastTo b1 b2, CanCastTo c1 c2, CanCastTo d1 d2) => CanCastTo ((a1, b1, c1, d1) :: Type) ((a2, b2, c2, d2) :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (a1, b1, c1, d1) -> Proxy (a2, b2, c2, d2) -> () #
(CanCastTo a1 a2, CanCastTo b1 b2, CanCastTo c1 c2, CanCastTo d1 d2, CanCastTo e1 e2) => CanCastTo ((a1, b1, c1, d1, e1) :: Type) ((a2, b2, c2, d2, e2) :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (a1, b1, c1, d1, e1) -> Proxy (a2, b2, c2, d2, e2) -> () #
(CanCastTo a1 a2, CanCastTo b1 b2, CanCastTo c1 c2, CanCastTo d1 d2, CanCastTo e1 e2, CanCastTo f1 f2) => CanCastTo ((a1, b1, c1, d1, e1, f1) :: Type) ((a2, b2, c2, d2, e2, f2) :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (a1, b1, c1, d1, e1, f1) -> Proxy (a2, b2, c2, d2, e2, f2) -> () #

type Castable_ a b = (MichelsonCoercible a b, CanCastTo a b) #

Coercion from a to b is permitted and safe.

type Coercible_ a b = (MichelsonCoercible a b, CanCastTo a b, CanCastTo b a) #

Coercions between a to b are permitted and safe.

newtype ParameterWrapper deriv cp #

Wrap parameter into this to locally assign a way to derive entrypoints for it.

Constructors

ParameterWrapper
Fields unParameterWraper :: cp

Instances

Instances details

EntrypointsDerivation deriv cp => EntrypointsDerivation (PwDeriv deriv :: Type) (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type EpdAllEntrypoints (PwDeriv deriv) (ParameterWrapper deriv cp) :: [(Symbol, Type)] # type EpdLookupEntrypoint (PwDeriv deriv) (ParameterWrapper deriv cp) :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT (ParameterWrapper deriv cp)), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT (ParameterWrapper deriv cp)) => Label name -> EpConstructionRes (ToT (ParameterWrapper deriv cp)) (Eval (EpdLookupEntrypoint (PwDeriv deriv) (ParameterWrapper deriv cp) name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints (PwDeriv deriv) (ParameterWrapper deriv cp)) #
Generic (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type Rep (ParameterWrapper deriv cp) :: Type -> Type # Methods from :: ParameterWrapper deriv cp -> Rep (ParameterWrapper deriv cp) x # to :: Rep (ParameterWrapper deriv cp) x -> ParameterWrapper deriv cp #
(NiceParameter cp, EntrypointsDerivation epd cp, RequireAllUniqueEntrypoints' epd cp) => ParameterHasEntrypoints (ParameterWrapper epd cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type ParameterEntrypointsDerivation (ParameterWrapper epd cp) #
Unwrappable (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type Unwrappabled (ParameterWrapper deriv cp) #
Wrappable (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual
HasRPCRepr cp => HasRPCRepr (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type AsRPC (ParameterWrapper deriv cp) #
IsoValue cp => IsoValue (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type ToT (ParameterWrapper deriv cp) :: T # Methods toVal :: ParameterWrapper deriv cp -> Value (ToT (ParameterWrapper deriv cp)) # fromVal :: Value (ToT (ParameterWrapper deriv cp)) -> ParameterWrapper deriv cp #
type EpdAllEntrypoints (PwDeriv deriv :: Type) (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual type EpdAllEntrypoints (PwDeriv deriv :: Type) (ParameterWrapper deriv cp) = EpdAllEntrypoints deriv cp
type EpdLookupEntrypoint (PwDeriv deriv :: Type) (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual type EpdLookupEntrypoint (PwDeriv deriv :: Type) (ParameterWrapper deriv cp) = EpdLookupEntrypoint deriv cp
type Rep (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual type Rep (ParameterWrapper deriv cp) = D1 ('MetaData "ParameterWrapper" "Lorentz.Entrypoints.Manual" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'True) (C1 ('MetaCons "ParameterWrapper" 'PrefixI 'True) (S1 ('MetaSel ('Just "unParameterWraper") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 cp)))
type ParameterEntrypointsDerivation (ParameterWrapper epd cp)
Instance details Defined in Lorentz.Entrypoints.Manual type ParameterEntrypointsDerivation (ParameterWrapper epd cp) = PwDeriv epd
type Unwrappabled (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual type Unwrappabled (ParameterWrapper deriv cp) = GUnwrappabled (ParameterWrapper deriv cp) (Rep (ParameterWrapper deriv cp))
type AsRPC (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual type AsRPC (ParameterWrapper deriv cp) = ParameterWrapper deriv (AsRPC cp)
type ToT (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual type ToT (ParameterWrapper deriv cp) = GValueType (Rep (ParameterWrapper deriv cp))

type family Unwrappabled s #

The type we unwrap to (inner type of the newtype).

Used in constraint for Lorentz instruction wrapping into a Haskell newtype and vice versa.

Instances

Instances details

type Unwrappabled (UParam entries)
Instance details Defined in Lorentz.UParam type Unwrappabled (UParam entries) = GUnwrappabled (UParam entries) (Rep (UParam entries))
type Unwrappabled (Fixed a)
Instance details Defined in Lorentz.Wrappable type Unwrappabled (Fixed a) = Integer
type Unwrappabled (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual type Unwrappabled (ParameterWrapper deriv cp) = GUnwrappabled (ParameterWrapper deriv cp) (Rep (ParameterWrapper deriv cp))
type Unwrappabled (NamedF Identity a name)
Instance details Defined in Lorentz.Wrappable type Unwrappabled (NamedF Identity a name) = a
type Unwrappabled (NamedF Maybe a name)
Instance details Defined in Lorentz.Wrappable type Unwrappabled (NamedF Maybe a name) = Maybe a

class ToT s ~ ToT (Unwrappabled s) => Unwrappable s #

Declares that this type is just a wrapper over some other type and it can be safely unwrapped to that inner type.

Inspired by lens Wrapped.

Associated Types

type Unwrappabled s #

The type we unwrap to (inner type of the newtype).

Used in constraint for Lorentz instruction wrapping into a Haskell newtype and vice versa.

type Unwrappabled s = GUnwrappabled s (Rep s)

Instances

Instances details

Unwrappable (UParam entries)
Instance details Defined in Lorentz.UParam Associated Types type Unwrappabled (UParam entries) #
Unwrappable (Fixed a)
Instance details Defined in Lorentz.Wrappable Associated Types type Unwrappabled (Fixed a) #
Unwrappable (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type Unwrappabled (ParameterWrapper deriv cp) #
Unwrappable (NamedF Identity a name)
Instance details Defined in Lorentz.Wrappable Associated Types type Unwrappabled (NamedF Identity a name) #
Unwrappable (NamedF Maybe a name)
Instance details Defined in Lorentz.Wrappable Associated Types type Unwrappabled (NamedF Maybe a name) #

class Unwrappable s => Wrappable s #

Declares that it is safe to wrap an inner type to the given wrapper type. Can be provided in addition to Unwrappable.

You can declare this instance when your wrapper exists just to make type system differentiate the two types. Example: newtype TokenId = TokenId Natural.

Do not define this instance for wrappers that provide some invariants. Example: UStore type from morley-upgradeable.

Wrappable is similar to lens Wrapped class without the method.

Instances

Instances details

Wrappable (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual
Wrappable (NamedF Identity a name)
Instance details Defined in Lorentz.Wrappable
Wrappable (NamedF Maybe a name)
Instance details Defined in Lorentz.Wrappable

class ArithOpHs aop n m r where #

Lifted ArithOp.

Minimal complete definition

Nothing

Methods

evalArithOpHs :: forall (s :: [Type]). (n ': (m ': s)) :-> (r ': s) #

Instances

Instances details

(ArithOpHs EDiv n d (Maybe (q, r)), mq ~ Maybe q, KnownValue q) => ArithOpHs IDiv n d mq
Instance details Defined in Lorentz.Macro Methods evalArithOpHs :: forall (s :: [Type]). (n ': (d ': s)) :-> (mq ': s) #
(ArithOpHs EDiv n d (Maybe (q, r)), mr ~ Maybe r, KnownValue r) => ArithOpHs IMod n d mr
Instance details Defined in Lorentz.Macro Methods evalArithOpHs :: forall (s :: [Type]). (n ': (d ': s)) :-> (mr ': s) #
r ~ Mutez => ArithOpHs Add Mutez Mutez r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Mutez ': (Mutez ': s)) :-> (r ': s) #
r ~ Timestamp => ArithOpHs Add Timestamp Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Timestamp ': (Integer ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Add Bls12381Fr Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Bls12381G1 => ArithOpHs Add Bls12381G1 Bls12381G1 r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381G1 ': (Bls12381G1 ': s)) :-> (r ': s) #
r ~ Bls12381G2 => ArithOpHs Add Bls12381G2 Bls12381G2 r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381G2 ': (Bls12381G2 ': s)) :-> (r ': s) #
r ~ Timestamp => ArithOpHs Add Integer Timestamp r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Timestamp ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Add Integer Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Integer ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Add Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Add Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Add Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs And ByteString ByteString r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (ByteString ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs And Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs And Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ Bool => ArithOpHs And Bool Bool r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bool ': (Bool ': s)) :-> (r ': s) #
r ~ Maybe (Natural, Mutez) => ArithOpHs EDiv Mutez Mutez r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Mutez ': (Mutez ': s)) :-> (r ': s) #
r ~ Maybe (Mutez, Mutez) => ArithOpHs EDiv Mutez Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Mutez ': (Natural ': s)) :-> (r ': s) #
r ~ Maybe (Integer, Natural) => ArithOpHs EDiv Integer Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Integer ': s)) :-> (r ': s) #
r ~ Maybe (Integer, Natural) => ArithOpHs EDiv Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Maybe (Integer, Natural) => ArithOpHs EDiv Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Maybe (Natural, Natural) => ArithOpHs EDiv Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs Lsl ByteString Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (Natural ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Lsl Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs Lsr ByteString Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (Natural ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Lsr Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ Mutez => ArithOpHs Mul Mutez Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Mutez ': (Natural ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Bls12381Fr Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Bls12381G1 => ArithOpHs Mul Bls12381Fr Bls12381G1 r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Bls12381G1 ': s)) :-> (r ': s) #
r ~ Bls12381G2 => ArithOpHs Mul Bls12381Fr Bls12381G2 r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Bls12381G2 ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Bls12381Fr Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Integer ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Bls12381Fr Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Natural ': s)) :-> (r ': s) #
r ~ Bls12381G1 => ArithOpHs Mul Bls12381G1 Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381G1 ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Bls12381G2 => ArithOpHs Mul Bls12381G2 Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381G2 ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Integer Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Mul Integer Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Integer ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Mul Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Mutez => ArithOpHs Mul Natural Mutez r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Mutez ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Natural Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Mul Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Mul Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs Or ByteString ByteString r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (ByteString ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Or Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ Bool => ArithOpHs Or Bool Bool r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bool ': (Bool ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Timestamp Timestamp r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Timestamp ': (Timestamp ': s)) :-> (r ': s) #
r ~ Timestamp => ArithOpHs Sub Timestamp Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Timestamp ': (Integer ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Integer Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Integer ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Integer Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Natural ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Natural Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Integer ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ ByteString => ArithOpHs Xor ByteString ByteString r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (ByteString ': (ByteString ': s)) :-> (r ': s) #
r ~ Natural => ArithOpHs Xor Natural Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Natural ': s)) :-> (r ': s) #
r ~ Bool => ArithOpHs Xor Bool Bool r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bool ': (Bool ': s)) :-> (r ': s) #

class DefArithOp (aop :: k) where #

Helper typeclass that provides default definition of evalArithOpHs.

Methods

defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp aop n m, r ~ ArithRes aop n m) => Instr (n ': (m ': s)) (r ': s) #

Instances

Instances details

DefArithOp Add
Instance details Defined in Lorentz.Arith Methods defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp Add n m, r ~ ArithRes Add n m) => Instr (n ': (m ': s)) (r ': s) #
DefArithOp And
Instance details Defined in Lorentz.Arith Methods defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp And n m, r ~ ArithRes And n m) => Instr (n ': (m ': s)) (r ': s) #
DefArithOp EDiv
Instance details Defined in Lorentz.Arith Methods defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp EDiv n m, r ~ ArithRes EDiv n m) => Instr (n ': (m ': s)) (r ': s) #
DefArithOp Lsl
Instance details Defined in Lorentz.Arith Methods defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp Lsl n m, r ~ ArithRes Lsl n m) => Instr (n ': (m ': s)) (r ': s) #
DefArithOp Lsr
Instance details Defined in Lorentz.Arith Methods defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp Lsr n m, r ~ ArithRes Lsr n m) => Instr (n ': (m ': s)) (r ': s) #
DefArithOp Mul
Instance details Defined in Lorentz.Arith Methods defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp Mul n m, r ~ ArithRes Mul n m) => Instr (n ': (m ': s)) (r ': s) #
DefArithOp Or
Instance details Defined in Lorentz.Arith Methods defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp Or n m, r ~ ArithRes Or n m) => Instr (n ': (m ': s)) (r ': s) #
DefArithOp Sub
Instance details Defined in Lorentz.Arith Methods defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp Sub n m, r ~ ArithRes Sub n m) => Instr (n ': (m ': s)) (r ': s) #
DefArithOp Xor
Instance details Defined in Lorentz.Arith Methods defEvalOpHs :: forall (n :: T) (m :: T) (r :: T) (s :: [T]). (ArithOp Xor n m, r ~ ArithRes Xor n m) => Instr (n ': (m ': s)) (r ': s) #

type family UnaryArithResHs aop n #

Instances

Instances details

type UnaryArithResHs Abs Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Abs Integer = Natural
type UnaryArithResHs Eq' Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Eq' Integer = Bool
type UnaryArithResHs Eq' Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Eq' Natural = Bool
type UnaryArithResHs Ge Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Ge Integer = Bool
type UnaryArithResHs Ge Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Ge Natural = Bool
type UnaryArithResHs Gt Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Gt Integer = Bool
type UnaryArithResHs Gt Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Gt Natural = Bool
type UnaryArithResHs Le Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Le Integer = Bool
type UnaryArithResHs Le Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Le Natural = Bool
type UnaryArithResHs Lt Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Lt Integer = Bool
type UnaryArithResHs Lt Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Lt Natural = Bool
type UnaryArithResHs Neg Bls12381Fr
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neg Bls12381Fr = Bls12381Fr
type UnaryArithResHs Neg Bls12381G1
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neg Bls12381G1 = Bls12381G1
type UnaryArithResHs Neg Bls12381G2
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neg Bls12381G2 = Bls12381G2
type UnaryArithResHs Neg Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neg Integer = Integer
type UnaryArithResHs Neg Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neg Natural = Integer
type UnaryArithResHs Neq Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neq Integer = Bool
type UnaryArithResHs Neq Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neq Natural = Bool
type UnaryArithResHs Not ByteString
Instance details Defined in Lorentz.Arith type UnaryArithResHs Not ByteString = ByteString
type UnaryArithResHs Not Integer
Instance details Defined in Lorentz.Arith type UnaryArithResHs Not Integer = Integer
type UnaryArithResHs Not Natural
Instance details Defined in Lorentz.Arith type UnaryArithResHs Not Natural = Integer
type UnaryArithResHs Not Bool
Instance details Defined in Lorentz.Arith type UnaryArithResHs Not Bool = Bool

class UnaryArithOpHs aop n where #

Lifted UnaryArithOp.

Minimal complete definition

Nothing

Associated Types

type UnaryArithResHs aop n #

Methods

evalUnaryArithOpHs :: forall (s :: [Type]). (n ': s) :-> (UnaryArithResHs aop n ': s) #

Instances

Instances details

UnaryArithOpHs Abs Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Abs Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Abs Integer ': s) #
UnaryArithOpHs Eq' Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Eq' Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Eq' Integer ': s) #
UnaryArithOpHs Eq' Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Eq' Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Eq' Natural ': s) #
UnaryArithOpHs Ge Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Ge Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Ge Integer ': s) #
UnaryArithOpHs Ge Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Ge Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Ge Natural ': s) #
UnaryArithOpHs Gt Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Gt Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Gt Integer ': s) #
UnaryArithOpHs Gt Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Gt Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Gt Natural ': s) #
UnaryArithOpHs Le Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Le Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Le Integer ': s) #
UnaryArithOpHs Le Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Le Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Le Natural ': s) #
UnaryArithOpHs Lt Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Lt Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Lt Integer ': s) #
UnaryArithOpHs Lt Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Lt Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Lt Natural ': s) #
UnaryArithOpHs Neg Bls12381Fr
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neg Bls12381Fr # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': s) :-> (UnaryArithResHs Neg Bls12381Fr ': s) #
UnaryArithOpHs Neg Bls12381G1
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neg Bls12381G1 # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Bls12381G1 ': s) :-> (UnaryArithResHs Neg Bls12381G1 ': s) #
UnaryArithOpHs Neg Bls12381G2
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neg Bls12381G2 # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Bls12381G2 ': s) :-> (UnaryArithResHs Neg Bls12381G2 ': s) #
UnaryArithOpHs Neg Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neg Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Neg Integer ': s) #
UnaryArithOpHs Neg Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neg Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Neg Natural ': s) #
UnaryArithOpHs Neq Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neq Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Neq Integer ': s) #
UnaryArithOpHs Neq Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neq Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Neq Natural ': s) #
UnaryArithOpHs Not ByteString
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Not ByteString # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (ByteString ': s) :-> (UnaryArithResHs Not ByteString ': s) #
UnaryArithOpHs Not Integer
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Not Integer # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Integer ': s) :-> (UnaryArithResHs Not Integer ': s) #
UnaryArithOpHs Not Natural
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Not Natural # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Natural ': s) :-> (UnaryArithResHs Not Natural ': s) #
UnaryArithOpHs Not Bool
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Not Bool # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Bool ': s) :-> (UnaryArithResHs Not Bool ': s) #

type family DefUnaryArithOpExtraConstraints (aop :: k) (n :: T) #

Instances

Instances details

type DefUnaryArithOpExtraConstraints Abs n
Instance details Defined in Lorentz.Arith type DefUnaryArithOpExtraConstraints Abs n = ()
type DefUnaryArithOpExtraConstraints Eq' n
Instance details Defined in Lorentz.Arith type DefUnaryArithOpExtraConstraints Eq' n = ()
type DefUnaryArithOpExtraConstraints Ge n
Instance details Defined in Lorentz.Arith type DefUnaryArithOpExtraConstraints Ge n = ()
type DefUnaryArithOpExtraConstraints Gt n
Instance details Defined in Lorentz.Arith type DefUnaryArithOpExtraConstraints Gt n = ()
type DefUnaryArithOpExtraConstraints Le n
Instance details Defined in Lorentz.Arith type DefUnaryArithOpExtraConstraints Le n = ()
type DefUnaryArithOpExtraConstraints Lt n
Instance details Defined in Lorentz.Arith type DefUnaryArithOpExtraConstraints Lt n = ()
type DefUnaryArithOpExtraConstraints Neg n
Instance details Defined in Lorentz.Arith type DefUnaryArithOpExtraConstraints Neg n = ()
type DefUnaryArithOpExtraConstraints Neq n
Instance details Defined in Lorentz.Arith type DefUnaryArithOpExtraConstraints Neq n = ()
type DefUnaryArithOpExtraConstraints Not n
Instance details Defined in Lorentz.Arith type DefUnaryArithOpExtraConstraints Not n = SingI n

class DefUnaryArithOp (aop :: k) where #

Helper typeclass that provides default definition of evalUnaryArithOpHs.

Associated Types

type DefUnaryArithOpExtraConstraints (aop :: k) (n :: T) #

type DefUnaryArithOpExtraConstraints (aop :: k) (n :: T) = ()

Methods

defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp aop n, r ~ UnaryArithRes aop n, DefUnaryArithOpExtraConstraints aop n) => Instr (n ': s) (r ': s) #

Instances

Instances details

DefUnaryArithOp Abs
Instance details Defined in Lorentz.Arith Associated Types type DefUnaryArithOpExtraConstraints Abs n # Methods defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp Abs n, r ~ UnaryArithRes Abs n, DefUnaryArithOpExtraConstraints Abs n) => Instr (n ': s) (r ': s) #
DefUnaryArithOp Eq'
Instance details Defined in Lorentz.Arith Associated Types type DefUnaryArithOpExtraConstraints Eq' n # Methods defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp Eq' n, r ~ UnaryArithRes Eq' n, DefUnaryArithOpExtraConstraints Eq' n) => Instr (n ': s) (r ': s) #
DefUnaryArithOp Ge
Instance details Defined in Lorentz.Arith Associated Types type DefUnaryArithOpExtraConstraints Ge n # Methods defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp Ge n, r ~ UnaryArithRes Ge n, DefUnaryArithOpExtraConstraints Ge n) => Instr (n ': s) (r ': s) #
DefUnaryArithOp Gt
Instance details Defined in Lorentz.Arith Associated Types type DefUnaryArithOpExtraConstraints Gt n # Methods defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp Gt n, r ~ UnaryArithRes Gt n, DefUnaryArithOpExtraConstraints Gt n) => Instr (n ': s) (r ': s) #
DefUnaryArithOp Le
Instance details Defined in Lorentz.Arith Associated Types type DefUnaryArithOpExtraConstraints Le n # Methods defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp Le n, r ~ UnaryArithRes Le n, DefUnaryArithOpExtraConstraints Le n) => Instr (n ': s) (r ': s) #
DefUnaryArithOp Lt
Instance details Defined in Lorentz.Arith Associated Types type DefUnaryArithOpExtraConstraints Lt n # Methods defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp Lt n, r ~ UnaryArithRes Lt n, DefUnaryArithOpExtraConstraints Lt n) => Instr (n ': s) (r ': s) #
DefUnaryArithOp Neg
Instance details Defined in Lorentz.Arith Associated Types type DefUnaryArithOpExtraConstraints Neg n # Methods defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp Neg n, r ~ UnaryArithRes Neg n, DefUnaryArithOpExtraConstraints Neg n) => Instr (n ': s) (r ': s) #
DefUnaryArithOp Neq
Instance details Defined in Lorentz.Arith Associated Types type DefUnaryArithOpExtraConstraints Neq n # Methods defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp Neq n, r ~ UnaryArithRes Neq n, DefUnaryArithOpExtraConstraints Neq n) => Instr (n ': s) (r ': s) #
DefUnaryArithOp Not
Instance details Defined in Lorentz.Arith Associated Types type DefUnaryArithOpExtraConstraints Not n # Methods defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp Not n, r ~ UnaryArithRes Not n, DefUnaryArithOpExtraConstraints Not n) => Instr (n ': s) (r ': s) #

class ToIntegerArithOpHs n where #

Minimal complete definition

Nothing

Methods

evalToIntOpHs :: forall (s :: [Type]). (n ': s) :-> (Integer ': s) #

Instances

Instances details

ToIntegerArithOpHs Bls12381Fr
Instance details Defined in Lorentz.Arith Methods evalToIntOpHs :: forall (s :: [Type]). (Bls12381Fr ': s) :-> (Integer ': s) #
ToIntegerArithOpHs Natural
Instance details Defined in Lorentz.Arith Methods evalToIntOpHs :: forall (s :: [Type]). (Natural ': s) :-> (Integer ': s) #
BytesLike bs => ToIntegerArithOpHs bs
Instance details Defined in Lorentz.Arith Methods evalToIntOpHs :: forall (s :: [Type]). (bs ': s) :-> (Integer ': s) #

class ToBytesArithOpHs n where #

Minimal complete definition

Nothing

Methods

evalToBytesOpHs :: forall bs (s :: [Type]). BytesLike bs => (n ': s) :-> (bs ': s) #

Instances

Instances details

ToBytesArithOpHs Integer
Instance details Defined in Lorentz.Arith Methods evalToBytesOpHs :: forall bs (s :: [Type]). BytesLike bs => (Integer ': s) :-> (bs ': s) #
ToBytesArithOpHs Natural
Instance details Defined in Lorentz.Arith Methods evalToBytesOpHs :: forall bs (s :: [Type]). BytesLike bs => (Natural ': s) :-> (bs ': s) #

expressionToScriptExpr :: Expression -> ByteString #

Similar to valueToScriptExpr, but for values encoded as Expressions. This is only used in tests.

valueToScriptExpr :: NicePackedValue t => t -> ByteString #

This function transforms Lorentz values into script_expr.

script_expr is used in RPC as an argument in entrypoint designed for getting value by key from the big_map in Babylon. In order to convert value to the script_expr we have to pack it, take blake2b hash and add specific expr prefix. Take a look at https://gitlab.com/tezos/tezos/blob/6e25ae8eb385d9975a30388c7a7aa2a9a65bf184/src/proto_005_PsBabyM1/lib_protocol/script_expr_hash.ml and https://gitlab.com/tezos/tezos/blob/6e25ae8eb385d9975a30388c7a7aa2a9a65bf184/src/proto_005_PsBabyM1/lib_protocol/contract_services.ml#L136 for more information.

lEncodeValue :: NiceUntypedValue a => a -> ByteString #

lUnpackValue :: NiceUnpackedValue a => Packed a -> Either UnpackError a #

lPackValue :: NicePackedValue a => a -> Packed a #

lUnpackValueRaw :: NiceUnpackedValue a => ByteString -> Either UnpackError a #

lPackValueRaw :: NicePackedValue a => a -> ByteString #

openChestT :: forall a (s :: [Type]). BytesLike a => (ChestKey ': (ChestT a ': (Natural ': s))) :-> (OpenChestT a ': s) #

toHashHs :: forall (alg :: HashAlgorithmKind) bs. (BytesLike bs, KnownHashAlgorithm alg) => bs -> Hash alg bs #

Evaluate hash in Haskell world.

lSign :: (MonadRandom m, BytesLike a) => SecretKey -> a -> m (TSignature a) #

Sign data using SecretKey

class (KnownValue bs, ToT bs ~ ToT ByteString) => BytesLike bs where #

Everything which is represented as bytes inside.

Methods

toBytes :: bs -> ByteString #

Instances

Instances details

BytesLike ByteString
Instance details Defined in Lorentz.Bytes Methods toBytes :: ByteString -> ByteString #
Typeable a => BytesLike (Packed a)
Instance details Defined in Lorentz.Bytes Methods toBytes :: Packed a -> ByteString #
(Typeable alg, Typeable a) => BytesLike (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods toBytes :: Hash alg a -> ByteString #

newtype Packed a #

Represents a ByteString resulting from packing a value of type a.

This is not guaranteed to keep some packed value, and unpack can fail. We do so because often we need to accept values of such type from user, and also because there is no simple way to check validity of packed data without performing full unpack. So this wrapper is rather a hint for users.

Constructors

Packed
Fields unPacked :: ByteString

Instances

Instances details

Generic (Packed a)
Instance details Defined in Lorentz.Bytes Associated Types type Rep (Packed a) :: Type -> Type # Methods from :: Packed a -> Rep (Packed a) x # to :: Rep (Packed a) x -> Packed a #
Show (Packed a)
Instance details Defined in Lorentz.Bytes Methods showsPrec :: Int -> Packed a -> ShowS # show :: Packed a -> String # showList :: [Packed a] -> ShowS #
Buildable (Packed a)
Instance details Defined in Lorentz.Bytes Methods build :: Packed a -> Builder #
Eq (Packed a)
Instance details Defined in Lorentz.Bytes Methods (==) :: Packed a -> Packed a -> Bool # (/=) :: Packed a -> Packed a -> Bool #
Ord (Packed a)
Instance details Defined in Lorentz.Bytes Methods compare :: Packed a -> Packed a -> Ordering # (<) :: Packed a -> Packed a -> Bool # (<=) :: Packed a -> Packed a -> Bool # (>) :: Packed a -> Packed a -> Bool # (>=) :: Packed a -> Packed a -> Bool # max :: Packed a -> Packed a -> Packed a # min :: Packed a -> Packed a -> Packed a #
HasAnnotation (Packed a)
Instance details Defined in Lorentz.Bytes Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Packed a)) # annOptions :: Maybe AnnOptions #
Typeable a => BytesLike (Packed a)
Instance details Defined in Lorentz.Bytes Methods toBytes :: Packed a -> ByteString #
HasRPCRepr (Packed a)
Instance details Defined in Lorentz.Bytes Associated Types type AsRPC (Packed a) #
TypeHasDoc a => TypeHasDoc (Packed a)
Instance details Defined in Lorentz.Bytes Associated Types type TypeDocFieldDescriptions (Packed a) :: FieldDescriptions # Methods typeDocName :: Proxy (Packed a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Packed a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Packed a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Packed a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Packed a) #
IsoValue (Packed a)
Instance details Defined in Lorentz.Bytes Associated Types type ToT (Packed a) :: T # Methods toVal :: Packed a -> Value (ToT (Packed a)) # fromVal :: Value (ToT (Packed a)) -> Packed a #
CanCastTo (Packed a :: Type) ByteString
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Packed a) -> Proxy ByteString -> () #
CanCastTo a b => CanCastTo (Packed a :: Type) (Packed b :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Packed a) -> Proxy (Packed b) -> () #
type Rep (Packed a)
Instance details Defined in Lorentz.Bytes type Rep (Packed a) = D1 ('MetaData "Packed" "Lorentz.Bytes" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'True) (C1 ('MetaCons "Packed" 'PrefixI 'True) (S1 ('MetaSel ('Just "unPacked") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ByteString)))
type AsRPC (Packed a)
Instance details Defined in Lorentz.Bytes type AsRPC (Packed a) = Packed a
type TypeDocFieldDescriptions (Packed a)
Instance details Defined in Lorentz.Bytes type TypeDocFieldDescriptions (Packed a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (Packed a)
Instance details Defined in Lorentz.Bytes type ToT (Packed a) = ToT ByteString

newtype TSignature a #

Represents a signature, where signed data has given type.

Since we usually sign a packed data, a common pattern for this type is TSignature (Packed signedData). If you don't want to use Packed, use plain TSignature ByteString instead.

Constructors

TSignature
Fields unTSignature :: Signature

Instances

Instances details

Generic (TSignature a)
Instance details Defined in Lorentz.Bytes Associated Types type Rep (TSignature a) :: Type -> Type # Methods from :: TSignature a -> Rep (TSignature a) x # to :: Rep (TSignature a) x -> TSignature a #
Show (TSignature a)
Instance details Defined in Lorentz.Bytes Methods showsPrec :: Int -> TSignature a -> ShowS # show :: TSignature a -> String # showList :: [TSignature a] -> ShowS #
Buildable (TSignature a)
Instance details Defined in Lorentz.Bytes Methods build :: TSignature a -> Builder #
HasAnnotation (TSignature a)
Instance details Defined in Lorentz.Bytes Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (TSignature a)) # annOptions :: Maybe AnnOptions #
HasRPCRepr (TSignature a)
Instance details Defined in Lorentz.Bytes Associated Types type AsRPC (TSignature a) #
TypeHasDoc a => TypeHasDoc (TSignature a)
Instance details Defined in Lorentz.Bytes Associated Types type TypeDocFieldDescriptions (TSignature a) :: FieldDescriptions # Methods typeDocName :: Proxy (TSignature a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (TSignature a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (TSignature a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (TSignature a) # typeDocMichelsonRep :: TypeDocMichelsonRep (TSignature a) #
IsoValue (TSignature a)
Instance details Defined in Lorentz.Bytes Associated Types type ToT (TSignature a) :: T # Methods toVal :: TSignature a -> Value (ToT (TSignature a)) # fromVal :: Value (ToT (TSignature a)) -> TSignature a #
CanCastTo (TSignature a :: Type) ByteString
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (TSignature a) -> Proxy ByteString -> () #
CanCastTo a b => CanCastTo (TSignature a :: Type) (TSignature b :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (TSignature a) -> Proxy (TSignature b) -> () #
type Rep (TSignature a)
Instance details Defined in Lorentz.Bytes type Rep (TSignature a) = D1 ('MetaData "TSignature" "Lorentz.Bytes" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'True) (C1 ('MetaCons "TSignature" 'PrefixI 'True) (S1 ('MetaSel ('Just "unTSignature") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Signature)))
type AsRPC (TSignature a)
Instance details Defined in Lorentz.Bytes type AsRPC (TSignature a) = TSignature a
type TypeDocFieldDescriptions (TSignature a)
Instance details Defined in Lorentz.Bytes type TypeDocFieldDescriptions (TSignature a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (TSignature a)
Instance details Defined in Lorentz.Bytes type ToT (TSignature a) = ToT Signature

newtype Hash (alg :: HashAlgorithmKind) a #

Hash of type t evaluated from data of type a.

Constructors

UnsafeHash
Fields unHash :: ByteString

Instances

Instances details

CanCastTo (Hash alg a :: Type) ByteString
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Hash alg a) -> Proxy ByteString -> () #
(CanCastTo alg1 alg2, CanCastTo a1 a2) => CanCastTo (Hash alg1 a1 :: Type) (Hash alg2 a2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (Hash alg1 a1) -> Proxy (Hash alg2 a2) -> () #
Generic (Hash alg a)
Instance details Defined in Lorentz.Bytes Associated Types type Rep (Hash alg a) :: Type -> Type # Methods from :: Hash alg a -> Rep (Hash alg a) x # to :: Rep (Hash alg a) x -> Hash alg a #
Show (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods showsPrec :: Int -> Hash alg a -> ShowS # show :: Hash alg a -> String # showList :: [Hash alg a] -> ShowS #
Buildable (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods build :: Hash alg a -> Builder #
Eq (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods (==) :: Hash alg a -> Hash alg a -> Bool # (/=) :: Hash alg a -> Hash alg a -> Bool #
Ord (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods compare :: Hash alg a -> Hash alg a -> Ordering # (<) :: Hash alg a -> Hash alg a -> Bool # (<=) :: Hash alg a -> Hash alg a -> Bool # (>) :: Hash alg a -> Hash alg a -> Bool # (>=) :: Hash alg a -> Hash alg a -> Bool # max :: Hash alg a -> Hash alg a -> Hash alg a # min :: Hash alg a -> Hash alg a -> Hash alg a #
HasAnnotation (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Hash alg a)) # annOptions :: Maybe AnnOptions #
(Typeable alg, Typeable a) => BytesLike (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods toBytes :: Hash alg a -> ByteString #
HasRPCRepr (Hash alg a)
Instance details Defined in Lorentz.Bytes Associated Types type AsRPC (Hash alg a) #
(KnownHashAlgorithm alg, TypeHasDoc a) => TypeHasDoc (Hash alg a)
Instance details Defined in Lorentz.Bytes Associated Types type TypeDocFieldDescriptions (Hash alg a) :: FieldDescriptions # Methods typeDocName :: Proxy (Hash alg a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Hash alg a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Hash alg a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Hash alg a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Hash alg a) #
IsoValue (Hash alg a)
Instance details Defined in Lorentz.Bytes Associated Types type ToT (Hash alg a) :: T # Methods toVal :: Hash alg a -> Value (ToT (Hash alg a)) # fromVal :: Value (ToT (Hash alg a)) -> Hash alg a #
type Rep (Hash alg a)
Instance details Defined in Lorentz.Bytes type Rep (Hash alg a) = D1 ('MetaData "Hash" "Lorentz.Bytes" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'True) (C1 ('MetaCons "UnsafeHash" 'PrefixI 'True) (S1 ('MetaSel ('Just "unHash") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ByteString)))
type AsRPC (Hash alg a)
Instance details Defined in Lorentz.Bytes type AsRPC (Hash alg a) = Hash alg a
type TypeDocFieldDescriptions (Hash alg a)
Instance details Defined in Lorentz.Bytes type TypeDocFieldDescriptions (Hash alg a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (Hash alg a)
Instance details Defined in Lorentz.Bytes type ToT (Hash alg a) = ToT ByteString

class Typeable alg => KnownHashAlgorithm (alg :: HashAlgorithmKind) where #

Hash algorithm used in Tezos.

Minimal complete definition

computeHash, toHash

Methods

hashAlgorithmName :: Proxy alg -> Text #

computeHash :: ByteString -> ByteString #

toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash alg bs ': s) #

Instances

Instances details

KnownHashAlgorithm Blake2b
Instance details Defined in Lorentz.Bytes Methods hashAlgorithmName :: Proxy Blake2b -> Text # computeHash :: ByteString -> ByteString # toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash Blake2b bs ': s) #
KnownHashAlgorithm Keccak
Instance details Defined in Lorentz.Bytes Methods hashAlgorithmName :: Proxy Keccak -> Text # computeHash :: ByteString -> ByteString # toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash Keccak bs ': s) #
KnownHashAlgorithm Sha256
Instance details Defined in Lorentz.Bytes Methods hashAlgorithmName :: Proxy Sha256 -> Text # computeHash :: ByteString -> ByteString # toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash Sha256 bs ': s) #
KnownHashAlgorithm Sha3
Instance details Defined in Lorentz.Bytes Methods hashAlgorithmName :: Proxy Sha3 -> Text # computeHash :: ByteString -> ByteString # toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash Sha3 bs ': s) #
KnownHashAlgorithm Sha512
Instance details Defined in Lorentz.Bytes Methods hashAlgorithmName :: Proxy Sha512 -> Text # computeHash :: ByteString -> ByteString # toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash Sha512 bs ': s) #

data DHashAlgorithm #

Documentation item for hash algorithms.

Instances

Instances details

Eq DHashAlgorithm
Instance details Defined in Lorentz.Bytes Methods (==) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (/=) :: DHashAlgorithm -> DHashAlgorithm -> Bool #
Ord DHashAlgorithm
Instance details Defined in Lorentz.Bytes Methods compare :: DHashAlgorithm -> DHashAlgorithm -> Ordering # (<) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (<=) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (>) :: DHashAlgorithm -> DHashAlgorithm -> Bool # (>=) :: DHashAlgorithm -> DHashAlgorithm -> Bool # max :: DHashAlgorithm -> DHashAlgorithm -> DHashAlgorithm # min :: DHashAlgorithm -> DHashAlgorithm -> DHashAlgorithm #
DocItem DHashAlgorithm
Instance details Defined in Lorentz.Bytes Associated Types type DocItemPlacement DHashAlgorithm :: DocItemPlacementKind # type DocItemReferenced DHashAlgorithm :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DHashAlgorithm -> DocItemRef (DocItemPlacement DHashAlgorithm) (DocItemReferenced DHashAlgorithm) # docItemToMarkdown :: HeaderLevel -> DHashAlgorithm -> Markdown # docItemToToc :: HeaderLevel -> DHashAlgorithm -> Markdown # docItemDependencies :: DHashAlgorithm -> [SomeDocDefinitionItem] # docItemsOrder :: [DHashAlgorithm] -> [DHashAlgorithm] #
type DocItemPlacement DHashAlgorithm
Instance details Defined in Lorentz.Bytes type DocItemPlacement DHashAlgorithm = 'DocItemInDefinitions
type DocItemReferenced DHashAlgorithm
Instance details Defined in Lorentz.Bytes type DocItemReferenced DHashAlgorithm = 'True

data Sha256 (a :: HashAlgoTag) #

Instances

Instances details

KnownHashAlgorithm Sha256
Instance details Defined in Lorentz.Bytes Methods hashAlgorithmName :: Proxy Sha256 -> Text # computeHash :: ByteString -> ByteString # toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash Sha256 bs ': s) #

data Sha512 (a :: HashAlgoTag) #

Instances

Instances details

KnownHashAlgorithm Sha512
Instance details Defined in Lorentz.Bytes Methods hashAlgorithmName :: Proxy Sha512 -> Text # computeHash :: ByteString -> ByteString # toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash Sha512 bs ': s) #

data Blake2b (a :: HashAlgoTag) #

Instances

Instances details

KnownHashAlgorithm Blake2b
Instance details Defined in Lorentz.Bytes Methods hashAlgorithmName :: Proxy Blake2b -> Text # computeHash :: ByteString -> ByteString # toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash Blake2b bs ': s) #

data Sha3 (a :: HashAlgoTag) #

Instances

Instances details

KnownHashAlgorithm Sha3
Instance details Defined in Lorentz.Bytes Methods hashAlgorithmName :: Proxy Sha3 -> Text # computeHash :: ByteString -> ByteString # toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash Sha3 bs ': s) #

data Keccak (a :: HashAlgoTag) #

Instances

Instances details

KnownHashAlgorithm Keccak
Instance details Defined in Lorentz.Bytes Methods hashAlgorithmName :: Proxy Keccak -> Text # computeHash :: ByteString -> ByteString # toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash Keccak bs ': s) #

newtype ChestT a #

Constructors

ChestT
Fields unChestT :: Chest

Instances

Instances details

Generic (ChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type Rep (ChestT a) :: Type -> Type # Methods from :: ChestT a -> Rep (ChestT a) x # to :: Rep (ChestT a) x -> ChestT a #
HasAnnotation (ChestT a)
Instance details Defined in Lorentz.Bytes Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (ChestT a)) # annOptions :: Maybe AnnOptions #
HasRPCRepr (ChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type AsRPC (ChestT a) #
TypeHasDoc a => TypeHasDoc (ChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type TypeDocFieldDescriptions (ChestT a) :: FieldDescriptions # Methods typeDocName :: Proxy (ChestT a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (ChestT a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (ChestT a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (ChestT a) # typeDocMichelsonRep :: TypeDocMichelsonRep (ChestT a) #
IsoValue (ChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type ToT (ChestT a) :: T # Methods toVal :: ChestT a -> Value (ToT (ChestT a)) # fromVal :: Value (ToT (ChestT a)) -> ChestT a #
type Rep (ChestT a)
Instance details Defined in Lorentz.Bytes type Rep (ChestT a) = D1 ('MetaData "ChestT" "Lorentz.Bytes" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'True) (C1 ('MetaCons "ChestT" 'PrefixI 'True) (S1 ('MetaSel ('Just "unChestT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Chest)))
type AsRPC (ChestT a)
Instance details Defined in Lorentz.Bytes type AsRPC (ChestT a) = ChestT a
type TypeDocFieldDescriptions (ChestT a)
Instance details Defined in Lorentz.Bytes type TypeDocFieldDescriptions (ChestT a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (ChestT a)
Instance details Defined in Lorentz.Bytes type ToT (ChestT a) = ToT Chest

data OpenChestT a #

Constructors

ChestContentT a
ChestOpenFailedT Bool

Instances

Instances details

Generic (OpenChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type Rep (OpenChestT a) :: Type -> Type # Methods from :: OpenChestT a -> Rep (OpenChestT a) x # to :: Rep (OpenChestT a) x -> OpenChestT a #
Show a => Show (OpenChestT a)
Instance details Defined in Lorentz.Bytes Methods showsPrec :: Int -> OpenChestT a -> ShowS # show :: OpenChestT a -> String # showList :: [OpenChestT a] -> ShowS #
Eq a => Eq (OpenChestT a)
Instance details Defined in Lorentz.Bytes Methods (==) :: OpenChestT a -> OpenChestT a -> Bool # (/=) :: OpenChestT a -> OpenChestT a -> Bool #
HasAnnotation a => HasAnnotation (OpenChestT a)
Instance details Defined in Lorentz.Bytes Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (OpenChestT a)) # annOptions :: Maybe AnnOptions #
HasRPCRepr a => HasRPCRepr (OpenChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type AsRPC (OpenChestT a) #
TypeHasDoc a => TypeHasDoc (OpenChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type TypeDocFieldDescriptions (OpenChestT a) :: FieldDescriptions # Methods typeDocName :: Proxy (OpenChestT a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (OpenChestT a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (OpenChestT a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (OpenChestT a) # typeDocMichelsonRep :: TypeDocMichelsonRep (OpenChestT a) #
IsoValue a => IsoValue (OpenChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type ToT (OpenChestT a) :: T # Methods toVal :: OpenChestT a -> Value (ToT (OpenChestT a)) # fromVal :: Value (ToT (OpenChestT a)) -> OpenChestT a #
type Rep (OpenChestT a)
Instance details Defined in Lorentz.Bytes type Rep (OpenChestT a) = D1 ('MetaData "OpenChestT" "Lorentz.Bytes" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'False) (C1 ('MetaCons "ChestContentT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 a)) :+: C1 ('MetaCons "ChestOpenFailedT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Bool)))
type AsRPC (OpenChestT a)
Instance details Defined in Lorentz.Bytes type AsRPC (OpenChestT a) = OpenChestT (AsRPC a)
type TypeDocFieldDescriptions (OpenChestT a)
Instance details Defined in Lorentz.Bytes type TypeDocFieldDescriptions (OpenChestT a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (OpenChestT a)
Instance details Defined in Lorentz.Bytes type ToT (OpenChestT a) = GValueType (Rep (OpenChestT a))

mkDEntrypointExample :: NiceParameter a => a -> DEntrypointExample #

cutLorentzNonDoc :: forall (inp :: [Type]) (out :: [Type]) (s :: [Type]). (inp :-> out) -> s :-> s #

Leave only instructions related to documentation.

This function is useful when your method executes a lambda coming from outside, but you know its properties and want to propagate its documentation to your contract code.

data DEntrypointExample #

Modify the example value of an entrypoint

Constructors

ParameterScope t => DEntrypointExample (Value t)

Instances

Instances details

DocItem DEntrypointExample
Instance details Defined in Lorentz.Doc Associated Types type DocItemPlacement DEntrypointExample :: DocItemPlacementKind # type DocItemReferenced DEntrypointExample :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DEntrypointExample -> DocItemRef (DocItemPlacement DEntrypointExample) (DocItemReferenced DEntrypointExample) # docItemToMarkdown :: HeaderLevel -> DEntrypointExample -> Markdown # docItemToToc :: HeaderLevel -> DEntrypointExample -> Markdown # docItemDependencies :: DEntrypointExample -> [SomeDocDefinitionItem] # docItemsOrder :: [DEntrypointExample] -> [DEntrypointExample] #
type DocItemPlacement DEntrypointExample
Instance details Defined in Lorentz.Doc type DocItemPlacement DEntrypointExample = 'DocItemInlined
type DocItemReferenced DEntrypointExample
Instance details Defined in Lorentz.Doc type DocItemReferenced DEntrypointExample = 'False

data DView #

Renders to a view section.

Constructors

DView
Fields dvName :: ViewName dvSub :: SubDoc

Instances

Instances details

DocItem DView
Instance details Defined in Lorentz.Doc Associated Types type DocItemPlacement DView :: DocItemPlacementKind # type DocItemReferenced DView :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DView -> DocItemRef (DocItemPlacement DView) (DocItemReferenced DView) # docItemToMarkdown :: HeaderLevel -> DView -> Markdown # docItemToToc :: HeaderLevel -> DView -> Markdown # docItemDependencies :: DView -> [SomeDocDefinitionItem] # docItemsOrder :: [DView] -> [DView] #
type DocItemPlacement DView
Instance details Defined in Lorentz.Doc type DocItemPlacement DView = 'DocItemInlined
type DocItemReferenced DView
Instance details Defined in Lorentz.Doc type DocItemReferenced DView = 'True

data DViewArg #

Renders to a line mentioning the view's argument.

Constructors

(NiceViewable a, TypeHasDoc a) => DViewArg (Proxy a)

Instances

Instances details

DocItem DViewArg
Instance details Defined in Lorentz.Doc Associated Types type DocItemPlacement DViewArg :: DocItemPlacementKind # type DocItemReferenced DViewArg :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DViewArg -> DocItemRef (DocItemPlacement DViewArg) (DocItemReferenced DViewArg) # docItemToMarkdown :: HeaderLevel -> DViewArg -> Markdown # docItemToToc :: HeaderLevel -> DViewArg -> Markdown # docItemDependencies :: DViewArg -> [SomeDocDefinitionItem] # docItemsOrder :: [DViewArg] -> [DViewArg] #
type DocItemPlacement DViewArg
Instance details Defined in Lorentz.Doc type DocItemPlacement DViewArg = 'DocItemInlined
type DocItemReferenced DViewArg
Instance details Defined in Lorentz.Doc type DocItemReferenced DViewArg = 'False

data DViewRet #

Renders to a line mentioning the view's argument.

Constructors

(NiceViewable a, TypeHasDoc a) => DViewRet (Proxy a)

Instances

Instances details

DocItem DViewRet
Instance details Defined in Lorentz.Doc Associated Types type DocItemPlacement DViewRet :: DocItemPlacementKind # type DocItemReferenced DViewRet :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DViewRet -> DocItemRef (DocItemPlacement DViewRet) (DocItemReferenced DViewRet) # docItemToMarkdown :: HeaderLevel -> DViewRet -> Markdown # docItemToToc :: HeaderLevel -> DViewRet -> Markdown # docItemDependencies :: DViewRet -> [SomeDocDefinitionItem] # docItemsOrder :: [DViewRet] -> [DViewRet] #
type DocItemPlacement DViewRet
Instance details Defined in Lorentz.Doc type DocItemPlacement DViewRet = 'DocItemInlined
type DocItemReferenced DViewRet
Instance details Defined in Lorentz.Doc type DocItemReferenced DViewRet = 'False

class (Typeable vd, RenderViewsImpl (RevealViews vd)) => ViewsDescriptorHasDoc vd where #

Provides documentation for views descriptor.

Note that views descriptors may describe views that do not belong to the current contract, e.g. TAddress may refer to an external contract provided by the user in which we want to call a view.

Minimal complete definition

Nothing

Methods

viewsDescriptorName :: Proxy vd -> Text #

renderViewsDescriptorDoc :: Proxy vd -> Builder #

data DViewDesc #

Renders to documentation of view descriptor.

Constructors

ViewsDescriptorHasDoc vd => DViewDesc (Proxy vd)

Instances

Instances details

Eq DViewDesc
Instance details Defined in Lorentz.Doc Methods (==) :: DViewDesc -> DViewDesc -> Bool # (/=) :: DViewDesc -> DViewDesc -> Bool #
Ord DViewDesc
Instance details Defined in Lorentz.Doc Methods compare :: DViewDesc -> DViewDesc -> Ordering # (<) :: DViewDesc -> DViewDesc -> Bool # (<=) :: DViewDesc -> DViewDesc -> Bool # (>) :: DViewDesc -> DViewDesc -> Bool # (>=) :: DViewDesc -> DViewDesc -> Bool # max :: DViewDesc -> DViewDesc -> DViewDesc # min :: DViewDesc -> DViewDesc -> DViewDesc #
DocItem DViewDesc
Instance details Defined in Lorentz.Doc Associated Types type DocItemPlacement DViewDesc :: DocItemPlacementKind # type DocItemReferenced DViewDesc :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DViewDesc -> DocItemRef (DocItemPlacement DViewDesc) (DocItemReferenced DViewDesc) # docItemToMarkdown :: HeaderLevel -> DViewDesc -> Markdown # docItemToToc :: HeaderLevel -> DViewDesc -> Markdown # docItemDependencies :: DViewDesc -> [SomeDocDefinitionItem] # docItemsOrder :: [DViewDesc] -> [DViewDesc] #
type DocItemPlacement DViewDesc
Instance details Defined in Lorentz.Doc type DocItemPlacement DViewDesc = 'DocItemInDefinitions
type DocItemReferenced DViewDesc
Instance details Defined in Lorentz.Doc type DocItemReferenced DViewDesc = 'True

data EpdPlain #

Implementation of ParameterHasEntrypoints which fits for case when your contract exposes multiple entrypoints via having sum type as its parameter.

In particular, each constructor would produce a homonymous entrypoint with argument type equal to type of constructor field (each constructor should have only one field). Constructor called Default will designate the default entrypoint.

Instances

Instances details

PlainEntrypointsC EpdPlain cp => EntrypointsDerivation EpdPlain cp
Instance details Defined in Lorentz.Entrypoints.Impl Associated Types type EpdAllEntrypoints EpdPlain cp :: [(Symbol, Type)] # type EpdLookupEntrypoint EpdPlain cp :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT cp), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint EpdPlain cp name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints EpdPlain cp) #
type EpdAllEntrypoints EpdPlain cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdAllEntrypoints EpdPlain cp = PlainAllEntrypointsExt EpdPlain cp
type EpdLookupEntrypoint EpdPlain cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdLookupEntrypoint EpdPlain cp = PlainLookupEntrypointExt EpdPlain cp

data EpdRecursive #

Extension of EpdPlain on parameters being defined as several nested datatypes.

In particular, this will traverse sum types recursively, stopping at Michelson primitives (like Natural) and constructors with number of fields different from one.

It does not assign names to intermediate nodes of Or tree, only to the very leaves.

If some entrypoint arguments have custom IsoValue instance, this derivation way will not work. As a workaround, you can wrap your argument into some primitive (e.g. :!).

Instances

Instances details

(EntrypointsNotes EpdRecursive ep a, GenericIsoValue a) => GEntrypointsNotes EpdRecursive ep (Rec0 a)
Instance details Defined in Lorentz.Entrypoints.Impl Associated Types type GAllEntrypoints EpdRecursive ep (Rec0 a) :: [(Symbol, Type)] type GLookupEntrypoint EpdRecursive ep (Rec0 a) :: Symbol -> Exp (Maybe Type) Methods gMkEntrypointsNotes :: (Notes (GValueType (Rec0 a)), FieldAnn) gMkEpLiftSequence :: forall (name :: Symbol). ParameterScope (GValueType (Rec0 a)) => Label name -> EpConstructionRes (GValueType (Rec0 a)) (Eval (GLookupEntrypoint EpdRecursive ep (Rec0 a) name)) gMkDescs :: Rec EpCallingDesc (GAllEntrypoints EpdRecursive ep (Rec0 a))
PlainEntrypointsC EpdRecursive cp => EntrypointsDerivation EpdRecursive cp
Instance details Defined in Lorentz.Entrypoints.Impl Associated Types type EpdAllEntrypoints EpdRecursive cp :: [(Symbol, Type)] # type EpdLookupEntrypoint EpdRecursive cp :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT cp), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint EpdRecursive cp name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints EpdRecursive cp) #
type GAllEntrypoints EpdRecursive ep (Rec0 a)
Instance details Defined in Lorentz.Entrypoints.Impl type GAllEntrypoints EpdRecursive ep (Rec0 a) = AllEntrypoints EpdRecursive ep a
type GLookupEntrypoint EpdRecursive ep (Rec0 a)
Instance details Defined in Lorentz.Entrypoints.Impl type GLookupEntrypoint EpdRecursive ep (Rec0 a) = LookupEntrypoint EpdRecursive ep a
type EpdAllEntrypoints EpdRecursive cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdAllEntrypoints EpdRecursive cp = PlainAllEntrypointsExt EpdRecursive cp
type EpdLookupEntrypoint EpdRecursive cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdLookupEntrypoint EpdRecursive cp = PlainLookupEntrypointExt EpdRecursive cp

data EpdDelegate #

Extension of EpdPlain on parameters being defined as several nested datatypes.

In particular, it will traverse the immediate sum type, and require another ParameterHasEntrypoints for the inner complex datatypes. Only those inner types are considered which are the only fields in their respective constructors. Inner types should not themselves declare default entrypoint, we enforce this for better modularity. Each top-level constructor will be treated as entrypoint even if it contains a complex datatype within, in such case that would be an entrypoint corresponding to intermediate node in or tree.

Comparing to EpdRecursive this gives you more control over where and how entrypoints will be derived.

Instances

Instances details

ParameterDeclaresEntrypoints a => GEntrypointsNotes EpdDelegate 'EPDelegate (Rec0 a)
Instance details Defined in Lorentz.Entrypoints.Impl Associated Types type GAllEntrypoints EpdDelegate 'EPDelegate (Rec0 a) :: [(Symbol, Type)] type GLookupEntrypoint EpdDelegate 'EPDelegate (Rec0 a) :: Symbol -> Exp (Maybe Type) Methods gMkEntrypointsNotes :: (Notes (GValueType (Rec0 a)), FieldAnn) gMkEpLiftSequence :: forall (name :: Symbol). ParameterScope (GValueType (Rec0 a)) => Label name -> EpConstructionRes (GValueType (Rec0 a)) (Eval (GLookupEntrypoint EpdDelegate 'EPDelegate (Rec0 a) name)) gMkDescs :: Rec EpCallingDesc (GAllEntrypoints EpdDelegate 'EPDelegate (Rec0 a))
PlainEntrypointsC EpdDelegate cp => EntrypointsDerivation EpdDelegate cp
Instance details Defined in Lorentz.Entrypoints.Impl Associated Types type EpdAllEntrypoints EpdDelegate cp :: [(Symbol, Type)] # type EpdLookupEntrypoint EpdDelegate cp :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT cp), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint EpdDelegate cp name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints EpdDelegate cp) #
type GAllEntrypoints EpdDelegate 'EPDelegate (Rec0 a)
Instance details Defined in Lorentz.Entrypoints.Impl type GAllEntrypoints EpdDelegate 'EPDelegate (Rec0 a) = AllParameterEntrypoints a
type GLookupEntrypoint EpdDelegate 'EPDelegate (Rec0 a)
Instance details Defined in Lorentz.Entrypoints.Impl type GLookupEntrypoint EpdDelegate 'EPDelegate (Rec0 a) = LookupParameterEntrypoint a
type EpdAllEntrypoints EpdDelegate cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdAllEntrypoints EpdDelegate cp = PlainAllEntrypointsExt EpdDelegate cp
type EpdLookupEntrypoint EpdDelegate cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdLookupEntrypoint EpdDelegate cp = PlainLookupEntrypointExt EpdDelegate cp

data EpdWithRoot (r :: Symbol) (epd :: k) #

Extension of EpdPlain, EpdRecursive, and EpdDelegate which allow specifying root annotation for the parameters.

Instances

Instances details

(KnownSymbol r, PlainEntrypointsC deriv cp) => EntrypointsDerivation (EpdWithRoot r deriv :: Type) cp
Instance details Defined in Lorentz.Entrypoints.Impl Associated Types type EpdAllEntrypoints (EpdWithRoot r deriv) cp :: [(Symbol, Type)] # type EpdLookupEntrypoint (EpdWithRoot r deriv) cp :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT cp), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint (EpdWithRoot r deriv) cp name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints (EpdWithRoot r deriv) cp) #
type EpdAllEntrypoints (EpdWithRoot r deriv :: Type) cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdAllEntrypoints (EpdWithRoot r deriv :: Type) cp = '(r, cp) ': PlainAllEntrypointsExt deriv cp
type EpdLookupEntrypoint (EpdWithRoot r deriv :: Type) cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdLookupEntrypoint (EpdWithRoot r deriv :: Type) cp = Case '[Is (TyEqSing r :: Symbol -> Bool -> Type) ('Just cp), Else (PlainLookupEntrypointExt deriv cp)]

type family MemOpKeyHs c #

Instances

Instances details

type MemOpKeyHs (Set e)
Instance details Defined in Lorentz.Polymorphic type MemOpKeyHs (Set e) = e
type MemOpKeyHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type MemOpKeyHs (Map k v) = k
type MemOpKeyHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic type MemOpKeyHs (BigMap k v) = k

class (MemOp (ToT c), ToT (MemOpKeyHs c) ~ MemOpKey (ToT c)) => MemOpHs c #

Lifted MemOpKey.

Associated Types

type MemOpKeyHs c #

Instances

Instances details

NiceComparable e => MemOpHs (Set e)
Instance details Defined in Lorentz.Polymorphic Associated Types type MemOpKeyHs (Set e) #
NiceComparable k => MemOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type MemOpKeyHs (Map k v) #
NiceComparable k => MemOpHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type MemOpKeyHs (BigMap k v) #

type family IsoMapOpRes c b where ... #

A useful property which holds for reasonable MapOp instances.

It's a separate thing from MapOpHs because it mentions b type parameter.

Equations

IsoMapOpRes c b = ToT (MapOpResHs c b) ~ MapOpRes (ToT c) (ToT b)

type family MapOpResHs c :: Type -> Type #

Instances

Instances details

type MapOpResHs (Maybe e)
Instance details Defined in Lorentz.Polymorphic type MapOpResHs (Maybe e) = Maybe
type MapOpResHs [e]
Instance details Defined in Lorentz.Polymorphic type MapOpResHs [e] = []
type MapOpResHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type MapOpResHs (Map k v) = Map k

type family MapOpInpHs c #

Instances

Instances details

type MapOpInpHs (Maybe e)
Instance details Defined in Lorentz.Polymorphic type MapOpInpHs (Maybe e) = e
type MapOpInpHs [e]
Instance details Defined in Lorentz.Polymorphic type MapOpInpHs [e] = e
type MapOpInpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type MapOpInpHs (Map k v) = (k, v)

class (MapOp (ToT c), ToT (MapOpInpHs c) ~ MapOpInp (ToT c), ToT (MapOpResHs c ()) ~ MapOpRes (ToT c) (ToT ())) => MapOpHs c #

Lifted MapOp.

Associated Types

type MapOpInpHs c #

type MapOpResHs c :: Type -> Type #

Instances

Instances details

MapOpHs (Maybe e)
Instance details Defined in Lorentz.Polymorphic Associated Types type MapOpInpHs (Maybe e) # type MapOpResHs (Maybe e) :: Type -> Type #
MapOpHs [e]
Instance details Defined in Lorentz.Polymorphic Associated Types type MapOpInpHs [e] # type MapOpResHs [e] :: Type -> Type #
NiceComparable k => MapOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type MapOpInpHs (Map k v) # type MapOpResHs (Map k v) :: Type -> Type #

type family IterOpElHs c #

Instances

Instances details

type IterOpElHs (Set e)
Instance details Defined in Lorentz.Polymorphic type IterOpElHs (Set e) = e
type IterOpElHs [e]
Instance details Defined in Lorentz.Polymorphic type IterOpElHs [e] = e
type IterOpElHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type IterOpElHs (Map k v) = (k, v)

class (IterOp (ToT c), ToT (IterOpElHs c) ~ IterOpEl (ToT c)) => IterOpHs c #

Lifted IterOp.

Associated Types

type IterOpElHs c #

Instances

Instances details

NiceComparable e => IterOpHs (Set e)
Instance details Defined in Lorentz.Polymorphic Associated Types type IterOpElHs (Set e) #
IterOpHs [e]
Instance details Defined in Lorentz.Polymorphic Associated Types type IterOpElHs [e] #
NiceComparable k => IterOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type IterOpElHs (Map k v) #

class SizeOp (ToT c) => SizeOpHs c #

Lifted SizeOp.

This could be just a constraint alias, but to avoid T types appearance in error messages we make a full type class with concrete instances.

Instances

Instances details

SizeOpHs ByteString
Instance details Defined in Lorentz.Polymorphic
SizeOpHs MText
Instance details Defined in Lorentz.Polymorphic
SizeOpHs (Set a)
Instance details Defined in Lorentz.Polymorphic
SizeOpHs [a]
Instance details Defined in Lorentz.Polymorphic
SizeOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic

type family UpdOpParamsHs c #

Instances

Instances details

type UpdOpParamsHs (Set a)
Instance details Defined in Lorentz.Polymorphic type UpdOpParamsHs (Set a) = Bool
type UpdOpParamsHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type UpdOpParamsHs (Map k v) = Maybe v
type UpdOpParamsHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic type UpdOpParamsHs (BigMap k v) = Maybe v

type family UpdOpKeyHs c #

Instances

Instances details

type UpdOpKeyHs (Set a)
Instance details Defined in Lorentz.Polymorphic type UpdOpKeyHs (Set a) = a
type UpdOpKeyHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type UpdOpKeyHs (Map k v) = k
type UpdOpKeyHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic type UpdOpKeyHs (BigMap k v) = k

class (UpdOp (ToT c), ToT (UpdOpKeyHs c) ~ UpdOpKey (ToT c), ToT (UpdOpParamsHs c) ~ UpdOpParams (ToT c)) => UpdOpHs c #

Lifted UpdOp.

Associated Types

type UpdOpKeyHs c #

type UpdOpParamsHs c #

Instances

Instances details

NiceComparable a => UpdOpHs (Set a)
Instance details Defined in Lorentz.Polymorphic Associated Types type UpdOpKeyHs (Set a) # type UpdOpParamsHs (Set a) #
NiceComparable k => UpdOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type UpdOpKeyHs (Map k v) # type UpdOpParamsHs (Map k v) #
NiceComparable k => UpdOpHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type UpdOpKeyHs (BigMap k v) # type UpdOpParamsHs (BigMap k v) #

type family GetOpValHs c #

Instances

Instances details

type GetOpValHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type GetOpValHs (Map k v) = v
type GetOpValHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic type GetOpValHs (BigMap k v) = v

type family GetOpKeyHs c #

Instances

Instances details

type GetOpKeyHs (Map k v)
Instance details Defined in Lorentz.Polymorphic type GetOpKeyHs (Map k v) = k
type GetOpKeyHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic type GetOpKeyHs (BigMap k v) = k

class (GetOp (ToT c), ToT (GetOpKeyHs c) ~ GetOpKey (ToT c), ToT (GetOpValHs c) ~ GetOpVal (ToT c)) => GetOpHs c #

Lifted GetOp.

Associated Types

type GetOpKeyHs c #

type GetOpValHs c #

Instances

Instances details

NiceComparable k => GetOpHs (Map k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type GetOpKeyHs (Map k v) # type GetOpValHs (Map k v) #
NiceComparable k => GetOpHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type GetOpKeyHs (BigMap k v) # type GetOpValHs (BigMap k v) #

class ConcatOp (ToT c) => ConcatOpHs c #

Lifted ConcatOp.

Instances

Instances details

ConcatOpHs ByteString
Instance details Defined in Lorentz.Polymorphic
ConcatOpHs MText
Instance details Defined in Lorentz.Polymorphic

class SliceOp (ToT c) => SliceOpHs c #

Lifted SliceOp.

Instances

Instances details

SliceOpHs ByteString
Instance details Defined in Lorentz.Polymorphic
SliceOpHs MText
Instance details Defined in Lorentz.Polymorphic

newtype PrintAsValue a #

Provides Buildable instance that prints Lorentz value via Michelson's Value.

Result won't be very pretty, but this avoids requiring Show or Buildable instances.

Constructors

PrintAsValue a

Instances

Instances details

NiceUntypedValue a => Buildable (PrintAsValue a)
Instance details Defined in Lorentz.Value Methods build :: PrintAsValue a -> Builder #

data OpenChest #

Instances

Instances details

Generic OpenChest
Instance details Defined in Lorentz.Value Associated Types type Rep OpenChest :: Type -> Type # Methods from :: OpenChest -> Rep OpenChest x # to :: Rep OpenChest x -> OpenChest #
Show OpenChest
Instance details Defined in Lorentz.Value Methods showsPrec :: Int -> OpenChest -> ShowS # show :: OpenChest -> String # showList :: [OpenChest] -> ShowS #
Eq OpenChest
Instance details Defined in Lorentz.Value Methods (==) :: OpenChest -> OpenChest -> Bool # (/=) :: OpenChest -> OpenChest -> Bool #
HasAnnotation OpenChest
Instance details Defined in Lorentz.Value Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT OpenChest) # annOptions :: Maybe AnnOptions #
TypeHasDoc OpenChest
Instance details Defined in Lorentz.Value Associated Types type TypeDocFieldDescriptions OpenChest :: FieldDescriptions # Methods typeDocName :: Proxy OpenChest -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy OpenChest -> WithinParens -> Markdown # typeDocDependencies :: Proxy OpenChest -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep OpenChest # typeDocMichelsonRep :: TypeDocMichelsonRep OpenChest #
IsoValue OpenChest
Instance details Defined in Lorentz.Value Associated Types type ToT OpenChest :: T # Methods toVal :: OpenChest -> Value (ToT OpenChest) # fromVal :: Value (ToT OpenChest) -> OpenChest #
type Rep OpenChest
Instance details Defined in Lorentz.Value type Rep OpenChest = D1 ('MetaData "OpenChest" "Lorentz.Value" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'False) (C1 ('MetaCons "ChestContent" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ByteString)) :+: C1 ('MetaCons "ChestOpenFailed" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Bool)))
type TypeDocFieldDescriptions OpenChest
Instance details Defined in Lorentz.Value type TypeDocFieldDescriptions OpenChest = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT OpenChest
Instance details Defined in Lorentz.Value type ToT OpenChest = GValueType (Rep OpenChest)

type List = [] #

data Never #

Instances

Instances details

Generic Never
Instance details Defined in Lorentz.Value Associated Types type Rep Never :: Type -> Type # Methods from :: Never -> Rep Never x # to :: Rep Never x -> Never #
Show Never
Instance details Defined in Lorentz.Value Methods showsPrec :: Int -> Never -> ShowS # show :: Never -> String # showList :: [Never] -> ShowS #
NFData Never
Instance details Defined in Lorentz.Value Methods rnf :: Never -> () #
Buildable Never
Instance details Defined in Lorentz.Value Methods build :: Never -> Builder #
Eq Never
Instance details Defined in Lorentz.Value Methods (==) :: Never -> Never -> Bool # (/=) :: Never -> Never -> Bool #
Ord Never
Instance details Defined in Lorentz.Value Methods compare :: Never -> Never -> Ordering # (<) :: Never -> Never -> Bool # (<=) :: Never -> Never -> Bool # (>) :: Never -> Never -> Bool # (>=) :: Never -> Never -> Bool # max :: Never -> Never -> Never # min :: Never -> Never -> Never #
HasAnnotation Never
Instance details Defined in Lorentz.Value Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Never) # annOptions :: Maybe AnnOptions #
HasRPCRepr Never
Instance details Defined in Lorentz.Value Associated Types type AsRPC Never #
TypeHasDoc Never
Instance details Defined in Lorentz.Value Associated Types type TypeDocFieldDescriptions Never :: FieldDescriptions # Methods typeDocName :: Proxy Never -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Never -> WithinParens -> Markdown # typeDocDependencies :: Proxy Never -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Never # typeDocMichelsonRep :: TypeDocMichelsonRep Never #
IsoValue Never
Instance details Defined in Lorentz.Value Associated Types type ToT Never :: T # Methods toVal :: Never -> Value (ToT Never) # fromVal :: Value (ToT Never) -> Never #
type Rep Never
Instance details Defined in Lorentz.Value type Rep Never = D1 ('MetaData "Never" "Lorentz.Value" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'False) (V1 :: Type -> Type)
type AsRPC Never
Instance details Defined in Lorentz.Value type AsRPC Never = Never
type TypeDocFieldDescriptions Never
Instance details Defined in Lorentz.Value type TypeDocFieldDescriptions Never = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Never
Instance details Defined in Lorentz.Value type ToT Never = GValueType (Rep Never)

data ReadTicket a #

Value returned by READ_TICKET instruction.

Constructors

ReadTicket
Fields rtTicketer :: Address rtData :: a rtAmount :: Natural

Instances

Instances details

Generic (ReadTicket a)
Instance details Defined in Lorentz.Value Associated Types type Rep (ReadTicket a) :: Type -> Type # Methods from :: ReadTicket a -> Rep (ReadTicket a) x # to :: Rep (ReadTicket a) x -> ReadTicket a #
Show a => Show (ReadTicket a)
Instance details Defined in Lorentz.Value Methods showsPrec :: Int -> ReadTicket a -> ShowS # show :: ReadTicket a -> String # showList :: [ReadTicket a] -> ShowS #
Eq a => Eq (ReadTicket a)
Instance details Defined in Lorentz.Value Methods (==) :: ReadTicket a -> ReadTicket a -> Bool # (/=) :: ReadTicket a -> ReadTicket a -> Bool #
Ord a => Ord (ReadTicket a)
Instance details Defined in Lorentz.Value Methods compare :: ReadTicket a -> ReadTicket a -> Ordering # (<) :: ReadTicket a -> ReadTicket a -> Bool # (<=) :: ReadTicket a -> ReadTicket a -> Bool # (>) :: ReadTicket a -> ReadTicket a -> Bool # (>=) :: ReadTicket a -> ReadTicket a -> Bool # max :: ReadTicket a -> ReadTicket a -> ReadTicket a # min :: ReadTicket a -> ReadTicket a -> ReadTicket a #
IsoValue a => IsoValue (ReadTicket a)
Instance details Defined in Lorentz.Value Associated Types type ToT (ReadTicket a) :: T # Methods toVal :: ReadTicket a -> Value (ToT (ReadTicket a)) # fromVal :: Value (ToT (ReadTicket a)) -> ReadTicket a #
type Rep (ReadTicket a)
Instance details Defined in Lorentz.Value type Rep (ReadTicket a) = D1 ('MetaData "ReadTicket" "Lorentz.Value" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'False) (C1 ('MetaCons "ReadTicket" 'PrefixI 'True) (S1 ('MetaSel ('Just "rtTicketer") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Constrained (NullConstraint :: AddressKind -> Constraint) KindedAddress)) :: (S1 ('MetaSel ('Just "rtData") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 a) :: S1 ('MetaSel ('Just "rtAmount") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Natural))))
type ToT (ReadTicket a)
Instance details Defined in Lorentz.Value type ToT (ReadTicket a) = GValueType (Rep (ReadTicket a))

convertContractRef :: forall cp contract2 contract1. (ToContractRef cp contract1, FromContractRef cp contract2) => contract1 -> contract2 #

callingDefAddress :: (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> ContractRef (GetDefaultEntrypointArg cp) #

Specialization of callingAddress to call the default entrypoint.

callingAddress :: forall cp vd addr (mname :: Maybe Symbol). (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> EntrypointRef mname -> ContractRef (GetEntrypointArgCustom cp mname) #

Turn any typed address to ContractRef in Haskell world.

This is an analogy of address to contract convertion in Michelson world, thus you have to supply an entrypoint (or call the default one explicitly).

newtype TAddress p vd #

Address which remembers the parameter and views types of the contract it refers to.

It differs from Michelson's contract type because it cannot contain entrypoint, and it always refers to entire contract parameter even if this contract has explicit default entrypoint.

Constructors

TAddress
Fields unTAddress :: Address

Instances

Instances details

(cp ~ cp', vd ~ vd') => ToTAddress cp vd (TAddress cp' vd')
Instance details Defined in Lorentz.Address Methods toTAddress :: TAddress cp' vd' -> TAddress cp vd #
CanCastTo Address (TAddress p vd :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy Address -> Proxy (TAddress p vd) -> () #
(FailWhen cond msg, cond ~ (CanHaveEntrypoints cp && Not (ParameterEntrypointsDerivation cp == EpdNone)), msg ~ (((('Text "Cannot apply `ToContractRef` to `TAddress`" :$$: 'Text "Consider using call(Def)TAddress first`") :$$: 'Text "(or if you know your parameter type is primitive,") :$$: 'Text " make sure typechecker also knows about that)") :$$: (('Text "For parameter `" :<>: 'ShowType cp) :<>: 'Text "`")), cp ~ arg, NiceParameter arg, NiceParameterFull cp, GetDefaultEntrypointArg cp ~ cp) => ToContractRef arg (TAddress cp vd)
Instance details Defined in Lorentz.Address Methods toContractRef :: TAddress cp vd -> ContractRef arg #
CanCastTo (TAddress p vd :: Type) Address
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (TAddress p vd) -> Proxy Address -> () #
Generic (TAddress p vd)
Instance details Defined in Lorentz.Address Associated Types type Rep (TAddress p vd) :: Type -> Type # Methods from :: TAddress p vd -> Rep (TAddress p vd) x # to :: Rep (TAddress p vd) x -> TAddress p vd #
Show (TAddress p vd)
Instance details Defined in Lorentz.Address Methods showsPrec :: Int -> TAddress p vd -> ShowS # show :: TAddress p vd -> String # showList :: [TAddress p vd] -> ShowS #
Buildable (TAddress p vd)
Instance details Defined in Lorentz.Address Methods build :: TAddress p vd -> Builder #
Eq (TAddress p vd)
Instance details Defined in Lorentz.Address Methods (==) :: TAddress p vd -> TAddress p vd -> Bool # (/=) :: TAddress p vd -> TAddress p vd -> Bool #
Ord (TAddress p vd)
Instance details Defined in Lorentz.Address Methods compare :: TAddress p vd -> TAddress p vd -> Ordering # (<) :: TAddress p vd -> TAddress p vd -> Bool # (<=) :: TAddress p vd -> TAddress p vd -> Bool # (>) :: TAddress p vd -> TAddress p vd -> Bool # (>=) :: TAddress p vd -> TAddress p vd -> Bool # max :: TAddress p vd -> TAddress p vd -> TAddress p vd # min :: TAddress p vd -> TAddress p vd -> TAddress p vd #
ToAddress (TAddress cp vd)
Instance details Defined in Lorentz.Address Methods toAddress :: TAddress cp vd -> Address #
HasAnnotation (TAddress p vd)
Instance details Defined in Lorentz.Address Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (TAddress p vd)) # annOptions :: Maybe AnnOptions #
HasRPCRepr (TAddress cp vd)
Instance details Defined in Lorentz.Address Associated Types type AsRPC (TAddress cp vd) #
IsoValue (TAddress p vd)
Instance details Defined in Lorentz.Address Associated Types type ToT (TAddress p vd) :: T # Methods toVal :: TAddress p vd -> Value (ToT (TAddress p vd)) # fromVal :: Value (ToT (TAddress p vd)) -> TAddress p vd #
type Rep (TAddress p vd)
Instance details Defined in Lorentz.Address type Rep (TAddress p vd) = D1 ('MetaData "TAddress" "Lorentz.Address" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'True) (C1 ('MetaCons "TAddress" 'PrefixI 'True) (S1 ('MetaSel ('Just "unTAddress") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Address)))
type AsRPC (TAddress cp vd)
Instance details Defined in Lorentz.Address type AsRPC (TAddress cp vd) = TAddress cp vd
type TypeDocFieldDescriptions (TAddress p vd)
Instance details Defined in Lorentz.Doc type TypeDocFieldDescriptions (TAddress p vd) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (TAddress p vd)
Instance details Defined in Lorentz.Address type ToT (TAddress p vd) = GValueType (Rep (TAddress p vd))

newtype FutureContract arg #

Address associated with value of contract arg type.

Places where ContractRef can appear are now severely limited, this type gives you type-safety of ContractRef but still can be used everywhere. This type is not a full-featured one rather a helper; in particular, once pushing it on stack, you cannot return it back to Haskell world.

Note that it refers to an entrypoint of the contract, not just the contract as a whole. In this sense this type differs from TAddress.

Unlike with ContractRef, having this type you still cannot be sure that the referred contract exists and need to perform a lookup before calling it.

Constructors

FutureContract
Fields unFutureContract :: ContractRef arg

Instances

Instances details

cp ~ cp' => FromContractRef cp (FutureContract cp')
Instance details Defined in Lorentz.Address Methods fromContractRef :: ContractRef cp -> FutureContract cp' #
(NiceParameter cp, cp ~ cp') => ToContractRef cp (FutureContract cp')
Instance details Defined in Lorentz.Address Methods toContractRef :: FutureContract cp' -> ContractRef cp #
ToAddress (FutureContract cp)
Instance details Defined in Lorentz.Address Methods toAddress :: FutureContract cp -> Address #
HasAnnotation (FutureContract a)
Instance details Defined in Lorentz.Address Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (FutureContract a)) # annOptions :: Maybe AnnOptions #
HasRPCRepr (FutureContract p)
Instance details Defined in Lorentz.Address Associated Types type AsRPC (FutureContract p) #
IsoValue (FutureContract arg)
Instance details Defined in Lorentz.Address Associated Types type ToT (FutureContract arg) :: T # Methods toVal :: FutureContract arg -> Value (ToT (FutureContract arg)) # fromVal :: Value (ToT (FutureContract arg)) -> FutureContract arg #
CanCastTo (FutureContract p :: Type) EpAddress
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (FutureContract p) -> Proxy EpAddress -> () #
type AsRPC (FutureContract p)
Instance details Defined in Lorentz.Address type AsRPC (FutureContract p) = FutureContract p
type TypeDocFieldDescriptions (FutureContract p)
Instance details Defined in Lorentz.Doc type TypeDocFieldDescriptions (FutureContract p) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (FutureContract arg)
Instance details Defined in Lorentz.Address type ToT (FutureContract arg) = ToT EpAddress

class ToAddress a where #

Convert something to Address in Haskell world.

Use this when you want to access state of the contract and are not interested in calling it.

Methods

toAddress :: a -> Address #

Instances

Instances details

ToAddress EpAddress
Instance details Defined in Lorentz.Address Methods toAddress :: EpAddress -> Address #
ToAddress Address
Instance details Defined in Lorentz.Address Methods toAddress :: Address -> Address #
ToAddress L1Address
Instance details Defined in Lorentz.Address Methods toAddress :: L1Address -> Address #
ToAddress (FutureContract cp)
Instance details Defined in Lorentz.Address Methods toAddress :: FutureContract cp -> Address #
ToAddress (ContractRef cp)
Instance details Defined in Lorentz.Address Methods toAddress :: ContractRef cp -> Address #
ToAddress (KindedAddress kind)
Instance details Defined in Lorentz.Address Methods toAddress :: KindedAddress kind -> Address #
ToAddress (TAddress cp vd)
Instance details Defined in Lorentz.Address Methods toAddress :: TAddress cp vd -> Address #

class ToTAddress cp vd a where #

Convert something referring to a contract (not specific entrypoint) to TAddress in Haskell world.

Methods

toTAddress :: a -> TAddress cp vd #

Instances

Instances details

ToTAddress cp vd Address
Instance details Defined in Lorentz.Address Methods toTAddress :: Address -> TAddress cp vd #
ToTAddress cp vd ContractAddress
Instance details Defined in Lorentz.Address Methods toTAddress :: ContractAddress -> TAddress cp vd #
(ImplicitContractParameter cp (ToT cp), vd ~ ()) => ToTAddress cp vd ImplicitAddress
Instance details Defined in Lorentz.Address Methods toTAddress :: ImplicitAddress -> TAddress cp vd #
ToTAddress cp vd L1Address
Instance details Defined in Lorentz.Address Methods toTAddress :: L1Address -> TAddress cp vd #
vd ~ () => ToTAddress cp vd SmartRollupAddress
Instance details Defined in Lorentz.Address Methods toTAddress :: SmartRollupAddress -> TAddress cp vd #
(cp ~ cp', vd ~ vd') => ToTAddress cp vd (TAddress cp' vd')
Instance details Defined in Lorentz.Address Methods toTAddress :: TAddress cp' vd' -> TAddress cp vd #

class ToContractRef cp contract where #

Convert something to ContractRef in Haskell world.

Methods

toContractRef :: contract -> ContractRef cp #

Instances

Instances details

(NiceParameter cp, cp ~ cp') => ToContractRef cp (FutureContract cp')
Instance details Defined in Lorentz.Address Methods toContractRef :: FutureContract cp' -> ContractRef cp #
cp ~ cp' => ToContractRef cp (ContractRef cp')
Instance details Defined in Lorentz.Address Methods toContractRef :: ContractRef cp' -> ContractRef cp #
(FailWhen cond msg, cond ~ (CanHaveEntrypoints cp && Not (ParameterEntrypointsDerivation cp == EpdNone)), msg ~ (((('Text "Cannot apply `ToContractRef` to `TAddress`" :$$: 'Text "Consider using call(Def)TAddress first`") :$$: 'Text "(or if you know your parameter type is primitive,") :$$: 'Text " make sure typechecker also knows about that)") :$$: (('Text "For parameter `" :<>: 'ShowType cp) :<>: 'Text "`")), cp ~ arg, NiceParameter arg, NiceParameterFull cp, GetDefaultEntrypointArg cp ~ cp) => ToContractRef arg (TAddress cp vd)
Instance details Defined in Lorentz.Address Methods toContractRef :: TAddress cp vd -> ContractRef arg #

class FromContractRef cp contract where #

Convert something from ContractRef in Haskell world.

Methods

fromContractRef :: ContractRef cp -> contract #

Instances

Instances details

FromContractRef cp EpAddress
Instance details Defined in Lorentz.Address Methods fromContractRef :: ContractRef cp -> EpAddress #
FromContractRef cp Address
Instance details Defined in Lorentz.Address Methods fromContractRef :: ContractRef cp -> Address #
cp ~ cp' => FromContractRef cp (FutureContract cp')
Instance details Defined in Lorentz.Address Methods fromContractRef :: ContractRef cp -> FutureContract cp' #
cp ~ cp' => FromContractRef cp (ContractRef cp')
Instance details Defined in Lorentz.Address Methods fromContractRef :: ContractRef cp -> ContractRef cp' #

type Entrypoint param store = '[param, store] :-> ContractOut store #

Single entrypoint of a contract.

Note that we cannot make it return [[Operation], store] because such entrypoint should've been followed by pair, and this is not possible if entrypoint implementation ends with failWith.

type Entrypoint_ store = '[store] :-> ContractOut store #

Version of Entrypoint which accepts no argument.

stackType :: forall (s :: [Type]). s :-> s #

Fix the current type of the stack to be given one.

stackType @'[Natural]
stackType @(Integer : Natural : s)
stackType @'["balance" :! Integer, "toSpend" :! Integer, BigMap Address Integer]

Note that you can omit arbitrary parts of the type.

stackType @'["balance" :! Integer, "toSpend" :! _, BigMap _ _]

testAssert :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => Text -> PrintComment (ToTs inp) -> (inp :-> (Bool ': out)) -> inp :-> inp #

Test an invariant, fail if it does not hold.

This won't be included into production contract and is executed only in tests.

printComment :: forall (s :: [Type]). PrintComment (ToTs s) -> s :-> s #

Print a comment. It will be visible in tests.

printComment "Hello world!"
printComment $ "On top of the stack I see " <> stackRef @0

stackRef :: forall (gn :: Nat) (st :: [T]) (n :: Peano). (n ~ ToPeano gn, SingI n, RequireLongerThan st n) => PrintComment st #

Include a value at given position on stack into comment produced by printComment.

stackRef @0

the top of the stack

optimizeLorentz :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> inp :-> out #

optimizeLorentzWithConf :: forall (inp :: [Type]) (out :: [Type]). OptimizerConf -> (inp :-> out) -> inp :-> out #

transformBytesLorentz :: forall (inp :: [Type]) (out :: [Type]). Bool -> (ByteString -> ByteString) -> (inp :-> out) -> inp :-> out #

Lorentz version of transformBytes.

transformStringsLorentz :: forall (inp :: [Type]) (out :: [Type]). Bool -> (MText -> MText) -> (inp :-> out) -> inp :-> out #

Lorentz version of transformStrings.

parseLorentzValue :: KnownValue v => MichelsonSource -> Text -> Either ParseLorentzError v #

Parse textual representation of a Michelson value and turn it into corresponding Haskell value.

Note: it won't work in some complex cases, e. g. if there is a lambda which uses an instruction which depends on current contract's type. Obviously it can not work, because we don't have any information about a contract to which this value belongs (there is no such contract at all).

toMichelsonContract :: Contract cp st vd -> Contract (ToT cp) (ToT st) #

Demote Lorentz Contract to Michelson typed Contract.

mkContractCode :: (IsNotInView => '[(cp, st)] :-> ContractOut st) -> ContractCode cp st #

A helper to construct ContractCode that provides IsNotInView constraint.

iForceNotFail :: forall (i :: [Type]) (o :: [Type]). (i :-> o) -> i :-> o #

iMapAnyCode :: forall (i1 :: [Type]) (i2 :: [Type]) (o :: [Type]). (forall (o' :: [T]). Instr (ToTs i1) o' -> Instr (ToTs i2) o') -> (i1 :-> o) -> i2 :-> o #

iNonFailingCode :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => (inp :-> out) -> Instr (ToTs inp) (ToTs out) #

iAnyCode :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> Instr (ToTs inp) (ToTs out) #

iGenericIf :: forall (a :: [Type]) (b :: [Type]) (c :: [Type]) (s :: [Type]). (forall (s' :: [T]). Instr (ToTs a) s' -> Instr (ToTs b) s' -> Instr (ToTs c) s') -> (a :-> s) -> (b :-> s) -> c :-> s #

pattern I :: Instr (ToTs inp) (ToTs out) -> inp :-> out #

pattern FI :: (forall (out' :: [T]). Instr (ToTs inp) out') -> inp :-> out #

newtype (inp :: [Type]) :-> (out :: [Type]) infixr 1 #

Alias for instruction which hides inner types representation via T.

Constructors

LorentzInstr
Fields unLorentzInstr :: RemFail Instr (ToTs inp) (ToTs out)

Instances

Instances details

(CanCastTo (ZippedStack i1) (ZippedStack i2), CanCastTo (ZippedStack o1) (ZippedStack o2)) => CanCastTo (i1 :-> o1 :: Type) (i2 :-> o2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (i1 :-> o1) -> Proxy (i2 :-> o2) -> () #
Monoid (s :-> s)
Instance details Defined in Lorentz.Base Methods mempty :: s :-> s # mappend :: (s :-> s) -> (s :-> s) -> s :-> s # mconcat :: [s :-> s] -> s :-> s #
Semigroup (s :-> s)
Instance details Defined in Lorentz.Base Methods (<>) :: (s :-> s) -> (s :-> s) -> s :-> s # sconcat :: NonEmpty (s :-> s) -> s :-> s # stimes :: Integral b => b -> (s :-> s) -> s :-> s #
Show (inp :-> out)
Instance details Defined in Lorentz.Base Methods showsPrec :: Int -> (inp :-> out) -> ShowS # show :: (inp :-> out) -> String # showList :: [inp :-> out] -> ShowS #
NFData (i :-> o)
Instance details Defined in Lorentz.Base Methods rnf :: (i :-> o) -> () #
Buildable (inp :-> out)
Instance details Defined in Lorentz.Base Methods build :: (inp :-> out) -> Builder #
Eq (inp :-> out)
Instance details Defined in Lorentz.Base Methods (==) :: (inp :-> out) -> (inp :-> out) -> Bool # (/=) :: (inp :-> out) -> (inp :-> out) -> Bool #
NoLambdaCodeIsomorphismError => HasAnnotation (i :-> o)
Instance details Defined in Lorentz.Base Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (i :-> o)) # annOptions :: Maybe AnnOptions #
MapLorentzInstr (i :-> o)
Instance details Defined in Lorentz.Base Methods mapLorentzInstr :: (forall (i0 :: [Type]) (o0 :: [Type]). (i0 :-> o0) -> i0 :-> o0) -> (i :-> o) -> i :-> o #
RenderDoc (inp :-> out)
Instance details Defined in Lorentz.Base Methods renderDoc :: RenderContext -> (inp :-> out) -> Doc # isRenderable :: (inp :-> out) -> Bool #
(NoLambdaCodeIsomorphismError, WellTyped (LorentzCodeIsNotIsomorphicToMichelsonValues :: T)) => IsoValue (inp :-> out)
Instance details Defined in Lorentz.Base Associated Types type ToT (inp :-> out) :: T # Methods toVal :: (inp :-> out) -> Value (ToT (inp :-> out)) # fromVal :: Value (ToT (inp :-> out)) -> inp :-> out #
type ToT (inp :-> out)
Instance details Defined in Lorentz.Base type ToT (inp :-> out) = LorentzCodeIsNotIsomorphicToMichelsonValues :: T

type (%>) = (:->) infixr 1 #

Alias for :->, seems to make signatures more readable sometimes.

Let's someday decide which one of these two should remain.

type ContractOut st = '[([Operation], st)] #

newtype ContractCode cp st #

Wrap contract code capturing the constraint that the code is not inside a view.

Constructors

ContractCode
Fields unContractCode :: '[(cp, st)] :-> ContractOut st

Instances

Instances details

Show (ContractCode cp st)
Instance details Defined in Lorentz.Base Methods showsPrec :: Int -> ContractCode cp st -> ShowS # show :: ContractCode cp st -> String # showList :: [ContractCode cp st] -> ShowS #
NFData (ContractCode cp st)
Instance details Defined in Lorentz.Base Methods rnf :: ContractCode cp st -> () #
Eq (ContractCode cp st)
Instance details Defined in Lorentz.Base Methods (==) :: ContractCode cp st -> ContractCode cp st -> Bool # (/=) :: ContractCode cp st -> ContractCode cp st -> Bool #

data SomeContractCode where #

Constructors

SomeContractCode :: forall cp st. (NiceParameter cp, NiceStorage st) => ContractCode cp st -> SomeContractCode

type ViewCode arg st ret = '[(arg, st)] :-> '[ret] #

cMichelsonContract :: Contract cp st vd -> Contract (ToT cp) (ToT st) #

Ready contract code.

cDocumentedCode :: Contract cp st vd -> ContractCode cp st #

Contract that contains documentation.

We have to keep it separately, since optimizer is free to destroy documentation blocks. Also, it is not ContractDoc but Lorentz code because the latter is easier to modify.

type (&) a (b :: [Type]) = a ': b infixr 2 #

An alias for ':.

We discourage its use as this hinders reading error messages (the compiler inserts unnecessary parentheses and indentation).

type Fn a b = '[a] :-> '[b] #

An instruction sequence taking one stack element as input and returning one stack element as output. Essentially behaves as a Michelson lambda without any additional semantical meaning.

The reason for this distinction is Michelson lambdas allow instructions inside them that might be forbidden in the outer scope. This type doesn't add any such conditions.

class MapLorentzInstr instr where #

Applicable for wrappers over Lorentz code.

Methods

mapLorentzInstr :: (forall (i :: [Type]) (o :: [Type]). (i :-> o) -> i :-> o) -> instr -> instr #

Modify all the code under given entity.

Instances

Instances details

MapLorentzInstr (i :-> o)
Instance details Defined in Lorentz.Base Methods mapLorentzInstr :: (forall (i0 :: [Type]) (o0 :: [Type]). (i0 :-> o0) -> i0 :-> o0) -> (i :-> o) -> i :-> o #
MapLorentzInstr (WrappedLambda inp out)
Instance details Defined in Lorentz.Lambda Methods mapLorentzInstr :: (forall (i :: [Type]) (o :: [Type]). (i :-> o) -> i :-> o) -> WrappedLambda inp out -> WrappedLambda inp out #

decideOnDupable :: KnownValue a => DupableDecision a #

Check whether given value is dupable, returning a proof of that when it is.

This lets defining methods that behave differently depending on whether given value is dupable or not. This may be suitable when for the dupable case you can provide a more efficient implementation, but you also want your implementation to be generic.

Example:

code = case decideOnDupable @a of
  IsDupable -> do dup; ...
  IsNotDupable -> ...

type NiceParameterFull cp = (Typeable cp, ParameterDeclaresEntrypoints cp) #

Constraint applied to a whole parameter type.

data DupableDecision a #

Tells whether given type is dupable or not.

Constructors

Dupable a => IsDupable
IsNotDupable

type NiceViews (vs :: [ViewTyInfo]) = RequireAllUnique "view" (ViewsNames vs) #

Require views set to be proper.

type NiceViewsDescriptor vd = NiceViews (RevealViews vd) #

Require views set referred by the given views descriptor to be proper.

parameterEntrypointCallCustom :: forall cp (mname :: Maybe Symbol). ParameterDeclaresEntrypoints cp => EntrypointRef mname -> EntrypointCall cp (GetEntrypointArgCustom cp mname) #

Universal entrypoint calling.

eprName :: forall (mname :: Maybe Symbol). EntrypointRef mname -> EpName #

sepcCallRootChecked :: (NiceParameter cp, ForbidExplicitDefaultEntrypoint cp) => SomeEntrypointCall cp #

Call root entrypoint safely.

parameterEntrypointCallDefault :: ParameterDeclaresEntrypoints cp => EntrypointCall cp (GetDefaultEntrypointArg cp) #

Call the default entrypoint.

parameterEntrypointCall :: forall cp (name :: Symbol). ParameterDeclaresEntrypoints cp => Label name -> EntrypointCall cp (GetEntrypointArg cp name) #

Prepare call to given entrypoint.

This does not treat calls to default entrypoint in a special way. To call default entrypoint properly use parameterEntrypointCallDefault.

parameterEntrypointsToNotes :: ParameterDeclaresEntrypoints cp => ParamNotes (ToT cp) #

Derive annotations for given parameter.

type family EpdLookupEntrypoint (deriv :: k) cp :: Symbol -> Exp (Maybe Type) #

Get entrypoint argument by name.

Instances

Instances details

type EpdLookupEntrypoint EpdNone cp
Instance details Defined in Lorentz.Entrypoints.Core type EpdLookupEntrypoint EpdNone cp = ConstFn ('Nothing :: Maybe Type) :: Symbol -> Maybe Type -> Type
type EpdLookupEntrypoint EpdDelegate cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdLookupEntrypoint EpdDelegate cp = PlainLookupEntrypointExt EpdDelegate cp
type EpdLookupEntrypoint EpdPlain cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdLookupEntrypoint EpdPlain cp = PlainLookupEntrypointExt EpdPlain cp
type EpdLookupEntrypoint EpdRecursive cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdLookupEntrypoint EpdRecursive cp = PlainLookupEntrypointExt EpdRecursive cp
type EpdLookupEntrypoint (PwDeriv deriv :: Type) (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual type EpdLookupEntrypoint (PwDeriv deriv :: Type) (ParameterWrapper deriv cp) = EpdLookupEntrypoint deriv cp
type EpdLookupEntrypoint (EpdWithRoot r deriv :: Type) cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdLookupEntrypoint (EpdWithRoot r deriv :: Type) cp = Case '[Is (TyEqSing r :: Symbol -> Bool -> Type) ('Just cp), Else (PlainLookupEntrypointExt deriv cp)]

type family EpdAllEntrypoints (deriv :: k) cp :: [(Symbol, Type)] #

Name and argument of each entrypoint. This may include intermediate ones, even root if necessary.

Touching this type family is costly (O(N^2)), don't use it often.

Note [order of entrypoints children]: If this contains entrypoints referring to indermediate nodes (not leaves) in or tree, then each such entrypoint should be mentioned eariler than all of its children.

Instances

Instances details

type EpdAllEntrypoints EpdNone cp
Instance details Defined in Lorentz.Entrypoints.Core type EpdAllEntrypoints EpdNone cp = '[] :: [(Symbol, Type)]
type EpdAllEntrypoints EpdDelegate cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdAllEntrypoints EpdDelegate cp = PlainAllEntrypointsExt EpdDelegate cp
type EpdAllEntrypoints EpdPlain cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdAllEntrypoints EpdPlain cp = PlainAllEntrypointsExt EpdPlain cp
type EpdAllEntrypoints EpdRecursive cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdAllEntrypoints EpdRecursive cp = PlainAllEntrypointsExt EpdRecursive cp
type EpdAllEntrypoints (PwDeriv deriv :: Type) (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual type EpdAllEntrypoints (PwDeriv deriv :: Type) (ParameterWrapper deriv cp) = EpdAllEntrypoints deriv cp
type EpdAllEntrypoints (EpdWithRoot r deriv :: Type) cp
Instance details Defined in Lorentz.Entrypoints.Impl type EpdAllEntrypoints (EpdWithRoot r deriv :: Type) cp = '(r, cp) ': PlainAllEntrypointsExt deriv cp

class EntrypointsDerivation (deriv :: k) cp where #

Defines a generalized way to declare entrypoints for various parameter types.

When defining instances of this typeclass, set concrete deriv argument and leave variable cp argument. Also keep in mind, that in presence of explicit default entrypoint, all other Or arms should be callable, though you can put this burden on user if very necessary.

Methods of this typeclass aim to better type-safety when making up an implementation and they may be not too convenient to use; users should exploit their counterparts.

Associated Types

type EpdAllEntrypoints (deriv :: k) cp :: [(Symbol, Type)] #

Name and argument of each entrypoint. This may include intermediate ones, even root if necessary.

Touching this type family is costly (O(N^2)), don't use it often.

Note [order of entrypoints children]: If this contains entrypoints referring to indermediate nodes (not leaves) in or tree, then each such entrypoint should be mentioned eariler than all of its children.

type EpdLookupEntrypoint (deriv :: k) cp :: Symbol -> Exp (Maybe Type) #

Get entrypoint argument by name.

Methods

epdNotes :: (Notes (ToT cp), RootAnn) #

Construct parameter annotations corresponding to expected entrypoints set.

This method is implementation detail, for actual notes construction use parameterEntrypointsToNotes.

epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint deriv cp name)) #

Construct entrypoint caller.

This does not treat calls to default entrypoint in a special way.

This method is implementation detail, for actual entrypoint lookup use parameterEntrypointCall.

epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints deriv cp) #

Description of how each of the entrypoints is constructed.

Instances

Instances details

HasAnnotation cp => EntrypointsDerivation EpdNone cp
Instance details Defined in Lorentz.Entrypoints.Core Associated Types type EpdAllEntrypoints EpdNone cp :: [(Symbol, Type)] # type EpdLookupEntrypoint EpdNone cp :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT cp), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint EpdNone cp name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints EpdNone cp) #
PlainEntrypointsC EpdDelegate cp => EntrypointsDerivation EpdDelegate cp
Instance details Defined in Lorentz.Entrypoints.Impl Associated Types type EpdAllEntrypoints EpdDelegate cp :: [(Symbol, Type)] # type EpdLookupEntrypoint EpdDelegate cp :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT cp), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint EpdDelegate cp name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints EpdDelegate cp) #
PlainEntrypointsC EpdPlain cp => EntrypointsDerivation EpdPlain cp
Instance details Defined in Lorentz.Entrypoints.Impl Associated Types type EpdAllEntrypoints EpdPlain cp :: [(Symbol, Type)] # type EpdLookupEntrypoint EpdPlain cp :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT cp), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint EpdPlain cp name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints EpdPlain cp) #
PlainEntrypointsC EpdRecursive cp => EntrypointsDerivation EpdRecursive cp
Instance details Defined in Lorentz.Entrypoints.Impl Associated Types type EpdAllEntrypoints EpdRecursive cp :: [(Symbol, Type)] # type EpdLookupEntrypoint EpdRecursive cp :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT cp), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint EpdRecursive cp name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints EpdRecursive cp) #
EntrypointsDerivation deriv cp => EntrypointsDerivation (PwDeriv deriv :: Type) (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type EpdAllEntrypoints (PwDeriv deriv) (ParameterWrapper deriv cp) :: [(Symbol, Type)] # type EpdLookupEntrypoint (PwDeriv deriv) (ParameterWrapper deriv cp) :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT (ParameterWrapper deriv cp)), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT (ParameterWrapper deriv cp)) => Label name -> EpConstructionRes (ToT (ParameterWrapper deriv cp)) (Eval (EpdLookupEntrypoint (PwDeriv deriv) (ParameterWrapper deriv cp) name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints (PwDeriv deriv) (ParameterWrapper deriv cp)) #
(KnownSymbol r, PlainEntrypointsC deriv cp) => EntrypointsDerivation (EpdWithRoot r deriv :: Type) cp
Instance details Defined in Lorentz.Entrypoints.Impl Associated Types type EpdAllEntrypoints (EpdWithRoot r deriv) cp :: [(Symbol, Type)] # type EpdLookupEntrypoint (EpdWithRoot r deriv) cp :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT cp), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint (EpdWithRoot r deriv) cp name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints (EpdWithRoot r deriv) cp) #

type RequireAllUniqueEntrypoints cp = RequireAllUniqueEntrypoints' (ParameterEntrypointsDerivation cp) cp #

Ensure that all declared entrypoints are unique.

type family ParameterEntrypointsDerivation cp #

Instances

Instances details

type ParameterEntrypointsDerivation (ParameterWrapper epd cp)
Instance details Defined in Lorentz.Entrypoints.Manual type ParameterEntrypointsDerivation (ParameterWrapper epd cp) = PwDeriv epd

class (EntrypointsDerivation (ParameterEntrypointsDerivation cp) cp, RequireAllUniqueEntrypoints cp) => ParameterHasEntrypoints cp #

Which entrypoints given parameter declares.

Note that usually this function should not be used as constraint, use ParameterDeclaresEntrypoints for this purpose.

Associated Types

type ParameterEntrypointsDerivation cp #

Instances

Instances details

(NiceParameter cp, EntrypointsDerivation epd cp, RequireAllUniqueEntrypoints' epd cp) => ParameterHasEntrypoints (ParameterWrapper epd cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type ParameterEntrypointsDerivation (ParameterWrapper epd cp) #

type ParameterDeclaresEntrypoints cp = (If (CanHaveEntrypoints cp) (ParameterHasEntrypoints cp) (), NiceParameter cp, EntrypointsDerivation (GetParameterEpDerivation cp) cp) #

Parameter declares some entrypoints.

This is a version of ParameterHasEntrypoints which we actually use in constraints. When given type is a sum type or newtype, we refer to ParameterHasEntrypoints instance, otherwise this instance is not necessary.

type family AllParameterEntrypoints cp :: [(Symbol, Type)] where ... #

Get all entrypoints declared for parameter.

Equations

AllParameterEntrypoints cp = EpdAllEntrypoints (GetParameterEpDerivation cp) cp

type family LookupParameterEntrypoint cp :: Symbol -> Exp (Maybe Type) where ... #

Lookup for entrypoint type by name.

Does not treat default entrypoints in a special way.

Equations

LookupParameterEntrypoint cp = EpdLookupEntrypoint (GetParameterEpDerivation cp) cp

type GetEntrypointArg cp (name :: Symbol) = Eval (LiftM2 (FromMaybe :: Type -> Maybe Type -> Type -> Type) (TError (('Text "Entrypoint not found: " :<>: 'ShowType name) :$$: (('Text "In contract parameter `" :<>: 'ShowType cp) :<>: 'Text "`")) :: Type -> Type) (LookupParameterEntrypoint cp name)) #

Get type of entrypoint with given name, fail if not found.

type GetDefaultEntrypointArg cp = Eval (LiftM2 (FromMaybe :: Type -> Maybe Type -> Type -> Type) (Pure cp) (LookupParameterEntrypoint cp DefaultEpName)) #

Get type of entrypoint with given name, fail if not found.

type ForbidExplicitDefaultEntrypoint cp = Eval (LiftM3 (UnMaybe :: Exp Constraint -> (Type -> Exp Constraint) -> Maybe Type -> Constraint -> Type) (Pure (Pure ())) (TError ('Text "Parameter used here must have no explicit \"default\" entrypoint" :$$: (('Text "In parameter type `" :<>: 'ShowType cp) :<>: 'Text "`")) :: (Type -> Exp Constraint) -> Type) (LookupParameterEntrypoint cp DefaultEpName)) #

Ensure that there is no explicit "default" entrypoint.

type NoExplicitDefaultEntrypoint cp = Eval (LookupParameterEntrypoint cp DefaultEpName) ~ ('Nothing :: Maybe Type) #

Similar to ForbidExplicitDefaultEntrypoint, but in a version which the compiler can work with (and which produces errors confusing for users :/)

data EntrypointRef (mname :: Maybe Symbol) where #

Which entrypoint to call.

We intentionally distinguish default and non-default cases because this makes API more details-agnostic.

Constructors

CallDefault :: EntrypointRef ('Nothing :: Maybe Symbol)

Call the default entrypoint, or root if no explicit default is assigned.

Call :: forall (name :: Symbol). NiceEntrypointName name => EntrypointRef ('Just name)

Call the given entrypoint; calling default is not treated specially. You have to provide entrypoint name via passing it as type argument.

Unfortunatelly, here we cannot accept a label because in most cases our entrypoints begin from capital letter (being derived from constructor name), while labels must start from a lower-case letter, and there is no way to make a conversion at type-level.

Instances

Instances details

(CheckStuckEp cp mname arg' arg, GetEntrypointArgCustom cp mname ~ arg', ParameterDeclaresEntrypoints cp) => HasEntrypointArg (cp :: Type) (EntrypointRef mname) arg'
Instance details Defined in Lorentz.Entrypoints.Core Methods useHasEntrypointArg :: EntrypointRef mname -> (Dict (ParameterScope (ToT arg')), EpName) #

type family GetEntrypointArgCustom cp (mname :: Maybe Symbol) where ... #

Universal entrypoint lookup.

Equations

GetEntrypointArgCustom cp ('Nothing :: Maybe Symbol) = GetDefaultEntrypointArg cp
GetEntrypointArgCustom cp ('Just name) = GetEntrypointArg cp name

class HasEntrypointArg (cp :: k) name arg where #

When we call a Lorentz contract we should pass entrypoint name and corresponding argument. Ideally we want to statically check that parameter has entrypoint with given name and argument. Constraint defined by this type class holds for contract with parameter cp that have entrypoint matching name with type arg.

In order to check this property statically, we need to know entrypoint name in compile time, EntrypointRef type serves this purpose. If entrypoint name is not known, one can use TrustEpName wrapper to take responsibility for presence of this entrypoint.

If you want to call a function which has this constraint, you have two options:

Pass contract parameter cp using type application, pass EntrypointRef as a value and pass entrypoint argument. Type system will check that cp has an entrypoint with given reference and type.
Pass EpName wrapped into TrustEpName and entrypoint argument. In this case passing contract parameter is not necessary, you do not even have to know it.

You may need to add this constraint for polymorphic arguments. GHC should tell you when that is the case:

>>> :{
f :: forall (cp :: Type). ParameterDeclaresEntrypoints cp => ()
f = useHasEntrypointArg @cp @_ @(Maybe Integer) CallDefault & const ()
:}
...
... Can not look up entrypoints in type
...   cp
... The most likely reason it is ambiguous, or you need
...   HasEntrypointArg cp (EntrypointRef 'Nothing) (Maybe Integer)
... constraint
...

If GHC can't deduce the type of entrypoint argument, it'll use an unbound type variable, usually arg0, in the error message:

>>> :{
f :: forall (cp :: Type). ParameterDeclaresEntrypoints cp => ()
f = useHasEntrypointArg @cp CallDefault & const ()
:}
...
... Can not look up entrypoints in type
...   cp
... The most likely reason it is ambiguous, or you need
...   HasEntrypointArg cp (EntrypointRef 'Nothing) arg0
... constraint
...

Methods

useHasEntrypointArg :: name -> (Dict (ParameterScope (ToT arg)), EpName) #

Data returned by this method may look somewhat arbitrary. EpName is obviously needed because name can be EntrypointRef or TrustEpName. Dict is returned because in EntrypointRef case we get this evidence for free and don't want to use it. We seem to always need it anyway.

Instances

Instances details

NiceParameter arg => HasEntrypointArg (cp :: k) TrustEpName arg
Instance details Defined in Lorentz.Entrypoints.Core Methods useHasEntrypointArg :: TrustEpName -> (Dict (ParameterScope (ToT arg)), EpName) #
(CheckStuckEp cp mname arg' arg, GetEntrypointArgCustom cp mname ~ arg', ParameterDeclaresEntrypoints cp) => HasEntrypointArg (cp :: Type) (EntrypointRef mname) arg'
Instance details Defined in Lorentz.Entrypoints.Core Methods useHasEntrypointArg :: EntrypointRef mname -> (Dict (ParameterScope (ToT arg')), EpName) #

type HasDefEntrypointArg (cp :: k) defEpName defArg = (defEpName ~ EntrypointRef ('Nothing :: Maybe Symbol), HasEntrypointArg cp defEpName defArg) #

HasEntrypointArg constraint specialized to default entrypoint.

newtype TrustEpName #

This wrapper allows to pass untyped EpName and bypass checking that entrypoint with given name and type exists.

Constructors

TrustEpName EpName

Instances

Instances details

NiceParameter arg => HasEntrypointArg (cp :: k) TrustEpName arg
Instance details Defined in Lorentz.Entrypoints.Core Methods useHasEntrypointArg :: TrustEpName -> (Dict (ParameterScope (ToT arg)), EpName) #

type HasEntrypointOfType param (con :: Symbol) exp = (GetEntrypointArgCustom param ('Just con) ~ exp, ParameterDeclaresEntrypoints param) #

Checks that the given parameter consists of some specific entrypoint. Similar as HasEntrypointArg but ensures that the argument matches the following datatype.

type (:>) (n :: Symbol) ty = 'NamedEp n ty infixr 0 #

type family ParameterContainsEntrypoints param (fields :: [NamedEp]) where ... #

Check that the given entrypoint has some fields inside. This interface allows for an abstraction of contract parameter so that it requires some *minimal* specification, but not a concrete one.

Equations

ParameterContainsEntrypoints _1 ('[] :: [NamedEp]) = ()
ParameterContainsEntrypoints param ((n :> ty) ': rest) = (HasEntrypointOfType param n ty, ParameterContainsEntrypoints param rest)

data EpdNone #

No entrypoints declared, parameter type will serve as argument type of the only existing entrypoint (default one).

Instances

Instances details

HasAnnotation cp => EntrypointsDerivation EpdNone cp
Instance details Defined in Lorentz.Entrypoints.Core Associated Types type EpdAllEntrypoints EpdNone cp :: [(Symbol, Type)] # type EpdLookupEntrypoint EpdNone cp :: Symbol -> Exp (Maybe Type) # Methods epdNotes :: (Notes (ToT cp), RootAnn) # epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint EpdNone cp name)) # epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints EpdNone cp) #
type EpdAllEntrypoints EpdNone cp
Instance details Defined in Lorentz.Entrypoints.Core type EpdAllEntrypoints EpdNone cp = '[] :: [(Symbol, Type)]
type EpdLookupEntrypoint EpdNone cp
Instance details Defined in Lorentz.Entrypoints.Core type EpdLookupEntrypoint EpdNone cp = ConstFn ('Nothing :: Maybe Type) :: Symbol -> Maybe Type -> Type

newtype ShouldHaveEntrypoints a #

A special type which wraps over a primitive type and states that it has entrypoints (one).

Assuming that any type can have entrypoints makes use of Lorentz entrypoints too annoying, so for declaring entrypoints for not sum types we require an explicit wrapper.

Constructors

ShouldHaveEntrypoints
Fields unHasEntrypoints :: a

Instances

Instances details

Generic (ShouldHaveEntrypoints a)
Instance details Defined in Lorentz.Entrypoints.Helpers Associated Types type Rep (ShouldHaveEntrypoints a) :: Type -> Type # Methods from :: ShouldHaveEntrypoints a -> Rep (ShouldHaveEntrypoints a) x # to :: Rep (ShouldHaveEntrypoints a) x -> ShouldHaveEntrypoints a #
HasRPCRepr a => HasRPCRepr (ShouldHaveEntrypoints a)
Instance details Defined in Lorentz.Entrypoints.Helpers Associated Types type AsRPC (ShouldHaveEntrypoints a) #
WellTypedToT r => IsoValue (ShouldHaveEntrypoints r)
Instance details Defined in Lorentz.Entrypoints.Helpers Associated Types type ToT (ShouldHaveEntrypoints r) :: T # Methods toVal :: ShouldHaveEntrypoints r -> Value (ToT (ShouldHaveEntrypoints r)) # fromVal :: Value (ToT (ShouldHaveEntrypoints r)) -> ShouldHaveEntrypoints r #
type Rep (ShouldHaveEntrypoints a)
Instance details Defined in Lorentz.Entrypoints.Helpers type Rep (ShouldHaveEntrypoints a) = D1 ('MetaData "ShouldHaveEntrypoints" "Lorentz.Entrypoints.Helpers" "lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7" 'True) (C1 ('MetaCons "ShouldHaveEntrypoints" 'PrefixI 'True) (S1 ('MetaSel ('Just "unHasEntrypoints") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type AsRPC (ShouldHaveEntrypoints a)
Instance details Defined in Lorentz.Entrypoints.Helpers type AsRPC (ShouldHaveEntrypoints a) = ShouldHaveEntrypoints (AsRPC a)
type ToT (ShouldHaveEntrypoints r)
Instance details Defined in Lorentz.Entrypoints.Helpers type ToT (ShouldHaveEntrypoints r) = GValueType (Rep (ShouldHaveEntrypoints r))

class (IsoValue a, Typeable a) => KnownValue a #

Gathers constraints, commonly required for values.

Instances

Instances details

(IsoValue a, Typeable a) => KnownValue a
Instance details Defined in Lorentz.Constraints.Scopes

class (ForbidOp (ToT a), IsoValue a) => NoOperation a #

Ensure given type does not contain "operation".

Instances

Instances details

(ForbidOp (ToT a), IsoValue a) => NoOperation a
Instance details Defined in Lorentz.Constraints.Scopes

class (ForbidContract (ToT a), IsoValue a) => NoContractType a #

Instances

Instances details

(ForbidContract (ToT a), IsoValue a) => NoContractType a
Instance details Defined in Lorentz.Constraints.Scopes

class (ForbidBigMap (ToT a), IsoValue a) => NoBigMap a #

Instances

Instances details

(ForbidBigMap (ToT a), IsoValue a) => NoBigMap a
Instance details Defined in Lorentz.Constraints.Scopes

class (HasNoNestedBigMaps (ToT a), IsoValue a) => CanHaveBigMap a #

Instances

Instances details

(HasNoNestedBigMaps (ToT a), IsoValue a) => CanHaveBigMap a
Instance details Defined in Lorentz.Constraints.Scopes

type NiceParameter a = (ProperParameterBetterErrors (ToT a), KnownValue a) #

Constraint applied to any part of a parameter type.

Use NiceParameterFull instead when you need to know the contract's entrypoints at compile-time.

type NiceStorage a = (ProperStorageBetterErrors (ToT a), KnownValue a) #

type NiceStorageFull a = (NiceStorage a, HasAnnotation a) #

type NiceConstant a = (ProperConstantBetterErrors (ToT a), KnownValue a) #

type Dupable a = (ProperDupableBetterErrors (ToT a), KnownValue a) #

type NicePackedValue a = (ProperPackedValBetterErrors (ToT a), KnownValue a) #

type NiceUnpackedValue a = (ProperUnpackedValBetterErrors (ToT a), KnownValue a) #

type NiceFullPackedValue a = (NicePackedValue a, NiceUnpackedValue a) #

type NiceUntypedValue a = (ProperUntypedValBetterErrors (ToT a), KnownValue a) #

type NiceViewable a = (ProperViewableBetterErrors (ToT a), KnownValue a) #

type NiceComparable n = (ProperNonComparableValBetterErrors (ToT n), KnownValue n, Comparable (ToT n)) #

Constraint applied to any type, to check if Michelson representation (if exists) of this type is Comparable. In case it is not prints human-readable error message

type NiceNoBigMap n = (KnownValue n, HasNoBigMap (ToT n)) #

class HasAnnotation a #

This class defines the type and field annotations for a given type. Right now the type annotations come from names in a named field, and field annotations are generated from the record fields.

Instances

Instances details

HasAnnotation ByteString
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT ByteString) # annOptions :: Maybe AnnOptions #
HasAnnotation Never
Instance details Defined in Lorentz.Value Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Never) # annOptions :: Maybe AnnOptions #
HasAnnotation OpenChest
Instance details Defined in Lorentz.Value Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT OpenChest) # annOptions :: Maybe AnnOptions #
HasAnnotation ZSNil
Instance details Defined in Lorentz.Zip Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT ZSNil) # annOptions :: Maybe AnnOptions #
HasAnnotation MText
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT MText) # annOptions :: Maybe AnnOptions #
HasAnnotation Operation
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Operation) # annOptions :: Maybe AnnOptions #
HasAnnotation EpAddress
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT EpAddress) # annOptions :: Maybe AnnOptions #
HasAnnotation Address
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Address) # annOptions :: Maybe AnnOptions #
HasAnnotation ChainId
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT ChainId) # annOptions :: Maybe AnnOptions #
HasAnnotation Mutez
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Mutez) # annOptions :: Maybe AnnOptions #
HasAnnotation Timestamp
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Timestamp) # annOptions :: Maybe AnnOptions #
HasAnnotation KeyHash
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT KeyHash) # annOptions :: Maybe AnnOptions #
HasAnnotation PublicKey
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT PublicKey) # annOptions :: Maybe AnnOptions #
HasAnnotation Signature
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Signature) # annOptions :: Maybe AnnOptions #
HasAnnotation Chest
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Chest) # annOptions :: Maybe AnnOptions #
HasAnnotation ChestKey
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT ChestKey) # annOptions :: Maybe AnnOptions #
HasAnnotation Integer
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Integer) # annOptions :: Maybe AnnOptions #
HasAnnotation Natural
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Natural) # annOptions :: Maybe AnnOptions #
HasAnnotation ()
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT ()) # annOptions :: Maybe AnnOptions #
HasAnnotation Bool
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Bool) # annOptions :: Maybe AnnOptions #
KnownIsoT v => HasAnnotation (Set v)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Set v)) # annOptions :: Maybe AnnOptions #
HasAnnotation (FutureContract a)
Instance details Defined in Lorentz.Address Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (FutureContract a)) # annOptions :: Maybe AnnOptions #
HasAnnotation (ChestT a)
Instance details Defined in Lorentz.Bytes Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (ChestT a)) # annOptions :: Maybe AnnOptions #
HasAnnotation a => HasAnnotation (OpenChestT a)
Instance details Defined in Lorentz.Bytes Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (OpenChestT a)) # annOptions :: Maybe AnnOptions #
HasAnnotation (Packed a)
Instance details Defined in Lorentz.Bytes Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Packed a)) # annOptions :: Maybe AnnOptions #
HasAnnotation (TSignature a)
Instance details Defined in Lorentz.Bytes Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (TSignature a)) # annOptions :: Maybe AnnOptions #
HasAnnotation (UParam entries)
Instance details Defined in Lorentz.UParam Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (UParam entries)) # annOptions :: Maybe AnnOptions #
HasAnnotation a => HasAnnotation (ContractRef a)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (ContractRef a)) # annOptions :: Maybe AnnOptions #
HasAnnotation d => HasAnnotation (Ticket d)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Ticket d)) # annOptions :: Maybe AnnOptions #
HasAnnotation a => HasAnnotation (Maybe a)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Maybe a)) # annOptions :: Maybe AnnOptions #
HasAnnotation a => HasAnnotation [a]
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT [a]) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, HasAnnotation b) => HasAnnotation (Either a b)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Either a b)) # annOptions :: Maybe AnnOptions #
(HasAnnotation k, HasAnnotation v) => HasAnnotation (Map k v)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Map k v)) # annOptions :: Maybe AnnOptions #
HasAnnotation (TAddress p vd)
Instance details Defined in Lorentz.Address Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (TAddress p vd)) # annOptions :: Maybe AnnOptions #
NoLambdaCodeIsomorphismError => HasAnnotation (i :-> o)
Instance details Defined in Lorentz.Base Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (i :-> o)) # annOptions :: Maybe AnnOptions #
HasAnnotation (Hash alg a)
Instance details Defined in Lorentz.Bytes Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Hash alg a)) # annOptions :: Maybe AnnOptions #
Each '[HasAnnotation] '[ZippedStack i, ZippedStack o] => HasAnnotation (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (WrappedLambda i o)) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, HasAnnotation r) => HasAnnotation (View_ a r)
Instance details Defined in Lorentz.Macro Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (View_ a r)) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, HasAnnotation b) => HasAnnotation (Void_ a b)
Instance details Defined in Lorentz.Macro Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Void_ a b)) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, HasAnnotation b) => HasAnnotation (ZippedStackRepr a b)
Instance details Defined in Lorentz.Zip Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (ZippedStackRepr a b)) # annOptions :: Maybe AnnOptions #
(HasAnnotation k, HasAnnotation v) => HasAnnotation (BigMap k v)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (BigMap k v)) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, HasAnnotation b) => HasAnnotation (a, b)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (a, b)) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, KnownSymbol name) => HasAnnotation (NamedF Identity a name)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (NamedF Identity a name)) # annOptions :: Maybe AnnOptions #
(HasAnnotation (Maybe a), KnownSymbol name) => HasAnnotation (NamedF Maybe a name)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (NamedF Maybe a name)) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, HasAnnotation b, HasAnnotation c) => HasAnnotation (a, b, c)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (a, b, c)) # annOptions :: Maybe AnnOptions #
HasAnnotation (BigMapId k3 v)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (BigMapId k3 v)) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, HasAnnotation b, HasAnnotation c, HasAnnotation d) => HasAnnotation (a, b, c, d)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (a, b, c, d)) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, HasAnnotation b, HasAnnotation c, HasAnnotation d, HasAnnotation e) => HasAnnotation (a, b, c, d, e)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (a, b, c, d, e)) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, HasAnnotation b, HasAnnotation c, HasAnnotation d, HasAnnotation e, HasAnnotation f) => HasAnnotation (a, b, c, d, e, f)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (a, b, c, d, e, f)) # annOptions :: Maybe AnnOptions #
(HasAnnotation a, HasAnnotation b, HasAnnotation c, HasAnnotation d, HasAnnotation e, HasAnnotation f, HasAnnotation g) => HasAnnotation (a, b, c, d, e, f, g)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (a, b, c, d, e, f, g)) # annOptions :: Maybe AnnOptions #

data Rec (a :: u -> Type) (b :: [u]) where #

A record is parameterized by a universe u, an interpretation f and a list of rows rs. The labels or indices of the record are given by inhabitants of the kind u; the type of values at any label r :: u is given by its interpretation f r :: *.

Constructors

RNil :: forall {u} (a :: u -> Type). Rec a ('[] :: [u])
(:&) :: forall {u} (a :: u -> Type) (r :: u) (rs :: [u]). !(a r) -> !(Rec a rs) -> Rec a (r ': rs) infixr 7

Instances

Instances details

RecSubset (Rec :: (k -> Type) -> [k] -> Type) ('[] :: [k]) (ss :: [k]) ('[] :: [Nat])
Instance details Defined in Data.Vinyl.Lens Associated Types type RecSubsetFCtx Rec f # Methods rsubsetC :: forall g (f :: k0 -> Type). (Functor g, RecSubsetFCtx Rec f) => (Rec f '[] -> g (Rec f '[])) -> Rec f ss -> g (Rec f ss) # rcastC :: forall (f :: k0 -> Type). RecSubsetFCtx Rec f => Rec f ss -> Rec f '[] # rreplaceC :: forall (f :: k0 -> Type). RecSubsetFCtx Rec f => Rec f '[] -> Rec f ss -> Rec f ss #
(RElem r ss i, RSubset rs ss is) => RecSubset (Rec :: (k -> Type) -> [k] -> Type) (r ': rs :: [k]) (ss :: [k]) (i ': is)
Instance details Defined in Data.Vinyl.Lens Associated Types type RecSubsetFCtx Rec f # Methods rsubsetC :: forall g (f :: k0 -> Type). (Functor g, RecSubsetFCtx Rec f) => (Rec f (r ': rs) -> g (Rec f (r ': rs))) -> Rec f ss -> g (Rec f ss) # rcastC :: forall (f :: k0 -> Type). RecSubsetFCtx Rec f => Rec f ss -> Rec f (r ': rs) # rreplaceC :: forall (f :: k0 -> Type). RecSubsetFCtx Rec f => Rec f (r ': rs) -> Rec f ss -> Rec f ss #
RecElem (Rec :: (a -> Type) -> [a] -> Type) (r :: a) (r' :: a) (r ': rs :: [a]) (r' ': rs :: [a]) 'Z
Instance details Defined in Data.Vinyl.Lens Associated Types type RecElemFCtx Rec f # Methods rlensC :: (Functor g, RecElemFCtx Rec f) => (f r -> g (f r')) -> Rec f (r ': rs) -> g (Rec f (r' ': rs)) # rgetC :: (RecElemFCtx Rec f, r ~ r') => Rec f (r ': rs) -> f r # rputC :: RecElemFCtx Rec f => f r' -> Rec f (r ': rs) -> Rec f (r' ': rs) #
(RIndex r (s ': rs) ~ 'S i, RecElem (Rec :: (a -> Type) -> [a] -> Type) r r' rs rs' i) => RecElem (Rec :: (a -> Type) -> [a] -> Type) (r :: a) (r' :: a) (s ': rs :: [a]) (s ': rs' :: [a]) ('S i)
Instance details Defined in Data.Vinyl.Lens Associated Types type RecElemFCtx Rec f # Methods rlensC :: (Functor g, RecElemFCtx Rec f) => (f r -> g (f r')) -> Rec f (s ': rs) -> g (Rec f (s ': rs')) # rgetC :: (RecElemFCtx Rec f, r ~ r') => Rec f (s ': rs) -> f r # rputC :: RecElemFCtx Rec f => f r' -> Rec f (s ': rs) -> Rec f (s ': rs') #
TestCoercion f => TestCoercion (Rec f :: [u] -> Type)
Instance details Defined in Data.Vinyl.Core Methods testCoercion :: forall (a :: k) (b :: k). Rec f a -> Rec f b -> Maybe (Coercion a b) #
TestEquality f => TestEquality (Rec f :: [u] -> Type)
Instance details Defined in Data.Vinyl.Core Methods testEquality :: forall (a :: k) (b :: k). Rec f a -> Rec f b -> Maybe (a :~: b) #
(Storable (f r), Storable (Rec f rs)) => Storable (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Methods sizeOf :: Rec f (r ': rs) -> Int # alignment :: Rec f (r ': rs) -> Int # peekElemOff :: Ptr (Rec f (r ': rs)) -> Int -> IO (Rec f (r ': rs)) # pokeElemOff :: Ptr (Rec f (r ': rs)) -> Int -> Rec f (r ': rs) -> IO () # peekByteOff :: Ptr b -> Int -> IO (Rec f (r ': rs)) # pokeByteOff :: Ptr b -> Int -> Rec f (r ': rs) -> IO () # peek :: Ptr (Rec f (r ': rs)) -> IO (Rec f (r ': rs)) # poke :: Ptr (Rec f (r ': rs)) -> Rec f (r ': rs) -> IO () #
Storable (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Methods sizeOf :: Rec f '[] -> Int # alignment :: Rec f '[] -> Int # peekElemOff :: Ptr (Rec f '[]) -> Int -> IO (Rec f '[]) # pokeElemOff :: Ptr (Rec f '[]) -> Int -> Rec f '[] -> IO () # peekByteOff :: Ptr b -> Int -> IO (Rec f '[]) # pokeByteOff :: Ptr b -> Int -> Rec f '[] -> IO () # peek :: Ptr (Rec f '[]) -> IO (Rec f '[]) # poke :: Ptr (Rec f '[]) -> Rec f '[] -> IO () #
(Monoid (f r), Monoid (Rec f rs)) => Monoid (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Methods mempty :: Rec f (r ': rs) # mappend :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) # mconcat :: [Rec f (r ': rs)] -> Rec f (r ': rs) #
Monoid (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Methods mempty :: Rec f '[] # mappend :: Rec f '[] -> Rec f '[] -> Rec f '[] # mconcat :: [Rec f '[]] -> Rec f '[] #
(Semigroup (f r), Semigroup (Rec f rs)) => Semigroup (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Methods (<>) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) # sconcat :: NonEmpty (Rec f (r ': rs)) -> Rec f (r ': rs) # stimes :: Integral b => b -> Rec f (r ': rs) -> Rec f (r ': rs) #
Semigroup (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Methods (<>) :: Rec f '[] -> Rec f '[] -> Rec f '[] # sconcat :: NonEmpty (Rec f '[]) -> Rec f '[] # stimes :: Integral b => b -> Rec f '[] -> Rec f '[] #
Generic (Rec f rs) => Generic (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Associated Types type Rep (Rec f (r ': rs)) :: Type -> Type # Methods from :: Rec f (r ': rs) -> Rep (Rec f (r ': rs)) x # to :: Rep (Rec f (r ': rs)) x -> Rec f (r ': rs) #
Generic (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Associated Types type Rep (Rec f '[]) :: Type -> Type # Methods from :: Rec f '[] -> Rep (Rec f '[]) x # to :: Rep (Rec f '[]) x -> Rec f '[] #
(RMap rs, ReifyConstraint Show f rs, RecordToList rs) => Show (Rec f rs)	Records may be shown insofar as their points may be shown. `reifyConstraint` is used to great effect here.
Instance details Defined in Data.Vinyl.Core Methods showsPrec :: Int -> Rec f rs -> ShowS # show :: Rec f rs -> String # showList :: [Rec f rs] -> ShowS #
ReifyConstraint NFData f xs => NFData (Rec f xs)
Instance details Defined in Data.Vinyl.Core Methods rnf :: Rec f xs -> () #
(Eq (f r), Eq (Rec f rs)) => Eq (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Methods (==) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (/=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool #
Eq (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Methods (==) :: Rec f '[] -> Rec f '[] -> Bool # (/=) :: Rec f '[] -> Rec f '[] -> Bool #
(Ord (f r), Ord (Rec f rs)) => Ord (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core Methods compare :: Rec f (r ': rs) -> Rec f (r ': rs) -> Ordering # (<) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (<=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (>) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # (>=) :: Rec f (r ': rs) -> Rec f (r ': rs) -> Bool # max :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) # min :: Rec f (r ': rs) -> Rec f (r ': rs) -> Rec f (r ': rs) #
Ord (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core Methods compare :: Rec f '[] -> Rec f '[] -> Ordering # (<) :: Rec f '[] -> Rec f '[] -> Bool # (<=) :: Rec f '[] -> Rec f '[] -> Bool # (>) :: Rec f '[] -> Rec f '[] -> Bool # (>=) :: Rec f '[] -> Rec f '[] -> Bool # max :: Rec f '[] -> Rec f '[] -> Rec f '[] # min :: Rec f '[] -> Rec f '[] -> Rec f '[] #
type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type)
Instance details Defined in Data.Vinyl.Lens type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type) = ()
type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type)
Instance details Defined in Data.Vinyl.Lens type RecSubsetFCtx (Rec :: (k -> Type) -> [k] -> Type) (f :: k -> Type) = ()
type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type)
Instance details Defined in Data.Vinyl.Lens type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type) = ()
type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type)
Instance details Defined in Data.Vinyl.Lens type RecElemFCtx (Rec :: (a -> Type) -> [a] -> Type) (f :: a -> Type) = ()
type Rep (Rec f (r ': rs))
Instance details Defined in Data.Vinyl.Core type Rep (Rec f (r ': rs)) = C1 ('MetaCons ":&" ('InfixI 'RightAssociative 7) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (f r)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rep (Rec f rs)))
type Rep (Rec f ('[] :: [u]))
Instance details Defined in Data.Vinyl.Core type Rep (Rec f ('[] :: [u])) = C1 ('MetaCons "RNil" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (U1 :: Type -> Type))
type IsoRecTuple (Rec f '[a])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[a]) = f a
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15, f x16, f x17, f x18, f x19, f x20, f x21, f x22, f x23, f x24, f x25)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15, f x16, f x17, f x18, f x19, f x20, f x21, f x22, f x23, f x24)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15, f x16, f x17, f x18, f x19, f x20, f x21, f x22, f x23)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15, f x16, f x17, f x18, f x19, f x20, f x21, f x22)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15, f x16, f x17, f x18, f x19, f x20, f x21)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15, f x16, f x17, f x18, f x19, f x20)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15, f x16, f x17, f x18, f x19)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15, f x16, f x17, f x18)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15, f x16, f x17)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15, f x16)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14, f x15)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13, f x14)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12, f x13)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11, f x12)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10, f x11)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9, x10]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9, f x10)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8, x9]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8, f x9)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7, x8]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7, f x8)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6, x7]) = (f x1, f x2, f x3, f x4, f x5, f x6, f x7)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5, x6]) = (f x1, f x2, f x3, f x4, f x5, f x6)
type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4, x5]) = (f x1, f x2, f x3, f x4, f x5)
type IsoRecTuple (Rec f '[x1, x2, x3, x4])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3, x4]) = (f x1, f x2, f x3, f x4)
type IsoRecTuple (Rec f '[x1, x2, x3])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2, x3]) = (f x1, f x2, f x3)
type IsoRecTuple (Rec f '[x1, x2])
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f '[x1, x2]) = (f x1, f x2)
type IsoRecTuple (Rec f ('[] :: [u]))
Instance details Defined in Morley.Util.TypeTuple.Instances type IsoRecTuple (Rec f ('[] :: [u])) = ()

type ($) (f :: k1 -> k) (a :: k1) = f a infixr 2 #

Infix application.

f :: Either String $ Maybe Int
=
f :: Either String (Maybe Int)

undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a #

undefined that leaves a warning in code on every usage.

type (:!) (name :: Symbol) a = NamedF Identity a name #

Infix notation for the type of a named parameter.

type (:?) (name :: Symbol) a = NamedF Maybe a name #

Infix notation for the type of an optional named parameter.

data GenericStrategy #

Type of a strategy to derive Generic instances.

withDepths :: [CstrDepth] -> GenericStrategy #

In this strategy the desired depths of contructors (in the type tree) and fields (in each constructor's tree) are provided manually and simply checked against the number of actual constructors and fields.

rightBalanced :: GenericStrategy #

Strategy to make right-balanced instances (both in constructors and fields).

This will try its best to produce a flat tree:

the balances of all leaves differ no more than by 1;
leaves at left will have equal or lesser depth than leaves at right.

leftBalanced :: GenericStrategy #

Strategy to make left-balanced instances (both in constructors and fields).

This is the same as symmetrically mapped rightBalanced.

rightComb :: GenericStrategy #

Strategy to make fully right-leaning instances (both in constructors and fields).

leftComb :: GenericStrategy #

Strategy to make fully left-leaning instances (both in constructors and fields).

haskellBalanced :: GenericStrategy #

Strategy to make Haskell's Generics-like instances (both in constructors and fields).

This is similar to rightBalanced, except for the "flat" part:

for each node, size of the left subtree is equal or less by one than size of the right subtree.

This strategy matches A1.1.

customGeneric "T" haskellBalanced is equivalent to mere deriving stock Generic T.

reorderingConstrs :: EntriesReorder -> GenericStrategy -> GenericStrategy #

Modify given strategy to reorder constructors.

The reordering will take place before depths are evaluated and structure of generic representation is formed.

Example: reorderingConstrs alphabetically rightBalanced.

reorderingFields :: UnnamedEntriesReorder -> EntriesReorder -> GenericStrategy -> GenericStrategy #

Modify given strategy to reorder fields.

Same notes as for reorderingConstrs apply here.

Example: reorderingFields forbidUnnamedFields alphabetically rightBalanced.

reorderingData :: UnnamedEntriesReorder -> EntriesReorder -> GenericStrategy -> GenericStrategy #

Modify given strategy to reorder constructors and fields.

Same notes as for reorderingConstrs apply here.

Example: reorderingData forbidUnnamedFields alphabetically rightBalanced.

alphabetically :: EntriesReorder #

Sort entries by name alphabetically.

leaveUnnamedFields :: UnnamedEntriesReorder #

Leave unnamed fields intact, without any reordering.

forbidUnnamedFields :: UnnamedEntriesReorder #

Fail in case records are unnamed and we cannot figure out the necessary reordering.

fromDepthsStrategy :: (Int -> [Natural]) -> GenericStrategy #

Helper to make a strategy that created depths for constructor and fields in the same way, just from their number.

The provided function f must satisfy the following rules:

```
length (f n) ≡ n
```
sum $ (x -> 2 ^^ (-x)) <$> f n ≡ 1 (unless n = 0)

fromDepthsStrategy' :: (Int -> [Natural]) -> (Int -> [Natural]) -> GenericStrategy #

Like fromDepthsStrategy, but allows specifying different strategies for constructors and fields.

makeRightBalDepths :: Int -> [Natural] #

cstr :: forall (n :: Nat). KnownNat n => [Natural] -> CstrDepth #

Helper for making a constructor depth.

Note that this is only intended to be more readable than directly using a tuple with withDepths and for the ability to be used in places where RebindableSyntax overrides the number literal resolution.

fld :: forall (n :: Nat). KnownNat n => Natural #

Helper for making a field depth.

Note that this is only intended to be more readable than directly using a tuple with withDepths and for the ability to be used in places where RebindableSyntax overrides the number literal resolution.

customGeneric :: String -> GenericStrategy -> Q [Dec] #

customGeneric' :: Maybe Type -> Name -> Type -> [Con] -> GenericStrategy -> Q [Dec] #

If a Type type is given, this function will generate a new Generic instance with it, and generate the appropriate "to" and "from" methods.

Otherwise, it'll generate a new Type instance as well.

reifyDataType :: Name -> Q (Name, Cxt, Maybe Kind, [TyVarBndr ()], [Con]) #

Reifies info from a type name (given as a String). The lookup happens from the current splice's scope (see lookupTypeName) and the only accepted result is a "plain" data type (no GADTs).

deriveFullType :: Name -> Maybe Kind -> [TyVarBndr flag] -> TypeQ #

Derives, as well as possible, a type definition from its name, its kind (where known) and its variables.

mangleGenericStrategyConstructors :: (Text -> Text) -> GenericStrategy -> GenericStrategy #

Patch a given strategy by applying a transformation function to constructor names before passing them through ordering function.

mangleGenericStrategyFields :: (Text -> Text) -> GenericStrategy -> GenericStrategy #

Patch a given strategy by applying a transformation function to field names before passing them through ordering function.

ligoLayout :: GenericStrategy #

Default layout in LIGO.

To be used with customGeneric, see this method for more info.

This is similar to leftBalanced, but

fields are sorted alphabetically;
always puts as large complete binary subtrees as possible at left.

ligoCombLayout :: GenericStrategy #

Comb layout in LIGO ( [@layout:comb] ).

To be used with customGeneric.

Note: to make comb layout work for sum types, make sure that in LIGO all the constructors are preceded by the bar symbol in your type declaration:

type my_type =
  [@layout:comb]
  | Ctor1 of nat  ← bar symbol _must_ be here
  | Ctor2 of int
  ...

Though the situation may change: https://gitlab.com/ligolang/ligo/-/issues/1104.

type Markdown = Builder #

A piece of markdown document.

This is opposed to Text type, which in turn is not supposed to contain markup elements.

class (SingI t, WellTyped t, HasNoOp t, HasNoBigMap t, HasNoContract t, HasNoTicket t, HasNoSaplingState t) => ConstantScope (t :: T) #

Set of constraints that Michelson applies to pushed constants.

Not just a type alias in order to be able to partially apply it

Instances

Instances details

(SingI t, WellTyped t, HasNoOp t, HasNoBigMap t, HasNoContract t, HasNoTicket t, HasNoSaplingState t) => ConstantScope t
Instance details Defined in Morley.Michelson.Typed.Scope
(WithDeMorganScope HasNoOp t a b, WithDeMorganScope HasNoBigMap t a b, WithDeMorganScope HasNoContract t a b, WithDeMorganScope HasNoTicket t a b, WithDeMorganScope HasNoSaplingState t a b, WellTyped a, WellTyped b) => WithDeMorganScope ConstantScope t a b
Instance details Defined in Morley.Michelson.Typed.Scope Methods withDeMorganScope :: ConstantScope (t a b) => ((ConstantScope a, ConstantScope b) => ret) -> ret #
SingI t => CheckScope (ConstantScope t)
Instance details Defined in Morley.Michelson.Typed.Scope Methods checkScope :: Either BadTypeForScope (Dict (ConstantScope t)) #

data Label (name :: Symbol) where #

Proxy for a label type that includes the KnownSymbol constraint

Constructors

Label :: forall (name :: Symbol). KnownSymbol name => Label name

Instances

Instances details

(KnownSymbol name, s ~ name) => IsLabel s (Label name)
Instance details Defined in Morley.Util.Label Methods fromLabel :: Label name #
Show (Label name)
Instance details Defined in Morley.Util.Label Methods showsPrec :: Int -> Label name -> ShowS # show :: Label name -> String # showList :: [Label name] -> ShowS #
Buildable (Label name)
Instance details Defined in Morley.Util.Label Methods build :: Label name -> Builder #
Eq (Label name)
Instance details Defined in Morley.Util.Label Methods (==) :: Label name -> Label name -> Bool # (/=) :: Label name -> Label name -> Bool #

data Chest #

A locked chest

Instances

Instances details

Generic Chest
Instance details Defined in Morley.Tezos.Crypto.Timelock Associated Types type Rep Chest :: Type -> Type # Methods from :: Chest -> Rep Chest x # to :: Rep Chest x -> Chest #
Show Chest
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> Chest -> ShowS # show :: Chest -> String # showList :: [Chest] -> ShowS #
Binary Chest
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods put :: Chest -> Put # get :: Get Chest # putList :: [Chest] -> Put #
NFData Chest
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods rnf :: Chest -> () #
Eq Chest
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: Chest -> Chest -> Bool # (/=) :: Chest -> Chest -> Bool #
HasAnnotation Chest
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Chest) # annOptions :: Maybe AnnOptions #
HasRPCRepr Chest
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Chest #
TypeHasDoc Chest
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Chest :: FieldDescriptions # Methods typeDocName :: Proxy Chest -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Chest -> WithinParens -> Markdown # typeDocDependencies :: Proxy Chest -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Chest # typeDocMichelsonRep :: TypeDocMichelsonRep Chest #
IsoValue Chest
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Chest :: T # Methods toVal :: Chest -> Value (ToT Chest) # fromVal :: Value (ToT Chest) -> Chest #
type Rep Chest
Instance details Defined in Morley.Tezos.Crypto.Timelock type Rep Chest = D1 ('MetaData "Chest" "Morley.Tezos.Crypto.Timelock" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'False) (C1 ('MetaCons "Chest" 'PrefixI 'True) (S1 ('MetaSel ('Just "chestLockedVal") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Locked) :: (S1 ('MetaSel ('Just "chestPublicModulus") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 PublicModulus) :: S1 ('MetaSel ('Just "chestCiphertext") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Ciphertext))))
type AsRPC Chest
Instance details Defined in Morley.AsRPC type AsRPC Chest = Chest
type TypeDocFieldDescriptions Chest
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Chest = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Chest
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Chest = 'TChest

data ChestKey #

A chest "key" with proof that it was indeed opened fairly.

Instances

Instances details

Generic ChestKey
Instance details Defined in Morley.Tezos.Crypto.Timelock Associated Types type Rep ChestKey :: Type -> Type # Methods from :: ChestKey -> Rep ChestKey x # to :: Rep ChestKey x -> ChestKey #
Show ChestKey
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods showsPrec :: Int -> ChestKey -> ShowS # show :: ChestKey -> String # showList :: [ChestKey] -> ShowS #
Binary ChestKey
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods put :: ChestKey -> Put # get :: Get ChestKey # putList :: [ChestKey] -> Put #
NFData ChestKey
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods rnf :: ChestKey -> () #
Eq ChestKey
Instance details Defined in Morley.Tezos.Crypto.Timelock Methods (==) :: ChestKey -> ChestKey -> Bool # (/=) :: ChestKey -> ChestKey -> Bool #
HasAnnotation ChestKey
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT ChestKey) # annOptions :: Maybe AnnOptions #
HasRPCRepr ChestKey
Instance details Defined in Morley.AsRPC Associated Types type AsRPC ChestKey #
TypeHasDoc ChestKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions ChestKey :: FieldDescriptions # Methods typeDocName :: Proxy ChestKey -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy ChestKey -> WithinParens -> Markdown # typeDocDependencies :: Proxy ChestKey -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep ChestKey # typeDocMichelsonRep :: TypeDocMichelsonRep ChestKey #
IsoValue ChestKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT ChestKey :: T # Methods toVal :: ChestKey -> Value (ToT ChestKey) # fromVal :: Value (ToT ChestKey) -> ChestKey #
type Rep ChestKey
Instance details Defined in Morley.Tezos.Crypto.Timelock type Rep ChestKey = D1 ('MetaData "ChestKey" "Morley.Tezos.Crypto.Timelock" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'False) (C1 ('MetaCons "ChestKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "ckUnlockedVal") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Unlocked) :*: S1 ('MetaSel ('Just "ckProof") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Proof)))
type AsRPC ChestKey
Instance details Defined in Morley.AsRPC type AsRPC ChestKey = ChestKey
type TypeDocFieldDescriptions ChestKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions ChestKey = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT ChestKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT ChestKey = 'TChestKey

data EpName #

Entrypoint name.

There are two properties we care about:

Special treatment of the default entrypoint name. default is prohibited in the CONTRACT instruction and in values of address and contract types. However, it is not prohibited in the SELF instruction. Hence, the value inside EpName can be "default", so that we can distinguish SELF and SELF %default. It is important to distinguish them because their binary representation that is inserted into blockchain is different. For example, typechecking SELF %default consumes more gas than SELF. In this module, we provide several smart constructors with different handling of default, please use the appropriate one for your use case.
The set of permitted characters. Intuitively, an entrypoint name should be valid only if it is a valid annotation (because entrypoints are defined using field annotations). However, it is not enforced in Tezos. It is not clear whether this behavior is intended. There is an upstream issue which received bug label, so probably it is considered a bug. Currently we treat it as a bug and deviate from upstream implementation by probiting entrypoint names that are not valid annotations. If Tezos developers fix it soon, we will be happy. If they don't, we should (maybe temporarily) remove this limitation from our code. There is an issue in our repo as well.

Instances

Instances details

FromJSON EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods parseJSON :: Value -> Parser EpName # parseJSONList :: Value -> Parser [EpName] #
ToJSON EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods toJSON :: EpName -> Value # toEncoding :: EpName -> Encoding # toJSONList :: [EpName] -> Value # toEncodingList :: [EpName] -> Encoding #
Generic EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Associated Types type Rep EpName :: Type -> Type # Methods from :: EpName -> Rep EpName x # to :: Rep EpName x -> EpName #
Show EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods showsPrec :: Int -> EpName -> ShowS # show :: EpName -> String # showList :: [EpName] -> ShowS #
NFData EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods rnf :: EpName -> () #
Buildable EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods build :: EpName -> Builder #
Eq EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods (==) :: EpName -> EpName -> Bool # (/=) :: EpName -> EpName -> Bool #
Ord EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods compare :: EpName -> EpName -> Ordering # (<) :: EpName -> EpName -> Bool # (<=) :: EpName -> EpName -> Bool # (>) :: EpName -> EpName -> Bool # (>=) :: EpName -> EpName -> Bool # max :: EpName -> EpName -> EpName # min :: EpName -> EpName -> EpName #
HasCLReader EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints Methods getReader :: ReadM EpName # getMetavar :: String #
type Rep EpName
Instance details Defined in Morley.Michelson.Untyped.Entrypoints type Rep EpName = D1 ('MetaData "EpName" "Morley.Michelson.Untyped.Entrypoints" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'True) (C1 ('MetaCons "UnsafeEpName" 'PrefixI 'True) (S1 ('MetaSel ('Just "unEpName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

pattern DefEpName :: EpName #

This is a bidirectional pattern that can be used for two purposes:

Construct an EpName referring to the default entrypoint.
Use it in pattern-matching or in equality comparison to check whether EpName refers to the default entrypoint. This is trickier because there are two possible EpName values referring to the default entrypoints. DefEpName will match only the most common one (no entrypoint). However, there is a special case: SELF instruction can have explicit %default reference. For this reason, it is recommended to use isDefEpName instead. Pattern-matching on DefEpName is still permitted for backwards compatibility and for the cases when you are sure that EpName does not come from the SELF instruction.

data Bls12381Fr #

An element of an algebraic number field (scalar), used for multiplying Bls12381G1 and Bls12381G2.

Instances

Instances details

Bounded Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods minBound :: Bls12381Fr # maxBound :: Bls12381Fr #
Enum Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods succ :: Bls12381Fr -> Bls12381Fr # pred :: Bls12381Fr -> Bls12381Fr # toEnum :: Int -> Bls12381Fr # fromEnum :: Bls12381Fr -> Int # enumFrom :: Bls12381Fr -> [Bls12381Fr] # enumFromThen :: Bls12381Fr -> Bls12381Fr -> [Bls12381Fr] # enumFromTo :: Bls12381Fr -> Bls12381Fr -> [Bls12381Fr] # enumFromThenTo :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr -> [Bls12381Fr] #
Num Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (+) :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # (-) :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # (*) :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # negate :: Bls12381Fr -> Bls12381Fr # abs :: Bls12381Fr -> Bls12381Fr # signum :: Bls12381Fr -> Bls12381Fr # fromInteger :: Integer -> Bls12381Fr #
Fractional Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (/) :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # recip :: Bls12381Fr -> Bls12381Fr # fromRational :: Rational -> Bls12381Fr #
Integral Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods quot :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # rem :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # div :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # mod :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # quotRem :: Bls12381Fr -> Bls12381Fr -> (Bls12381Fr, Bls12381Fr) # divMod :: Bls12381Fr -> Bls12381Fr -> (Bls12381Fr, Bls12381Fr) # toInteger :: Bls12381Fr -> Integer #
Real Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods toRational :: Bls12381Fr -> Rational #
Show Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods showsPrec :: Int -> Bls12381Fr -> ShowS # show :: Bls12381Fr -> String # showList :: [Bls12381Fr] -> ShowS #
NFData Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods rnf :: Bls12381Fr -> () #
Eq Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (==) :: Bls12381Fr -> Bls12381Fr -> Bool # (/=) :: Bls12381Fr -> Bls12381Fr -> Bool #
Ord Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods compare :: Bls12381Fr -> Bls12381Fr -> Ordering # (<) :: Bls12381Fr -> Bls12381Fr -> Bool # (<=) :: Bls12381Fr -> Bls12381Fr -> Bool # (>) :: Bls12381Fr -> Bls12381Fr -> Bool # (>=) :: Bls12381Fr -> Bls12381Fr -> Bool # max :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # min :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr #
ToIntegerArithOpHs Bls12381Fr
Instance details Defined in Lorentz.Arith Methods evalToIntOpHs :: forall (s :: [Type]). (Bls12381Fr ': s) :-> (Integer ': s) #
HasRPCRepr Bls12381Fr
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Bls12381Fr #
IsoValue Bls12381Fr
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bls12381Fr :: T # Methods toVal :: Bls12381Fr -> Value (ToT Bls12381Fr) # fromVal :: Value (ToT Bls12381Fr) -> Bls12381Fr #
CurveObject Bls12381Fr
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods zero :: Bls12381Fr # negate :: Bls12381Fr -> Bls12381Fr # add :: Bls12381Fr -> Bls12381Fr -> Bls12381Fr # generate :: MonadRandom m => m Bls12381Fr # fromMichelsonBytes :: ByteString -> Either DeserializationError Bls12381Fr # toMichelsonBytes :: Bls12381Fr -> ByteString #
UnaryArithOpHs Neg Bls12381Fr
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neg Bls12381Fr # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': s) :-> (UnaryArithResHs Neg Bls12381Fr ': s) #
MultiplyPoint Bls12381Fr Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods multiply :: Bls12381Fr -> Bls12381G1 -> Bls12381G1 #
MultiplyPoint Bls12381Fr Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods multiply :: Bls12381Fr -> Bls12381G2 -> Bls12381G2 #
r ~ Bls12381Fr => ArithOpHs Add Bls12381Fr Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Bls12381Fr Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Bls12381G1 => ArithOpHs Mul Bls12381Fr Bls12381G1 r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Bls12381G1 ': s)) :-> (r ': s) #
r ~ Bls12381G2 => ArithOpHs Mul Bls12381Fr Bls12381G2 r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Bls12381G2 ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Bls12381Fr Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Integer ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Bls12381Fr Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Natural ': s)) :-> (r ': s) #
r ~ Bls12381G1 => ArithOpHs Mul Bls12381G1 Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381G1 ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Bls12381G2 => ArithOpHs Mul Bls12381G2 Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381G2 ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Integer Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Bls12381Fr ': s)) :-> (r ': s) #
r ~ Bls12381Fr => ArithOpHs Mul Natural Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Bls12381Fr ': s)) :-> (r ': s) #
type AsRPC Bls12381Fr
Instance details Defined in Morley.AsRPC type AsRPC Bls12381Fr = Bls12381Fr
type ToT Bls12381Fr
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Bls12381Fr = 'TBls12381Fr
type UnaryArithResHs Neg Bls12381Fr
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neg Bls12381Fr = Bls12381Fr

data Bls12381G2 #

G2 point on the curve.

Instances

Instances details

Show Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods showsPrec :: Int -> Bls12381G2 -> ShowS # show :: Bls12381G2 -> String # showList :: [Bls12381G2] -> ShowS #
NFData Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods rnf :: Bls12381G2 -> () #
Eq Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (==) :: Bls12381G2 -> Bls12381G2 -> Bool # (/=) :: Bls12381G2 -> Bls12381G2 -> Bool #
HasRPCRepr Bls12381G2
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Bls12381G2 #
IsoValue Bls12381G2
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bls12381G2 :: T # Methods toVal :: Bls12381G2 -> Value (ToT Bls12381G2) # fromVal :: Value (ToT Bls12381G2) -> Bls12381G2 #
CurveObject Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods zero :: Bls12381G2 # negate :: Bls12381G2 -> Bls12381G2 # add :: Bls12381G2 -> Bls12381G2 -> Bls12381G2 # generate :: MonadRandom m => m Bls12381G2 # fromMichelsonBytes :: ByteString -> Either DeserializationError Bls12381G2 # toMichelsonBytes :: Bls12381G2 -> ByteString #
UnaryArithOpHs Neg Bls12381G2
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neg Bls12381G2 # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Bls12381G2 ': s) :-> (UnaryArithResHs Neg Bls12381G2 ': s) #
MultiplyPoint Bls12381Fr Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods multiply :: Bls12381Fr -> Bls12381G2 -> Bls12381G2 #
MultiplyPoint Integer Bls12381G2
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods multiply :: Integer -> Bls12381G2 -> Bls12381G2 #
r ~ Bls12381G2 => ArithOpHs Add Bls12381G2 Bls12381G2 r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381G2 ': (Bls12381G2 ': s)) :-> (r ': s) #
r ~ Bls12381G2 => ArithOpHs Mul Bls12381Fr Bls12381G2 r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Bls12381G2 ': s)) :-> (r ': s) #
r ~ Bls12381G2 => ArithOpHs Mul Bls12381G2 Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381G2 ': (Bls12381Fr ': s)) :-> (r ': s) #
type AsRPC Bls12381G2
Instance details Defined in Morley.AsRPC type AsRPC Bls12381G2 = Bls12381G2
type ToT Bls12381G2
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Bls12381G2 = 'TBls12381G2
type UnaryArithResHs Neg Bls12381G2
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neg Bls12381G2 = Bls12381G2

data Bls12381G1 #

G1 point on the curve.

Instances

Instances details

Show Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods showsPrec :: Int -> Bls12381G1 -> ShowS # show :: Bls12381G1 -> String # showList :: [Bls12381G1] -> ShowS #
NFData Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods rnf :: Bls12381G1 -> () #
Eq Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods (==) :: Bls12381G1 -> Bls12381G1 -> Bool # (/=) :: Bls12381G1 -> Bls12381G1 -> Bool #
HasRPCRepr Bls12381G1
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Bls12381G1 #
IsoValue Bls12381G1
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bls12381G1 :: T # Methods toVal :: Bls12381G1 -> Value (ToT Bls12381G1) # fromVal :: Value (ToT Bls12381G1) -> Bls12381G1 #
CurveObject Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods zero :: Bls12381G1 # negate :: Bls12381G1 -> Bls12381G1 # add :: Bls12381G1 -> Bls12381G1 -> Bls12381G1 # generate :: MonadRandom m => m Bls12381G1 # fromMichelsonBytes :: ByteString -> Either DeserializationError Bls12381G1 # toMichelsonBytes :: Bls12381G1 -> ByteString #
UnaryArithOpHs Neg Bls12381G1
Instance details Defined in Lorentz.Arith Associated Types type UnaryArithResHs Neg Bls12381G1 # Methods evalUnaryArithOpHs :: forall (s :: [Type]). (Bls12381G1 ': s) :-> (UnaryArithResHs Neg Bls12381G1 ': s) #
MultiplyPoint Bls12381Fr Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods multiply :: Bls12381Fr -> Bls12381G1 -> Bls12381G1 #
MultiplyPoint Integer Bls12381G1
Instance details Defined in Morley.Tezos.Crypto.BLS12381 Methods multiply :: Integer -> Bls12381G1 -> Bls12381G1 #
r ~ Bls12381G1 => ArithOpHs Add Bls12381G1 Bls12381G1 r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381G1 ': (Bls12381G1 ': s)) :-> (r ': s) #
r ~ Bls12381G1 => ArithOpHs Mul Bls12381Fr Bls12381G1 r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381Fr ': (Bls12381G1 ': s)) :-> (r ': s) #
r ~ Bls12381G1 => ArithOpHs Mul Bls12381G1 Bls12381Fr r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Bls12381G1 ': (Bls12381Fr ': s)) :-> (r ': s) #
type AsRPC Bls12381G1
Instance details Defined in Morley.AsRPC type AsRPC Bls12381G1 = Bls12381G1
type ToT Bls12381G1
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Bls12381G1 = 'TBls12381G1
type UnaryArithResHs Neg Bls12381G1
Instance details Defined in Lorentz.Arith type UnaryArithResHs Neg Bls12381G1 = Bls12381G1

data MText #

Michelson string value.

This is basically a mere text with limits imposed by the language: https://tezos.gitlab.io/whitedoc/michelson.html#constants Although, this document seems to be not fully correct, and thus we applied constraints deduced empirically.

You construct an item of this type using one of the following ways:

With QuasyQuotes when need to create a string literal.

>>> [mt|Some text|]
UnsafeMText {unMText = "Some text"}

With mkMText when constructing from a runtime text value.
With UnsafeMText when absolutelly sure that given string does not violate invariants.
With mkMTextCut when not sure about text contents and want to make it compliant with Michelson constraints.

Instances

Instances details

FromJSON MText
Instance details Defined in Morley.Michelson.Text Methods parseJSON :: Value -> Parser MText # parseJSONList :: Value -> Parser [MText] #
ToJSON MText
Instance details Defined in Morley.Michelson.Text Methods toJSON :: MText -> Value # toEncoding :: MText -> Encoding # toJSONList :: [MText] -> Value # toEncodingList :: [MText] -> Encoding #
Data MText
Instance details Defined in Morley.Michelson.Text Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MText -> c MText # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MText # toConstr :: MText -> Constr # dataTypeOf :: MText -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MText) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MText) # gmapT :: (forall b. Data b => b -> b) -> MText -> MText # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MText -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MText -> r # gmapQ :: (forall d. Data d => d -> u) -> MText -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> MText -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> MText -> m MText # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MText -> m MText # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MText -> m MText #
Monoid MText
Instance details Defined in Morley.Michelson.Text Methods mempty :: MText # mappend :: MText -> MText -> MText # mconcat :: [MText] -> MText #
Semigroup MText
Instance details Defined in Morley.Michelson.Text Methods (<>) :: MText -> MText -> MText # sconcat :: NonEmpty MText -> MText # stimes :: Integral b => b -> MText -> MText #
Generic MText
Instance details Defined in Morley.Michelson.Text Associated Types type Rep MText :: Type -> Type # Methods from :: MText -> Rep MText x # to :: Rep MText x -> MText #
Show MText
Instance details Defined in Morley.Michelson.Text Methods showsPrec :: Int -> MText -> ShowS # show :: MText -> String # showList :: [MText] -> ShowS #
NFData MText
Instance details Defined in Morley.Michelson.Text Methods rnf :: MText -> () #
Buildable MText
Instance details Defined in Morley.Michelson.Text Methods build :: MText -> Builder #
Eq MText
Instance details Defined in Morley.Michelson.Text Methods (==) :: MText -> MText -> Bool # (/=) :: MText -> MText -> Bool #
Ord MText
Instance details Defined in Morley.Michelson.Text Methods compare :: MText -> MText -> Ordering # (<) :: MText -> MText -> Bool # (<=) :: MText -> MText -> Bool # (>) :: MText -> MText -> Bool # (>=) :: MText -> MText -> Bool # max :: MText -> MText -> MText # min :: MText -> MText -> MText #
Hashable MText
Instance details Defined in Morley.Michelson.Text Methods hashWithSalt :: Int -> MText -> Int # hash :: MText -> Int #
HasAnnotation MText
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT MText) # annOptions :: Maybe AnnOptions #
ErrorHasDoc MText
Instance details Defined in Lorentz.Errors Associated Types type ErrorRequirements MText # Methods errorDocName :: Text # errorDocMdCause :: Markdown # errorDocMdCauseInEntrypoint :: Markdown # errorDocHaskellRep :: Markdown # errorDocClass :: ErrorClass # errorDocDependencies :: [SomeDocDefinitionItem] # errorDocRequirements :: Dict (ErrorRequirements MText) #
IsCustomErrorArgRep MText
Instance details Defined in Lorentz.Errors Methods verifyErrorTag :: MText -> MText -> Either Text MText # customErrorRepDocDeps :: [SomeDocDefinitionItem] # customErrorHaskellRep :: forall (tag :: Symbol). (KnownSymbol tag, CustomErrorHasDoc tag) => Proxy tag -> Markdown #
IsError MText	Use this for internal errors only. "Normal" error scenarios should use the mechanism of custom errors, see below.
Instance details Defined in Lorentz.Errors Methods errorToVal :: MText -> (forall (t :: T). ErrorScope t => Value t -> r) -> r # errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text MText # failUsing :: forall (s :: [Type]) (t :: [Type]). IsError MText => MText -> s :-> t #
ConcatOpHs MText
Instance details Defined in Lorentz.Polymorphic
SizeOpHs MText
Instance details Defined in Lorentz.Polymorphic
SliceOpHs MText
Instance details Defined in Lorentz.Polymorphic
HasRPCRepr MText
Instance details Defined in Morley.AsRPC Associated Types type AsRPC MText #
TypeHasDoc MText
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions MText :: FieldDescriptions # Methods typeDocName :: Proxy MText -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy MText -> WithinParens -> Markdown # typeDocDependencies :: Proxy MText -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep MText # typeDocMichelsonRep :: TypeDocMichelsonRep MText #
IsoValue MText
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT MText :: T # Methods toVal :: MText -> Value (ToT MText) # fromVal :: Value (ToT MText) -> MText #
HasCLReader MText
Instance details Defined in Morley.Michelson.Text Methods getReader :: ReadM MText # getMetavar :: String #
Container MText
Instance details Defined in Morley.Michelson.Text Associated Types type Element MText # Methods toList :: MText -> [Element MText] # null :: MText -> Bool # foldr :: (Element MText -> b -> b) -> b -> MText -> b # foldl :: (b -> Element MText -> b) -> b -> MText -> b # foldl' :: (b -> Element MText -> b) -> b -> MText -> b # length :: MText -> Int # elem :: Element MText -> MText -> Bool # foldMap :: Monoid m => (Element MText -> m) -> MText -> m # fold :: MText -> Element MText # foldr' :: (Element MText -> b -> b) -> b -> MText -> b # notElem :: Element MText -> MText -> Bool # all :: (Element MText -> Bool) -> MText -> Bool # any :: (Element MText -> Bool) -> MText -> Bool # and :: MText -> Bool # or :: MText -> Bool # find :: (Element MText -> Bool) -> MText -> Maybe (Element MText) # safeHead :: MText -> Maybe (Element MText) # safeMaximum :: MText -> Maybe (Element MText) # safeMinimum :: MText -> Maybe (Element MText) # safeFoldr1 :: (Element MText -> Element MText -> Element MText) -> MText -> Maybe (Element MText) # safeFoldl1 :: (Element MText -> Element MText -> Element MText) -> MText -> Maybe (Element MText) #
ToText MText
Instance details Defined in Morley.Michelson.Text Methods toText :: MText -> Text #
TypeHasDoc errArg => IsCustomErrorArgRep (MText, errArg)
Instance details Defined in Lorentz.Errors Methods verifyErrorTag :: MText -> (MText, errArg) -> Either Text (MText, errArg) # customErrorRepDocDeps :: [SomeDocDefinitionItem] # customErrorHaskellRep :: forall (tag :: Symbol). (KnownSymbol tag, CustomErrorHasDoc tag) => Proxy tag -> Markdown #
type Rep MText
Instance details Defined in Morley.Michelson.Text type Rep MText = D1 ('MetaData "MText" "Morley.Michelson.Text" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'True) (C1 ('MetaCons "UnsafeMText" 'PrefixI 'True) (S1 ('MetaSel ('Just "unMText") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))
type ErrorRequirements MText
Instance details Defined in Lorentz.Errors type ErrorRequirements MText = ()
type AsRPC MText
Instance details Defined in Morley.AsRPC type AsRPC MText = MText
type TypeDocFieldDescriptions MText
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions MText = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT MText
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT MText = 'TString
type Element MText
Instance details Defined in Morley.Michelson.Text type Element MText = Element Text

mt :: QuasiQuoter #

QuasyQuoter for constructing Michelson strings.

Validity of result will be checked at compile time. Note:

slash must be escaped
newline character must appear as 'n'
use quotes as is
other special characters are not allowed.

type KeyHash = Hash 'HashKindPublicKey #

Convenience synonym for an on-chain public key hash.

data Signature #

Cryptographic signatures used by Tezos. Constructors correspond to PublicKey constructors.

Tezos distinguishes signatures for different curves. For instance, ed25519 signatures and secp256k1 signatures are printed differently (have different prefix). However, signatures are packed without information about the curve. For this purpose there is a generic signature which only stores bytes and doesn't carry information about the curve. Apparently unpacking from bytes always produces such signature. Unpacking from string produces a signature with curve information.

Instances

Instances details

FromJSON Signature
Instance details Defined in Morley.Tezos.Crypto Methods parseJSON :: Value -> Parser Signature # parseJSONList :: Value -> Parser [Signature] #
ToJSON Signature
Instance details Defined in Morley.Tezos.Crypto Methods toJSON :: Signature -> Value # toEncoding :: Signature -> Encoding # toJSONList :: [Signature] -> Value # toEncodingList :: [Signature] -> Encoding #
Generic Signature
Instance details Defined in Morley.Tezos.Crypto Associated Types type Rep Signature :: Type -> Type # Methods from :: Signature -> Rep Signature x # to :: Rep Signature x -> Signature #
Show Signature
Instance details Defined in Morley.Tezos.Crypto Methods showsPrec :: Int -> Signature -> ShowS # show :: Signature -> String # showList :: [Signature] -> ShowS #
NFData Signature
Instance details Defined in Morley.Tezos.Crypto Methods rnf :: Signature -> () #
Buildable Signature
Instance details Defined in Morley.Tezos.Crypto Methods build :: Signature -> Builder #
Eq Signature
Instance details Defined in Morley.Tezos.Crypto Methods (==) :: Signature -> Signature -> Bool # (/=) :: Signature -> Signature -> Bool #
Ord Signature
Instance details Defined in Morley.Tezos.Crypto Methods compare :: Signature -> Signature -> Ordering # (<) :: Signature -> Signature -> Bool # (<=) :: Signature -> Signature -> Bool # (>) :: Signature -> Signature -> Bool # (>=) :: Signature -> Signature -> Bool # max :: Signature -> Signature -> Signature # min :: Signature -> Signature -> Signature #
HasAnnotation Signature
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Signature) # annOptions :: Maybe AnnOptions #
HasRPCRepr Signature
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Signature #
TypeHasDoc Signature
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Signature :: FieldDescriptions # Methods typeDocName :: Proxy Signature -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Signature -> WithinParens -> Markdown # typeDocDependencies :: Proxy Signature -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Signature # typeDocMichelsonRep :: TypeDocMichelsonRep Signature #
IsoValue Signature
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Signature :: T # Methods toVal :: Signature -> Value (ToT Signature) # fromVal :: Value (ToT Signature) -> Signature #
type Rep Signature
Instance details Defined in Morley.Tezos.Crypto type Rep Signature = D1 ('MetaData "Signature" "Morley.Tezos.Crypto" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'False) ((C1 ('MetaCons "SignatureEd25519" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedUnpack) (Rec0 Signature)) :+: C1 ('MetaCons "SignatureSecp256k1" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Signature))) :+: (C1 ('MetaCons "SignatureP256" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Signature)) :+: (C1 ('MetaCons "SignatureBLS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedUnpack) (Rec0 Signature)) :+: C1 ('MetaCons "SignatureGeneric" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ByteString)))))
type AsRPC Signature
Instance details Defined in Morley.AsRPC type AsRPC Signature = Signature
type TypeDocFieldDescriptions Signature
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Signature = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Signature
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Signature = 'TSignature

data PublicKey #

Public cryptographic key used by Tezos. There are three cryptographic curves each represented by its own constructor.

Instances

Instances details

FromJSON PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods parseJSON :: Value -> Parser PublicKey # parseJSONList :: Value -> Parser [PublicKey] #
ToJSON PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods toJSON :: PublicKey -> Value # toEncoding :: PublicKey -> Encoding # toJSONList :: [PublicKey] -> Value # toEncodingList :: [PublicKey] -> Encoding #
Generic PublicKey
Instance details Defined in Morley.Tezos.Crypto Associated Types type Rep PublicKey :: Type -> Type # Methods from :: PublicKey -> Rep PublicKey x # to :: Rep PublicKey x -> PublicKey #
Show PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods showsPrec :: Int -> PublicKey -> ShowS # show :: PublicKey -> String # showList :: [PublicKey] -> ShowS #
NFData PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods rnf :: PublicKey -> () #
Buildable PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods build :: PublicKey -> Builder #
Eq PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods (==) :: PublicKey -> PublicKey -> Bool # (/=) :: PublicKey -> PublicKey -> Bool #
Ord PublicKey
Instance details Defined in Morley.Tezos.Crypto Methods compare :: PublicKey -> PublicKey -> Ordering # (<) :: PublicKey -> PublicKey -> Bool # (<=) :: PublicKey -> PublicKey -> Bool # (>) :: PublicKey -> PublicKey -> Bool # (>=) :: PublicKey -> PublicKey -> Bool # max :: PublicKey -> PublicKey -> PublicKey # min :: PublicKey -> PublicKey -> PublicKey #
HasAnnotation PublicKey
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT PublicKey) # annOptions :: Maybe AnnOptions #
HasRPCRepr PublicKey
Instance details Defined in Morley.AsRPC Associated Types type AsRPC PublicKey #
TypeHasDoc PublicKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions PublicKey :: FieldDescriptions # Methods typeDocName :: Proxy PublicKey -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy PublicKey -> WithinParens -> Markdown # typeDocDependencies :: Proxy PublicKey -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep PublicKey # typeDocMichelsonRep :: TypeDocMichelsonRep PublicKey #
IsoValue PublicKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT PublicKey :: T # Methods toVal :: PublicKey -> Value (ToT PublicKey) # fromVal :: Value (ToT PublicKey) -> PublicKey #
type Rep PublicKey
Instance details Defined in Morley.Tezos.Crypto type Rep PublicKey = D1 ('MetaData "PublicKey" "Morley.Tezos.Crypto" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'False) ((C1 ('MetaCons "PublicKeyEd25519" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedUnpack) (Rec0 PublicKey)) :+: C1 ('MetaCons "PublicKeySecp256k1" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 PublicKey))) :+: (C1 ('MetaCons "PublicKeyP256" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 PublicKey)) :+: C1 ('MetaCons "PublicKeyBLS" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedUnpack) (Rec0 PublicKey))))
type AsRPC PublicKey
Instance details Defined in Morley.AsRPC type AsRPC PublicKey = PublicKey
type TypeDocFieldDescriptions PublicKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions PublicKey = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT PublicKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT PublicKey = 'TKey

data ChainId #

Identifier of a network (babylonnet, mainnet, test network or other). Evaluated as hash of the genesis block.

The only operation supported for this type is packing. Use case: multisig contract, for instance, now includes chain ID into signed data "in order to add extra replay protection between the main chain and the test chain".

Instances

Instances details

FromJSON ChainId
Instance details Defined in Morley.Tezos.Core Methods parseJSON :: Value -> Parser ChainId # parseJSONList :: Value -> Parser [ChainId] #
ToJSON ChainId
Instance details Defined in Morley.Tezos.Core Methods toJSON :: ChainId -> Value # toEncoding :: ChainId -> Encoding # toJSONList :: [ChainId] -> Value # toEncodingList :: [ChainId] -> Encoding #
Generic ChainId
Instance details Defined in Morley.Tezos.Core Associated Types type Rep ChainId :: Type -> Type # Methods from :: ChainId -> Rep ChainId x # to :: Rep ChainId x -> ChainId #
Show ChainId
Instance details Defined in Morley.Tezos.Core Methods showsPrec :: Int -> ChainId -> ShowS # show :: ChainId -> String # showList :: [ChainId] -> ShowS #
NFData ChainId
Instance details Defined in Morley.Tezos.Core Methods rnf :: ChainId -> () #
Buildable ChainId
Instance details Defined in Morley.Tezos.Core Methods build :: ChainId -> Builder #
Eq ChainId
Instance details Defined in Morley.Tezos.Core Methods (==) :: ChainId -> ChainId -> Bool # (/=) :: ChainId -> ChainId -> Bool #
Ord ChainId
Instance details Defined in Morley.Tezos.Core Methods compare :: ChainId -> ChainId -> Ordering # (<) :: ChainId -> ChainId -> Bool # (<=) :: ChainId -> ChainId -> Bool # (>) :: ChainId -> ChainId -> Bool # (>=) :: ChainId -> ChainId -> Bool # max :: ChainId -> ChainId -> ChainId # min :: ChainId -> ChainId -> ChainId #
HasAnnotation ChainId
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT ChainId) # annOptions :: Maybe AnnOptions #
HasRPCRepr ChainId
Instance details Defined in Morley.AsRPC Associated Types type AsRPC ChainId #
TypeHasDoc ChainId
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions ChainId :: FieldDescriptions # Methods typeDocName :: Proxy ChainId -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy ChainId -> WithinParens -> Markdown # typeDocDependencies :: Proxy ChainId -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep ChainId # typeDocMichelsonRep :: TypeDocMichelsonRep ChainId #
IsoValue ChainId
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT ChainId :: T # Methods toVal :: ChainId -> Value (ToT ChainId) # fromVal :: Value (ToT ChainId) -> ChainId #
type Rep ChainId
Instance details Defined in Morley.Tezos.Core type Rep ChainId = D1 ('MetaData "ChainId" "Morley.Tezos.Core" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'True) (C1 ('MetaCons "UnsafeChainId" 'PrefixI 'True) (S1 ('MetaSel ('Just "unChainId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ByteString)))
type AsRPC ChainId
Instance details Defined in Morley.AsRPC type AsRPC ChainId = ChainId
type TypeDocFieldDescriptions ChainId
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions ChainId = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT ChainId
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT ChainId = 'TChainId

data Timestamp #

Time in the real world. Use the functions below to convert it to/from Unix time in seconds.

Instances

Instances details

FromJSON Timestamp
Instance details Defined in Morley.Tezos.Core Methods parseJSON :: Value -> Parser Timestamp # parseJSONList :: Value -> Parser [Timestamp] #
ToJSON Timestamp
Instance details Defined in Morley.Tezos.Core Methods toJSON :: Timestamp -> Value # toEncoding :: Timestamp -> Encoding # toJSONList :: [Timestamp] -> Value # toEncodingList :: [Timestamp] -> Encoding #
Data Timestamp
Instance details Defined in Morley.Tezos.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Timestamp -> c Timestamp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Timestamp # toConstr :: Timestamp -> Constr # dataTypeOf :: Timestamp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Timestamp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Timestamp) # gmapT :: (forall b. Data b => b -> b) -> Timestamp -> Timestamp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Timestamp -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Timestamp -> r # gmapQ :: (forall d. Data d => d -> u) -> Timestamp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Timestamp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Timestamp -> m Timestamp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Timestamp -> m Timestamp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Timestamp -> m Timestamp #
Generic Timestamp
Instance details Defined in Morley.Tezos.Core Associated Types type Rep Timestamp :: Type -> Type # Methods from :: Timestamp -> Rep Timestamp x # to :: Rep Timestamp x -> Timestamp #
Show Timestamp
Instance details Defined in Morley.Tezos.Core Methods showsPrec :: Int -> Timestamp -> ShowS # show :: Timestamp -> String # showList :: [Timestamp] -> ShowS #
NFData Timestamp
Instance details Defined in Morley.Tezos.Core Methods rnf :: Timestamp -> () #
Buildable Timestamp
Instance details Defined in Morley.Tezos.Core Methods build :: Timestamp -> Builder #
Eq Timestamp
Instance details Defined in Morley.Tezos.Core Methods (==) :: Timestamp -> Timestamp -> Bool # (/=) :: Timestamp -> Timestamp -> Bool #
Ord Timestamp
Instance details Defined in Morley.Tezos.Core Methods compare :: Timestamp -> Timestamp -> Ordering # (<) :: Timestamp -> Timestamp -> Bool # (<=) :: Timestamp -> Timestamp -> Bool # (>) :: Timestamp -> Timestamp -> Bool # (>=) :: Timestamp -> Timestamp -> Bool # max :: Timestamp -> Timestamp -> Timestamp # min :: Timestamp -> Timestamp -> Timestamp #
HasAnnotation Timestamp
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Timestamp) # annOptions :: Maybe AnnOptions #
HasRPCRepr Timestamp
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Timestamp #
TypeHasDoc Timestamp
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Timestamp :: FieldDescriptions # Methods typeDocName :: Proxy Timestamp -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Timestamp -> WithinParens -> Markdown # typeDocDependencies :: Proxy Timestamp -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Timestamp # typeDocMichelsonRep :: TypeDocMichelsonRep Timestamp #
IsoValue Timestamp
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Timestamp :: T # Methods toVal :: Timestamp -> Value (ToT Timestamp) # fromVal :: Value (ToT Timestamp) -> Timestamp #
r ~ Timestamp => ArithOpHs Add Timestamp Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Timestamp ': (Integer ': s)) :-> (r ': s) #
r ~ Timestamp => ArithOpHs Add Integer Timestamp r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Integer ': (Timestamp ': s)) :-> (r ': s) #
r ~ Integer => ArithOpHs Sub Timestamp Timestamp r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Timestamp ': (Timestamp ': s)) :-> (r ': s) #
r ~ Timestamp => ArithOpHs Sub Timestamp Integer r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Timestamp ': (Integer ': s)) :-> (r ': s) #
type Rep Timestamp
Instance details Defined in Morley.Tezos.Core type Rep Timestamp = D1 ('MetaData "Timestamp" "Morley.Tezos.Core" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'True) (C1 ('MetaCons "Timestamp" 'PrefixI 'True) (S1 ('MetaSel ('Just "unTimestamp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 POSIXTime)))
type AsRPC Timestamp
Instance details Defined in Morley.AsRPC type AsRPC Timestamp = Timestamp
type TypeDocFieldDescriptions Timestamp
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Timestamp = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Timestamp
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Timestamp = 'TTimestamp

data Mutez #

Mutez is a wrapper over integer data type. 1 mutez is 1 token (μTz).

The constructor is marked Unsafe since GHC does not warn on overflowing literals (exceeding custom Word63 type bounds), thus the resultant Mutez value may get truncated silently.

>>> UnsafeMutez 9223372036854775809
UnsafeMutez {unMutez = 1}

Instances

Instances details

FromJSON Mutez
Instance details Defined in Morley.Tezos.Core Methods parseJSON :: Value -> Parser Mutez # parseJSONList :: Value -> Parser [Mutez] #
ToJSON Mutez
Instance details Defined in Morley.Tezos.Core Methods toJSON :: Mutez -> Value # toEncoding :: Mutez -> Encoding # toJSONList :: [Mutez] -> Value # toEncodingList :: [Mutez] -> Encoding #
Bounded Mutez
Instance details Defined in Morley.Tezos.Core Methods minBound :: Mutez # maxBound :: Mutez #
Enum Mutez
Instance details Defined in Morley.Tezos.Core Methods succ :: Mutez -> Mutez # pred :: Mutez -> Mutez # toEnum :: Int -> Mutez # fromEnum :: Mutez -> Int # enumFrom :: Mutez -> [Mutez] # enumFromThen :: Mutez -> Mutez -> [Mutez] # enumFromTo :: Mutez -> Mutez -> [Mutez] # enumFromThenTo :: Mutez -> Mutez -> Mutez -> [Mutez] #
Generic Mutez
Instance details Defined in Morley.Tezos.Core Associated Types type Rep Mutez :: Type -> Type # Methods from :: Mutez -> Rep Mutez x # to :: Rep Mutez x -> Mutez #
Show Mutez
Instance details Defined in Morley.Tezos.Core Methods showsPrec :: Int -> Mutez -> ShowS # show :: Mutez -> String # showList :: [Mutez] -> ShowS #
NFData Mutez
Instance details Defined in Morley.Tezos.Core Methods rnf :: Mutez -> () #
Buildable Mutez
Instance details Defined in Morley.Tezos.Core Methods build :: Mutez -> Builder #
Eq Mutez
Instance details Defined in Morley.Tezos.Core Methods (==) :: Mutez -> Mutez -> Bool # (/=) :: Mutez -> Mutez -> Bool #
Ord Mutez
Instance details Defined in Morley.Tezos.Core Methods compare :: Mutez -> Mutez -> Ordering # (<) :: Mutez -> Mutez -> Bool # (<=) :: Mutez -> Mutez -> Bool # (>) :: Mutez -> Mutez -> Bool # (>=) :: Mutez -> Mutez -> Bool # max :: Mutez -> Mutez -> Mutez # min :: Mutez -> Mutez -> Mutez #
HasAnnotation Mutez
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT Mutez) # annOptions :: Maybe AnnOptions #
HasRPCRepr Mutez
Instance details Defined in Morley.AsRPC Associated Types type AsRPC Mutez #
TypeHasDoc Mutez
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Mutez :: FieldDescriptions # Methods typeDocName :: Proxy Mutez -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Mutez -> WithinParens -> Markdown # typeDocDependencies :: Proxy Mutez -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Mutez # typeDocMichelsonRep :: TypeDocMichelsonRep Mutez #
IsoValue Mutez
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Mutez :: T # Methods toVal :: Mutez -> Value (ToT Mutez) # fromVal :: Value (ToT Mutez) -> Mutez #
HasCLReader Mutez
Instance details Defined in Morley.Tezos.Core Methods getReader :: ReadM Mutez # getMetavar :: String #
r ~ Mutez => ArithOpHs Add Mutez Mutez r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Mutez ': (Mutez ': s)) :-> (r ': s) #
r ~ Maybe (Natural, Mutez) => ArithOpHs EDiv Mutez Mutez r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Mutez ': (Mutez ': s)) :-> (r ': s) #
r ~ Maybe (Mutez, Mutez) => ArithOpHs EDiv Mutez Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Mutez ': (Natural ': s)) :-> (r ': s) #
r ~ Mutez => ArithOpHs Mul Mutez Natural r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Mutez ': (Natural ': s)) :-> (r ': s) #
r ~ Mutez => ArithOpHs Mul Natural Mutez r
Instance details Defined in Lorentz.Arith Methods evalArithOpHs :: forall (s :: [Type]). (Natural ': (Mutez ': s)) :-> (r ': s) #
type Rep Mutez
Instance details Defined in Morley.Tezos.Core type Rep Mutez = D1 ('MetaData "Mutez" "Morley.Tezos.Core" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'True) (C1 ('MetaCons "UnsafeMutez" 'PrefixI 'True) (S1 ('MetaSel ('Just "unMutez") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word63)))
type AsRPC Mutez
Instance details Defined in Morley.AsRPC type AsRPC Mutez = Mutez
type TypeDocFieldDescriptions Mutez
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Mutez = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT Mutez
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Mutez = 'TMutez

tz :: QuasiQuoter #

Quotes a Mutez value.

The value is in XTZ, i.e. 1e6 Mutez, with optional suffix representing a unit:

k, kilo -- 1000 XTZ
M, Mega, mega -- 1000000 XTZ
m, milli -- 0.001 XTZ
u, μ, micro -- 0.000001 XTZ

This is the safest and recommended way to create Mutez from a numeric literal.

The suffix can be separated from the number by whitespace. You can also use underscores as a delimiter (those will be ignored), and scientific notation, e.g. 123.456e6. Note that if the scientific notation represents a mutez fraction, that is a compile-time error.

>>> [tz|123|]
UnsafeMutez {unMutez = 123000000}

>>> [tz|123k|]
UnsafeMutez {unMutez = 123000000000}

>>> [tz|123 kilo|]
UnsafeMutez {unMutez = 123000000000}

>>> [tz|123M|]
UnsafeMutez {unMutez = 123000000000000}

>>> [tz|123 Mega|]
UnsafeMutez {unMutez = 123000000000000}

>>> [tz|123 mega|]
UnsafeMutez {unMutez = 123000000000000}

>>> [tz|123e6|]
UnsafeMutez {unMutez = 123000000000000}

>>> [tz|123m|]
UnsafeMutez {unMutez = 123000}

>>> [tz|123 milli|]
UnsafeMutez {unMutez = 123000}

>>> [tz|123u|]
UnsafeMutez {unMutez = 123}

>>> [tz|123μ|]
UnsafeMutez {unMutez = 123}

>>> [tz|123 micro|]
UnsafeMutez {unMutez = 123}

>>> [tz| 123.456_789 |]
UnsafeMutez {unMutez = 123456789}

>>> [tz|123.456u|]
...
... error:
...  • The number is a mutez fraction. The smallest possible subdivision is 0.000001 XTZ
...

>>> [tz|0.012_345_6|]
...
... error:
...  • The number is a mutez fraction. The smallest possible subdivision is 0.000001 XTZ
...

>>> [tz| 9223372.036854775807 M |]
UnsafeMutez {unMutez = 9223372036854775807}

>>> [tz| 9223372.036854775808 M |]
...
... error:
...  • The number is out of mutez bounds. It must be between 0 and 9223372036854.775807 XTZ (inclusive).
...

>>> [tz| -1 |]
...
... error:
...  • The number is out of mutez bounds. It must be between 0 and 9223372036854.775807 XTZ (inclusive).
...

toMutez :: (Integral a, CheckIntSubType a Word63) => a -> Mutez #

Safely create Mutez.

When constructing literals, you'll need to specify the type of the literal. GHC will check for literal overflow on builtin types like Word16 and Word32, but not on Word62 or Word63, so those can overflow silently.

It's recommended to use tz quasiquote for literals instead.

zeroMutez :: Mutez #

oneMutez :: Mutez #

timestampFromSeconds :: Integer -> Timestamp #

timestampFromUTCTime :: UTCTime -> Timestamp #

timestampQuote :: QuasiQuoter #

Quote a value of type Timestamp in yyyy-mm-ddThh:mm:ss[.sss]Z format.

>>> formatTimestamp [timestampQuote| 2019-02-21T16:54:12.2344523Z |]
"2019-02-21T16:54:12Z"

Inspired by 'time-quote' library.

type Address = Constrained (NullConstraint :: AddressKind -> Constraint) KindedAddress #

Data type corresponding to address structure in Tezos.

mkUType :: forall (x :: T). Notes x -> Ty #

Get the term-level type of notes, preserving annotations.

data EpAddress #

Address with optional entrypoint name attached to it.

Constructors

EpAddress'
Fields eaAddress :: Address Address itself eaEntrypoint :: EpName Entrypoint name (might be empty)

Bundled Patterns

pattern EpAddress :: forall (kind :: AddressKind). () => KindedAddress kind -> EpName -> EpAddress

Instances

Instances details

Generic EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Associated Types type Rep EpAddress :: Type -> Type # Methods from :: EpAddress -> Rep EpAddress x # to :: Rep EpAddress x -> EpAddress #
Show EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods showsPrec :: Int -> EpAddress -> ShowS # show :: EpAddress -> String # showList :: [EpAddress] -> ShowS #
NFData EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods rnf :: EpAddress -> () #
Buildable EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods build :: EpAddress -> Builder #
Eq EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods (==) :: EpAddress -> EpAddress -> Bool # (/=) :: EpAddress -> EpAddress -> Bool #
Ord EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints Methods compare :: EpAddress -> EpAddress -> Ordering # (<) :: EpAddress -> EpAddress -> Bool # (<=) :: EpAddress -> EpAddress -> Bool # (>) :: EpAddress -> EpAddress -> Bool # (>=) :: EpAddress -> EpAddress -> Bool # max :: EpAddress -> EpAddress -> EpAddress # min :: EpAddress -> EpAddress -> EpAddress #
ToAddress EpAddress
Instance details Defined in Lorentz.Address Methods toAddress :: EpAddress -> Address #
HasAnnotation EpAddress
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT EpAddress) # annOptions :: Maybe AnnOptions #
HasRPCRepr EpAddress
Instance details Defined in Morley.AsRPC Associated Types type AsRPC EpAddress #
TypeHasDoc EpAddress
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions EpAddress :: FieldDescriptions # Methods typeDocName :: Proxy EpAddress -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy EpAddress -> WithinParens -> Markdown # typeDocDependencies :: Proxy EpAddress -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep EpAddress # typeDocMichelsonRep :: TypeDocMichelsonRep EpAddress #
IsoValue EpAddress
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT EpAddress :: T # Methods toVal :: EpAddress -> Value (ToT EpAddress) # fromVal :: Value (ToT EpAddress) -> EpAddress #
FromContractRef cp EpAddress
Instance details Defined in Lorentz.Address Methods fromContractRef :: ContractRef cp -> EpAddress #
CanCastTo (FutureContract p :: Type) EpAddress
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (FutureContract p) -> Proxy EpAddress -> () #
type Rep EpAddress
Instance details Defined in Morley.Michelson.Typed.Entrypoints type Rep EpAddress = D1 ('MetaData "EpAddress" "Morley.Michelson.Typed.Entrypoints" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'False) (C1 ('MetaCons "EpAddress'" 'PrefixI 'True) (S1 ('MetaSel ('Just "eaAddress") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Address) :*: S1 ('MetaSel ('Just "eaEntrypoint") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 EpName)))
type AsRPC EpAddress
Instance details Defined in Morley.AsRPC type AsRPC EpAddress = EpAddress
type TypeDocFieldDescriptions EpAddress
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions EpAddress = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT EpAddress
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT EpAddress = 'TAddress

class IsNotInView #

Constraint ensuring the given code does not appear on the top level of a view. Some Michelson instructions are forbidden on the top level of views, but allowed in main contract code, and also inside lambdas in views. Hence, this constraint can be provided by mkContractCode or by mkVLam.

Instances

Instances details

(TypeError ('Text "Not allowed on the top level of a view") :: Constraint) => IsNotInView
Instance details Defined in Morley.Michelson.Typed.Contract

data ContractDoc #

Keeps documentation gathered for some piece of contract code.

Used for building documentation of a contract.

Constructors

ContractDoc

Fields

cdContents :: DocBlock
All inlined doc items.
cdDefinitions :: DocBlock
Definitions used in document.
Usually you put some large and repetitive descriptions here. This differs from the document content in that it contains sections which are always at top-level, disregard the nesting.
All doc items which define docItemId method go here, and only they.
cdDefinitionsSet :: Set SomeDocDefinitionItem
We remember all already declared entries to avoid cyclic dependencies in documentation items discovery.
cdDefinitionIds :: Set DocItemId
We remember all already used identifiers. (Documentation naturally should not declare multiple items with the same identifier because that would make references to the respective anchors ambiguous).

Instances

Instances details

Monoid ContractDoc
Instance details Defined in Morley.Michelson.Doc Methods mempty :: ContractDoc # mappend :: ContractDoc -> ContractDoc -> ContractDoc # mconcat :: [ContractDoc] -> ContractDoc #
Semigroup ContractDoc	Contract documentation assembly primarily relies on this instance.
Instance details Defined in Morley.Michelson.Doc Methods (<>) :: ContractDoc -> ContractDoc -> ContractDoc # sconcat :: NonEmpty ContractDoc -> ContractDoc # stimes :: Integral b => b -> ContractDoc -> ContractDoc #

newtype SubDoc #

A part of documentation to be grouped. Essentially incapsulates DocBlock.

Constructors

SubDoc DocBlock

Instances

Instances details

Show DocGrouping	To automatically derive `instance Show Morley.Michelson.Typed.Instr` later.
Instance details Defined in Morley.Michelson.Doc Methods showsPrec :: Int -> DocGrouping -> ShowS # show :: DocGrouping -> String # showList :: [DocGrouping] -> ShowS #
di ~ DName => IsString (SubDoc -> di)	This instance allows writing something like `docGroup "Title"`, this makes sense as the most primitive and basic use case for doc groups is putting a section under name.
Instance details Defined in Morley.Michelson.Doc Methods fromString :: String -> SubDoc -> di #

data DocSection #

Several doc items of the same type.

Constructors

DocItem d => DocSection (NonEmpty $ DocElem d)

data DocElem d #

A doc item which we store, along with related information.

Constructors

DocElem
Fields deItem :: d Doc item itself. deSub :: Maybe SubDoc Subdocumentation, if given item is a group.

data SomeDocDefinitionItem where #

Hides some documentation item which is put to "definitions" section.

Constructors

SomeDocDefinitionItem :: forall d. (DocItem d, DocItemPlacement d ~ 'DocItemInDefinitions) => d -> SomeDocDefinitionItem

Instances

Instances details

Eq SomeDocDefinitionItem
Instance details Defined in Morley.Michelson.Doc Methods (==) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (/=) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool #
Ord SomeDocDefinitionItem
Instance details Defined in Morley.Michelson.Doc Methods compare :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Ordering # (<) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (<=) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (>) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # (>=) :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> Bool # max :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> SomeDocDefinitionItem # min :: SomeDocDefinitionItem -> SomeDocDefinitionItem -> SomeDocDefinitionItem #

data SomeDocItem where #

Hides some documentation item.

Constructors

SomeDocItem :: forall d. DocItem d => d -> SomeDocItem

Instances

Instances details

Show DocGrouping	To automatically derive `instance Show Morley.Michelson.Typed.Instr` later.
Instance details Defined in Morley.Michelson.Doc Methods showsPrec :: Int -> DocGrouping -> ShowS # show :: DocGrouping -> String # showList :: [DocGrouping] -> ShowS #
Show SomeDocItem	To automatically derive `instance Show Morley.Michelson.Typed.Instr` later.
Instance details Defined in Morley.Michelson.Doc Methods showsPrec :: Int -> SomeDocItem -> ShowS # show :: SomeDocItem -> String # showList :: [SomeDocItem] -> ShowS #
NFData SomeDocItem
Instance details Defined in Morley.Michelson.Doc Methods rnf :: SomeDocItem -> () #

data DocSectionNameStyle #

How to render section name.

Constructors

DocSectionNameBig	Suitable for block name.
DocSectionNameSmall	Suitable for subsection title within block.

data DocItemRef (p :: DocItemPlacementKind) (r :: DocItemReferencedKind) where #

Constructors

DocItemRef :: DocItemId -> DocItemRef 'DocItemInDefinitions 'True
DocItemRefInlined :: DocItemId -> DocItemRef 'DocItemInlined 'True
DocItemNoRef :: DocItemRef 'DocItemInlined 'False

Instances

Instances details

ToAnchor (DocItemRef d 'True)
Instance details Defined in Morley.Michelson.Doc Methods toAnchor :: DocItemRef d 'True -> Anchor #

data DocItemPlacementKind #

Where do we place given doc item.

Constructors

DocItemInlined	Placed in the document content itself.
DocItemInDefinitions	Placed in dedicated definitions section; can later be referenced.

newtype DocItemPos #

Position of all doc items of some type.

Constructors

DocItemPos (Natural, Text)

Instances

Instances details

Show DocItemPos
Instance details Defined in Morley.Michelson.Doc Methods showsPrec :: Int -> DocItemPos -> ShowS # show :: DocItemPos -> String # showList :: [DocItemPos] -> ShowS #
Buildable DocItemPos
Instance details Defined in Morley.Michelson.Doc Methods build :: DocItemPos -> Builder #
Eq DocItemPos
Instance details Defined in Morley.Michelson.Doc Methods (==) :: DocItemPos -> DocItemPos -> Bool # (/=) :: DocItemPos -> DocItemPos -> Bool #
Ord DocItemPos
Instance details Defined in Morley.Michelson.Doc Methods compare :: DocItemPos -> DocItemPos -> Ordering # (<) :: DocItemPos -> DocItemPos -> Bool # (<=) :: DocItemPos -> DocItemPos -> Bool # (>) :: DocItemPos -> DocItemPos -> Bool # (>=) :: DocItemPos -> DocItemPos -> Bool # max :: DocItemPos -> DocItemPos -> DocItemPos # min :: DocItemPos -> DocItemPos -> DocItemPos #

newtype DocItemId #

Some unique identifier of a doc item.

All doc items which should be refer-able need to have this identifier.

Constructors

DocItemId Text

Instances

Instances details

Show DocItemId
Instance details Defined in Morley.Michelson.Doc Methods showsPrec :: Int -> DocItemId -> ShowS # show :: DocItemId -> String # showList :: [DocItemId] -> ShowS #
Eq DocItemId
Instance details Defined in Morley.Michelson.Doc Methods (==) :: DocItemId -> DocItemId -> Bool # (/=) :: DocItemId -> DocItemId -> Bool #
Ord DocItemId
Instance details Defined in Morley.Michelson.Doc Methods compare :: DocItemId -> DocItemId -> Ordering # (<) :: DocItemId -> DocItemId -> Bool # (<=) :: DocItemId -> DocItemId -> Bool # (>) :: DocItemId -> DocItemId -> Bool # (>=) :: DocItemId -> DocItemId -> Bool # max :: DocItemId -> DocItemId -> DocItemId # min :: DocItemId -> DocItemId -> DocItemId #
ToAnchor DocItemId
Instance details Defined in Morley.Michelson.Doc Methods toAnchor :: DocItemId -> Anchor #

class (Typeable d, DOrd d) => DocItem d where #

A piece of documentation describing one property of a thing, be it a name or description of a contract, or an error throwable by given endpoint.

Items of the same type appear close to each other in a rendered documentation and form a section.

Doc items are later injected into a contract code via a dedicated nop-like instruction. Normally doc items which belong to one section appear in resulting doc in the same order in which they appeared in the contract.

While documentation framework grows, this typeclass acquires more and more methods for fine tuning of existing rendering logic because we don't want to break backward compatibility, hope one day we will make everything concise :( E.g. all rendering and reording stuff could be merged in one method, and we could have several template implementations for it which would allow user to specify only stuff relevant to his case.

Minimal complete definition

docItemPos, docItemSectionName, docItemToMarkdown

Associated Types

type DocItemPlacement d :: DocItemPlacementKind #

Defines where given doc item should be put. There are two options: 1. Inline right here (default behaviour); 2. Put into definitions section.

Note that we require all doc items with "in definitions" placement to have Eq and Ord instances which comply the following law: if two documentation items describe the same entity or property, they should be considered equal.

type DocItemPlacement d = 'DocItemInlined

type DocItemReferenced d :: DocItemReferencedKind #

type DocItemReferenced d = 'False

Methods

docItemPos :: Natural #

Position of this item in the resulting documentation; the smaller the value, the higher the section with this element will be placed. If the position is the same as other doc items, they will be placed base on their name, alphabetically.

Documentation structure is not necessarily flat. If some doc item consolidates a whole documentation block within it, this block will have its own placement of items independent from outer parts of the doc.

docItemSectionName :: Maybe Text #

When multiple items of the same type belong to one section, how this section will be called.

If not provided, section will contain just untitled content.

docItemSectionDescription :: Maybe Markdown #

Description of a section.

Can be used to mention some common things about all elements of this section. Markdown syntax is permitted here.

docItemSectionNameStyle :: DocSectionNameStyle #

How to render section name.

Takes effect only if section name is set.

docItemRef :: d -> DocItemRef (DocItemPlacement d) (DocItemReferenced d) #

Defines a function which constructs an unique identifier of given doc item, if it has been decided to put the doc item into definitions section.

Identifier should be unique both among doc items of the same type and items of other types. Thus, consider using "typeId-contentId" pattern.

docItemToMarkdown :: HeaderLevel -> d -> Markdown #

Render given doc item to Markdown, preferably one line, optionally with header.

Accepts the smallest allowed level of header. (Using smaller value than provided one will interfere with existing headers thus delivering mess).

docItemToToc :: HeaderLevel -> d -> Markdown #

Render table of contents entry for given doc item to Markdown.

docItemDependencies :: d -> [SomeDocDefinitionItem] #

All doc items which this doc item refers to.

They will automatically be put to definitions as soon as given doc item is detected.

docItemsOrder :: [d] -> [d] #

This function accepts doc items put under the same section in the order in which they appeared in the contract and returns their new desired order. It's also fine to use this function for filtering or merging doc items.

Default implementation * leaves inlined items as is; * for items put to definitions, lexicographically sorts them by their id.

Instances

Instances details

DocItem DHashAlgorithm
Instance details Defined in Lorentz.Bytes Associated Types type DocItemPlacement DHashAlgorithm :: DocItemPlacementKind # type DocItemReferenced DHashAlgorithm :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DHashAlgorithm -> DocItemRef (DocItemPlacement DHashAlgorithm) (DocItemReferenced DHashAlgorithm) # docItemToMarkdown :: HeaderLevel -> DHashAlgorithm -> Markdown # docItemToToc :: HeaderLevel -> DHashAlgorithm -> Markdown # docItemDependencies :: DHashAlgorithm -> [SomeDocDefinitionItem] # docItemsOrder :: [DHashAlgorithm] -> [DHashAlgorithm] #
DocItem DEntrypointExample
Instance details Defined in Lorentz.Doc Associated Types type DocItemPlacement DEntrypointExample :: DocItemPlacementKind # type DocItemReferenced DEntrypointExample :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DEntrypointExample -> DocItemRef (DocItemPlacement DEntrypointExample) (DocItemReferenced DEntrypointExample) # docItemToMarkdown :: HeaderLevel -> DEntrypointExample -> Markdown # docItemToToc :: HeaderLevel -> DEntrypointExample -> Markdown # docItemDependencies :: DEntrypointExample -> [SomeDocDefinitionItem] # docItemsOrder :: [DEntrypointExample] -> [DEntrypointExample] #
DocItem DView
Instance details Defined in Lorentz.Doc Associated Types type DocItemPlacement DView :: DocItemPlacementKind # type DocItemReferenced DView :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DView -> DocItemRef (DocItemPlacement DView) (DocItemReferenced DView) # docItemToMarkdown :: HeaderLevel -> DView -> Markdown # docItemToToc :: HeaderLevel -> DView -> Markdown # docItemDependencies :: DView -> [SomeDocDefinitionItem] # docItemsOrder :: [DView] -> [DView] #
DocItem DViewArg
Instance details Defined in Lorentz.Doc Associated Types type DocItemPlacement DViewArg :: DocItemPlacementKind # type DocItemReferenced DViewArg :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DViewArg -> DocItemRef (DocItemPlacement DViewArg) (DocItemReferenced DViewArg) # docItemToMarkdown :: HeaderLevel -> DViewArg -> Markdown # docItemToToc :: HeaderLevel -> DViewArg -> Markdown # docItemDependencies :: DViewArg -> [SomeDocDefinitionItem] # docItemsOrder :: [DViewArg] -> [DViewArg] #
DocItem DViewDesc
Instance details Defined in Lorentz.Doc Associated Types type DocItemPlacement DViewDesc :: DocItemPlacementKind # type DocItemReferenced DViewDesc :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DViewDesc -> DocItemRef (DocItemPlacement DViewDesc) (DocItemReferenced DViewDesc) # docItemToMarkdown :: HeaderLevel -> DViewDesc -> Markdown # docItemToToc :: HeaderLevel -> DViewDesc -> Markdown # docItemDependencies :: DViewDesc -> [SomeDocDefinitionItem] # docItemsOrder :: [DViewDesc] -> [DViewDesc] #
DocItem DViewRet
Instance details Defined in Lorentz.Doc Associated Types type DocItemPlacement DViewRet :: DocItemPlacementKind # type DocItemReferenced DViewRet :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DViewRet -> DocItemRef (DocItemPlacement DViewRet) (DocItemReferenced DViewRet) # docItemToMarkdown :: HeaderLevel -> DViewRet -> Markdown # docItemToToc :: HeaderLevel -> DViewRet -> Markdown # docItemDependencies :: DViewRet -> [SomeDocDefinitionItem] # docItemsOrder :: [DViewRet] -> [DViewRet] #
DocItem DEntrypointArg
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type DocItemPlacement DEntrypointArg :: DocItemPlacementKind # type DocItemReferenced DEntrypointArg :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DEntrypointArg -> DocItemRef (DocItemPlacement DEntrypointArg) (DocItemReferenced DEntrypointArg) # docItemToMarkdown :: HeaderLevel -> DEntrypointArg -> Markdown # docItemToToc :: HeaderLevel -> DEntrypointArg -> Markdown # docItemDependencies :: DEntrypointArg -> [SomeDocDefinitionItem] # docItemsOrder :: [DEntrypointArg] -> [DEntrypointArg] #
DocItem DEntrypointReference
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type DocItemPlacement DEntrypointReference :: DocItemPlacementKind # type DocItemReferenced DEntrypointReference :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DEntrypointReference -> DocItemRef (DocItemPlacement DEntrypointReference) (DocItemReferenced DEntrypointReference) # docItemToMarkdown :: HeaderLevel -> DEntrypointReference -> Markdown # docItemToToc :: HeaderLevel -> DEntrypointReference -> Markdown # docItemDependencies :: DEntrypointReference -> [SomeDocDefinitionItem] # docItemsOrder :: [DEntrypointReference] -> [DEntrypointReference] #
DocItem DError
Instance details Defined in Lorentz.Errors Associated Types type DocItemPlacement DError :: DocItemPlacementKind # type DocItemReferenced DError :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DError -> DocItemRef (DocItemPlacement DError) (DocItemReferenced DError) # docItemToMarkdown :: HeaderLevel -> DError -> Markdown # docItemToToc :: HeaderLevel -> DError -> Markdown # docItemDependencies :: DError -> [SomeDocDefinitionItem] # docItemsOrder :: [DError] -> [DError] #
DocItem DThrows
Instance details Defined in Lorentz.Errors Associated Types type DocItemPlacement DThrows :: DocItemPlacementKind # type DocItemReferenced DThrows :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DThrows -> DocItemRef (DocItemPlacement DThrows) (DocItemReferenced DThrows) # docItemToMarkdown :: HeaderLevel -> DThrows -> Markdown # docItemToToc :: HeaderLevel -> DThrows -> Markdown # docItemDependencies :: DThrows -> [SomeDocDefinitionItem] # docItemsOrder :: [DThrows] -> [DThrows] #
DocItem DDescribeErrorTagMap
Instance details Defined in Lorentz.Errors.Numeric.Doc Associated Types type DocItemPlacement DDescribeErrorTagMap :: DocItemPlacementKind # type DocItemReferenced DDescribeErrorTagMap :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DDescribeErrorTagMap -> DocItemRef (DocItemPlacement DDescribeErrorTagMap) (DocItemReferenced DDescribeErrorTagMap) # docItemToMarkdown :: HeaderLevel -> DDescribeErrorTagMap -> Markdown # docItemToToc :: HeaderLevel -> DDescribeErrorTagMap -> Markdown # docItemDependencies :: DDescribeErrorTagMap -> [SomeDocDefinitionItem] # docItemsOrder :: [DDescribeErrorTagMap] -> [DDescribeErrorTagMap] #
DocItem DAnchor
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DAnchor :: DocItemPlacementKind # type DocItemReferenced DAnchor :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DAnchor -> DocItemRef (DocItemPlacement DAnchor) (DocItemReferenced DAnchor) # docItemToMarkdown :: HeaderLevel -> DAnchor -> Markdown # docItemToToc :: HeaderLevel -> DAnchor -> Markdown # docItemDependencies :: DAnchor -> [SomeDocDefinitionItem] # docItemsOrder :: [DAnchor] -> [DAnchor] #
DocItem DComment
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DComment :: DocItemPlacementKind # type DocItemReferenced DComment :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DComment -> DocItemRef (DocItemPlacement DComment) (DocItemReferenced DComment) # docItemToMarkdown :: HeaderLevel -> DComment -> Markdown # docItemToToc :: HeaderLevel -> DComment -> Markdown # docItemDependencies :: DComment -> [SomeDocDefinitionItem] # docItemsOrder :: [DComment] -> [DComment] #
DocItem DConversionInfo
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DConversionInfo :: DocItemPlacementKind # type DocItemReferenced DConversionInfo :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DConversionInfo -> DocItemRef (DocItemPlacement DConversionInfo) (DocItemReferenced DConversionInfo) # docItemToMarkdown :: HeaderLevel -> DConversionInfo -> Markdown # docItemToToc :: HeaderLevel -> DConversionInfo -> Markdown # docItemDependencies :: DConversionInfo -> [SomeDocDefinitionItem] # docItemsOrder :: [DConversionInfo] -> [DConversionInfo] #
DocItem DDescription
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DDescription :: DocItemPlacementKind # type DocItemReferenced DDescription :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DDescription -> DocItemRef (DocItemPlacement DDescription) (DocItemReferenced DDescription) # docItemToMarkdown :: HeaderLevel -> DDescription -> Markdown # docItemToToc :: HeaderLevel -> DDescription -> Markdown # docItemDependencies :: DDescription -> [SomeDocDefinitionItem] # docItemsOrder :: [DDescription] -> [DDescription] #
DocItem DGeneralInfoSection
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DGeneralInfoSection :: DocItemPlacementKind # type DocItemReferenced DGeneralInfoSection :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DGeneralInfoSection -> DocItemRef (DocItemPlacement DGeneralInfoSection) (DocItemReferenced DGeneralInfoSection) # docItemToMarkdown :: HeaderLevel -> DGeneralInfoSection -> Markdown # docItemToToc :: HeaderLevel -> DGeneralInfoSection -> Markdown # docItemDependencies :: DGeneralInfoSection -> [SomeDocDefinitionItem] # docItemsOrder :: [DGeneralInfoSection] -> [DGeneralInfoSection] #
DocItem DGitRevision
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DGitRevision :: DocItemPlacementKind # type DocItemReferenced DGitRevision :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DGitRevision -> DocItemRef (DocItemPlacement DGitRevision) (DocItemReferenced DGitRevision) # docItemToMarkdown :: HeaderLevel -> DGitRevision -> Markdown # docItemToToc :: HeaderLevel -> DGitRevision -> Markdown # docItemDependencies :: DGitRevision -> [SomeDocDefinitionItem] # docItemsOrder :: [DGitRevision] -> [DGitRevision] #
DocItem DName
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DName :: DocItemPlacementKind # type DocItemReferenced DName :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DName -> DocItemRef (DocItemPlacement DName) (DocItemReferenced DName) # docItemToMarkdown :: HeaderLevel -> DName -> Markdown # docItemToToc :: HeaderLevel -> DName -> Markdown # docItemDependencies :: DName -> [SomeDocDefinitionItem] # docItemsOrder :: [DName] -> [DName] #
DocItem DToc
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DToc :: DocItemPlacementKind # type DocItemReferenced DToc :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DToc -> DocItemRef (DocItemPlacement DToc) (DocItemReferenced DToc) # docItemToMarkdown :: HeaderLevel -> DToc -> Markdown # docItemToToc :: HeaderLevel -> DToc -> Markdown # docItemDependencies :: DToc -> [SomeDocDefinitionItem] # docItemsOrder :: [DToc] -> [DToc] #
DocItem DStorageType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type DocItemPlacement DStorageType :: DocItemPlacementKind # type DocItemReferenced DStorageType :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DStorageType -> DocItemRef (DocItemPlacement DStorageType) (DocItemReferenced DStorageType) # docItemToMarkdown :: HeaderLevel -> DStorageType -> Markdown # docItemToToc :: HeaderLevel -> DStorageType -> Markdown # docItemDependencies :: DStorageType -> [SomeDocDefinitionItem] # docItemsOrder :: [DStorageType] -> [DStorageType] #
DocItem DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type DocItemPlacement DType :: DocItemPlacementKind # type DocItemReferenced DType :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DType -> DocItemRef (DocItemPlacement DType) (DocItemReferenced DType) # docItemToMarkdown :: HeaderLevel -> DType -> Markdown # docItemToToc :: HeaderLevel -> DType -> Markdown # docItemDependencies :: DType -> [SomeDocDefinitionItem] # docItemsOrder :: [DType] -> [DType] #
EntrypointKindHasDoc ep => DocItem (DEntrypoint ep)
Instance details Defined in Lorentz.Entrypoints.Doc Associated Types type DocItemPlacement (DEntrypoint ep) :: DocItemPlacementKind # type DocItemReferenced (DEntrypoint ep) :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DEntrypoint ep -> DocItemRef (DocItemPlacement (DEntrypoint ep)) (DocItemReferenced (DEntrypoint ep)) # docItemToMarkdown :: HeaderLevel -> DEntrypoint ep -> Markdown # docItemToToc :: HeaderLevel -> DEntrypoint ep -> Markdown # docItemDependencies :: DEntrypoint ep -> [SomeDocDefinitionItem] # docItemsOrder :: [DEntrypoint ep] -> [DEntrypoint ep] #

type family DocItemPlacement d :: DocItemPlacementKind #

Defines where given doc item should be put. There are two options: 1. Inline right here (default behaviour); 2. Put into definitions section.

Note that we require all doc items with "in definitions" placement to have Eq and Ord instances which comply the following law: if two documentation items describe the same entity or property, they should be considered equal.

Instances

Instances details

type DocItemPlacement DHashAlgorithm
Instance details Defined in Lorentz.Bytes type DocItemPlacement DHashAlgorithm = 'DocItemInDefinitions
type DocItemPlacement DEntrypointExample
Instance details Defined in Lorentz.Doc type DocItemPlacement DEntrypointExample = 'DocItemInlined
type DocItemPlacement DView
Instance details Defined in Lorentz.Doc type DocItemPlacement DView = 'DocItemInlined
type DocItemPlacement DViewArg
Instance details Defined in Lorentz.Doc type DocItemPlacement DViewArg = 'DocItemInlined
type DocItemPlacement DViewDesc
Instance details Defined in Lorentz.Doc type DocItemPlacement DViewDesc = 'DocItemInDefinitions
type DocItemPlacement DViewRet
Instance details Defined in Lorentz.Doc type DocItemPlacement DViewRet = 'DocItemInlined
type DocItemPlacement DEntrypointArg
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemPlacement DEntrypointArg = 'DocItemInlined
type DocItemPlacement DEntrypointReference
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemPlacement DEntrypointReference = 'DocItemInlined
type DocItemPlacement DError
Instance details Defined in Lorentz.Errors type DocItemPlacement DError = 'DocItemInDefinitions
type DocItemPlacement DThrows
Instance details Defined in Lorentz.Errors type DocItemPlacement DThrows = 'DocItemInlined
type DocItemPlacement DDescribeErrorTagMap
Instance details Defined in Lorentz.Errors.Numeric.Doc type DocItemPlacement DDescribeErrorTagMap = 'DocItemInDefinitions
type DocItemPlacement DAnchor
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DAnchor = 'DocItemInlined
type DocItemPlacement DComment
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DComment = 'DocItemInlined
type DocItemPlacement DConversionInfo
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DConversionInfo = 'DocItemInlined
type DocItemPlacement DDescription
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DDescription = 'DocItemInlined
type DocItemPlacement DGeneralInfoSection
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DGeneralInfoSection = 'DocItemInlined
type DocItemPlacement DGitRevision
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DGitRevision = 'DocItemInlined
type DocItemPlacement DName
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DName = 'DocItemInlined
type DocItemPlacement DToc
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DToc = 'DocItemInlined
type DocItemPlacement DStorageType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type DocItemPlacement DStorageType = 'DocItemInlined
type DocItemPlacement DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type DocItemPlacement DType = 'DocItemInDefinitions
type DocItemPlacement (DEntrypoint ep)
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemPlacement (DEntrypoint ep) = 'DocItemInlined

type family DocItemReferenced d :: DocItemReferencedKind #

Instances

Instances details

type DocItemReferenced DHashAlgorithm
Instance details Defined in Lorentz.Bytes type DocItemReferenced DHashAlgorithm = 'True
type DocItemReferenced DEntrypointExample
Instance details Defined in Lorentz.Doc type DocItemReferenced DEntrypointExample = 'False
type DocItemReferenced DView
Instance details Defined in Lorentz.Doc type DocItemReferenced DView = 'True
type DocItemReferenced DViewArg
Instance details Defined in Lorentz.Doc type DocItemReferenced DViewArg = 'False
type DocItemReferenced DViewDesc
Instance details Defined in Lorentz.Doc type DocItemReferenced DViewDesc = 'True
type DocItemReferenced DViewRet
Instance details Defined in Lorentz.Doc type DocItemReferenced DViewRet = 'False
type DocItemReferenced DEntrypointArg
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemReferenced DEntrypointArg = 'False
type DocItemReferenced DEntrypointReference
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemReferenced DEntrypointReference = 'False
type DocItemReferenced DError
Instance details Defined in Lorentz.Errors type DocItemReferenced DError = 'True
type DocItemReferenced DThrows
Instance details Defined in Lorentz.Errors type DocItemReferenced DThrows = 'False
type DocItemReferenced DDescribeErrorTagMap
Instance details Defined in Lorentz.Errors.Numeric.Doc type DocItemReferenced DDescribeErrorTagMap = 'True
type DocItemReferenced DAnchor
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DAnchor = 'False
type DocItemReferenced DComment
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DComment = 'False
type DocItemReferenced DConversionInfo
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DConversionInfo = 'False
type DocItemReferenced DDescription
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DDescription = 'False
type DocItemReferenced DGeneralInfoSection
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DGeneralInfoSection = 'False
type DocItemReferenced DGitRevision
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DGitRevision = 'False
type DocItemReferenced DName
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DName = 'False
type DocItemReferenced DToc
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DToc = 'False
type DocItemReferenced DStorageType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type DocItemReferenced DStorageType = 'True
type DocItemReferenced DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type DocItemReferenced DType = 'True
type DocItemReferenced (DEntrypoint ep)
Instance details Defined in Lorentz.Entrypoints.Doc type DocItemReferenced (DEntrypoint ep) = 'True

mdTocFromRef :: (DocItem d, DocItemReferenced d ~ 'True) => HeaderLevel -> Markdown -> d -> Markdown #

Generate DToc entry anchor from docItemRef.

docItemPosition :: DocItem d => DocItemPos #

Get doc item position at term-level.

docDefinitionRef :: (DocItem d, DocItemPlacement d ~ 'DocItemInDefinitions) => Markdown -> d -> Markdown #

Make a reference to doc item in definitions.

docItemSectionRef :: DocItem di => Maybe Markdown #

Reference to the given section.

Will return Nothing if sections of given doc item type are not assumed to be referred outside.

subDocToMarkdown :: HeaderLevel -> SubDoc -> Markdown #

Render documentation for SubDoc.

data DAnchor #

A hand-made anchor.

Constructors

DAnchor Anchor

Instances

Instances details

DocItem DAnchor
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DAnchor :: DocItemPlacementKind # type DocItemReferenced DAnchor :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DAnchor -> DocItemRef (DocItemPlacement DAnchor) (DocItemReferenced DAnchor) # docItemToMarkdown :: HeaderLevel -> DAnchor -> Markdown # docItemToToc :: HeaderLevel -> DAnchor -> Markdown # docItemDependencies :: DAnchor -> [SomeDocDefinitionItem] # docItemsOrder :: [DAnchor] -> [DAnchor] #
type DocItemPlacement DAnchor
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DAnchor = 'DocItemInlined
type DocItemReferenced DAnchor
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DAnchor = 'False

data DComment #

Comment in the doc (mostly used for licenses)

Constructors

DComment Text

Instances

Instances details

DocItem DComment
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DComment :: DocItemPlacementKind # type DocItemReferenced DComment :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DComment -> DocItemRef (DocItemPlacement DComment) (DocItemReferenced DComment) # docItemToMarkdown :: HeaderLevel -> DComment -> Markdown # docItemToToc :: HeaderLevel -> DComment -> Markdown # docItemDependencies :: DComment -> [SomeDocDefinitionItem] # docItemsOrder :: [DComment] -> [DComment] #
type DocItemPlacement DComment
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DComment = 'DocItemInlined
type DocItemReferenced DComment
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DComment = 'False

newtype GitRepoSettings #

Repository settings for DGitRevision.

Constructors

GitRepoSettings
Fields grsMkGitRevision :: Text -> Text By commit sha make up a url to that commit in remote repository.

data DGitRevision #

Constructors

DGitRevisionKnown DGitRevisionInfo
DGitRevisionUnknown

Instances

Instances details

DocItem DGitRevision
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DGitRevision :: DocItemPlacementKind # type DocItemReferenced DGitRevision :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DGitRevision -> DocItemRef (DocItemPlacement DGitRevision) (DocItemReferenced DGitRevision) # docItemToMarkdown :: HeaderLevel -> DGitRevision -> Markdown # docItemToToc :: HeaderLevel -> DGitRevision -> Markdown # docItemDependencies :: DGitRevision -> [SomeDocDefinitionItem] # docItemsOrder :: [DGitRevision] -> [DGitRevision] #
type DocItemPlacement DGitRevision
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DGitRevision = 'DocItemInlined
type DocItemReferenced DGitRevision
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DGitRevision = 'False

data DDescription #

Description of something.

Constructors

DDescription Markdown

Instances

Instances details

DocItem DDescription
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DDescription :: DocItemPlacementKind # type DocItemReferenced DDescription :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DDescription -> DocItemRef (DocItemPlacement DDescription) (DocItemReferenced DDescription) # docItemToMarkdown :: HeaderLevel -> DDescription -> Markdown # docItemToToc :: HeaderLevel -> DDescription -> Markdown # docItemDependencies :: DDescription -> [SomeDocDefinitionItem] # docItemsOrder :: [DDescription] -> [DDescription] #
type DocItemPlacement DDescription
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DDescription = 'DocItemInlined
type DocItemReferenced DDescription
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DDescription = 'False

data DName #

Give a name to document block.

Constructors

DName Text SubDoc

Instances

Instances details

DocItem DName
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DName :: DocItemPlacementKind # type DocItemReferenced DName :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DName -> DocItemRef (DocItemPlacement DName) (DocItemReferenced DName) # docItemToMarkdown :: HeaderLevel -> DName -> Markdown # docItemToToc :: HeaderLevel -> DName -> Markdown # docItemDependencies :: DName -> [SomeDocDefinitionItem] # docItemsOrder :: [DName] -> [DName] #
type DocItemPlacement DName
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DName = 'DocItemInlined
type DocItemReferenced DName
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DName = 'False

newtype DGeneralInfoSection #

General (meta-)information about the contract such as git revision, contract's authors, etc. Should be relatively short (not several pages) because it is put somewhere close to the beginning of documentation.

Constructors

DGeneralInfoSection SubDoc

Instances

Instances details

DocItem DGeneralInfoSection
Instance details Defined in Morley.Michelson.Doc Associated Types type DocItemPlacement DGeneralInfoSection :: DocItemPlacementKind # type DocItemReferenced DGeneralInfoSection :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DGeneralInfoSection -> DocItemRef (DocItemPlacement DGeneralInfoSection) (DocItemReferenced DGeneralInfoSection) # docItemToMarkdown :: HeaderLevel -> DGeneralInfoSection -> Markdown # docItemToToc :: HeaderLevel -> DGeneralInfoSection -> Markdown # docItemDependencies :: DGeneralInfoSection -> [SomeDocDefinitionItem] # docItemsOrder :: [DGeneralInfoSection] -> [DGeneralInfoSection] #
type DocItemPlacement DGeneralInfoSection
Instance details Defined in Morley.Michelson.Doc type DocItemPlacement DGeneralInfoSection = 'DocItemInlined
type DocItemReferenced DGeneralInfoSection
Instance details Defined in Morley.Michelson.Doc type DocItemReferenced DGeneralInfoSection = 'False

data WithFinalizedDoc a #

Often there is some tuning recommended prior to rendering the contract, like attaching git revision info; this type designates that those last changes were applied.

For example, at Michelson level you may want to use attachDocCommons.

If you want no special tuning (e.g. for tests), say that explicitly with finalizedAsIs.

Instances

Instances details

Applicative WithFinalizedDoc
Instance details Defined in Morley.Michelson.Doc Methods pure :: a -> WithFinalizedDoc a # (<>) :: WithFinalizedDoc (a -> b) -> WithFinalizedDoc a -> WithFinalizedDoc b # liftA2 :: (a -> b -> c) -> WithFinalizedDoc a -> WithFinalizedDoc b -> WithFinalizedDoc c # (>) :: WithFinalizedDoc a -> WithFinalizedDoc b -> WithFinalizedDoc b # (<*) :: WithFinalizedDoc a -> WithFinalizedDoc b -> WithFinalizedDoc a #
Functor WithFinalizedDoc
Instance details Defined in Morley.Michelson.Doc Methods fmap :: (a -> b) -> WithFinalizedDoc a -> WithFinalizedDoc b # (<$) :: a -> WithFinalizedDoc b -> WithFinalizedDoc a #
Monad WithFinalizedDoc
Instance details Defined in Morley.Michelson.Doc Methods (>>=) :: WithFinalizedDoc a -> (a -> WithFinalizedDoc b) -> WithFinalizedDoc b # (>>) :: WithFinalizedDoc a -> WithFinalizedDoc b -> WithFinalizedDoc b # return :: a -> WithFinalizedDoc a #

class ContainsDoc a => ContainsUpdateableDoc a where #

Some contract languages may support documentation update.

Methods

modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> a -> a #

Modify all documentation items recursively.

Instances

Instances details

ContainsUpdateableDoc (ContractData cp st vd)
Instance details Defined in Lorentz.Run Methods modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> ContractData cp st vd -> ContractData cp st vd #

class ContainsDoc a where #

Everything that contains doc items that can be used to render the documentation.

Methods

buildDocUnfinalized :: a -> ContractDoc #

Gather documentation.

Calling this method directly is discouraged in prod, see buildDoc instead. Using this method in tests is fine though.

Instances

Instances details

ContainsDoc (ContractData cp st vd)
Instance details Defined in Lorentz.Run Methods buildDocUnfinalized :: ContractData cp st vd -> ContractDoc #

type DocGrouping = SubDoc -> SomeDocItem #

A function which groups a piece of doc under one doc item.

contractDocToMarkdown :: ContractDoc -> LText #

Render given contract documentation to markdown document.

finalizedAsIs :: a -> WithFinalizedDoc a #

Mark the code with doc as finalized without any changes.

buildDoc :: ContainsDoc a => WithFinalizedDoc a -> ContractDoc #

Gather documenation.

buildMarkdownDoc :: ContainsDoc a => WithFinalizedDoc a -> LText #

Construct and format documentation in textual form.

modifyDoc :: (ContainsUpdateableDoc a, DocItem i1, DocItem i2) => (i1 -> Maybe i2) -> a -> a #

Recursevly traverse doc items and modify those that match given type.

If mapper returns Nothing, doc item will remain unmodified.

morleyRepoSettings :: GitRepoSettings #

mkDGitRevision :: ExpQ #

Make DGitRevision.

>>> :t $mkDGitRevision
...
... :: GitRepoSettings -> DGitRevision

attachDocCommons :: ContainsUpdateableDoc a => DGitRevision -> a -> WithFinalizedDoc a #

Attach common information that is available only in the end.

type Operation = Operation' Instr #

type Value = Value' Instr #

data BigMap k v #

Instances

Instances details

MapInstrs BigMap
Instance details Defined in Lorentz.Macro Methods mapUpdate :: forall k v (s :: [Type]). NiceComparable k => (k ': (Maybe v ': (BigMap k v ': s))) :-> (BigMap k v ': s) mapInsert :: forall k v (s :: [Type]). NiceComparable k => (k ': (v ': (BigMap k v ': s))) :-> (BigMap k v ': s) # mapInsertNew :: forall k v e (s :: [Type]). (IsoValue (BigMap k v), NiceComparable k, NiceConstant e, Dupable k, KnownValue v) => (forall (s0 :: [Type]). (k ': s0) :-> (e ': s0)) -> (k ': (v ': (BigMap k v ': s))) :-> (BigMap k v ': s) # deleteMap :: forall k v (s :: [Type]). (NiceComparable k, KnownValue v) => (k ': (BigMap k v ': s)) :-> (BigMap k v ': s) #
Foldable (BigMap k)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods fold :: Monoid m => BigMap k m -> m # foldMap :: Monoid m => (a -> m) -> BigMap k a -> m # foldMap' :: Monoid m => (a -> m) -> BigMap k a -> m # foldr :: (a -> b -> b) -> b -> BigMap k a -> b # foldr' :: (a -> b -> b) -> b -> BigMap k a -> b # foldl :: (b -> a -> b) -> b -> BigMap k a -> b # foldl' :: (b -> a -> b) -> b -> BigMap k a -> b # foldr1 :: (a -> a -> a) -> BigMap k a -> a # foldl1 :: (a -> a -> a) -> BigMap k a -> a # toList :: BigMap k a -> [a] # null :: BigMap k a -> Bool # length :: BigMap k a -> Int # elem :: Eq a => a -> BigMap k a -> Bool # maximum :: Ord a => BigMap k a -> a # minimum :: Ord a => BigMap k a -> a # sum :: Num a => BigMap k a -> a # product :: Num a => BigMap k a -> a #
(CanCastTo k1 k2, CanCastTo v1 v2) => CanCastTo (BigMap k1 v1 :: Type) (BigMap k2 v2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (BigMap k1 v1) -> Proxy (BigMap k2 v2) -> () #
(Data k, Data v, Ord k) => Data (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BigMap k v -> c (BigMap k v) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BigMap k v) # toConstr :: BigMap k v -> Constr # dataTypeOf :: BigMap k v -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BigMap k v)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BigMap k v)) # gmapT :: (forall b. Data b => b -> b) -> BigMap k v -> BigMap k v # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BigMap k v -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BigMap k v -> r # gmapQ :: (forall d. Data d => d -> u) -> BigMap k v -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BigMap k v -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BigMap k v -> m (BigMap k v) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BigMap k v -> m (BigMap k v) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BigMap k v -> m (BigMap k v) #
Ord k => Semigroup (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (<>) :: BigMap k v -> BigMap k v -> BigMap k v # sconcat :: NonEmpty (BigMap k v) -> BigMap k v # stimes :: Integral b => b -> BigMap k v -> BigMap k v #
Ord k => IsList (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type Item (BigMap k v) # Methods fromList :: [Item (BigMap k v)] -> BigMap k v # fromListN :: Int -> [Item (BigMap k v)] -> BigMap k v # toList :: BigMap k v -> [Item (BigMap k v)] #
Generic (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type Rep (BigMap k v) :: Type -> Type # Methods from :: BigMap k v -> Rep (BigMap k v) x # to :: Rep (BigMap k v) x -> BigMap k v #
(Show k, Show v) => Show (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> BigMap k v -> ShowS # show :: BigMap k v -> String # showList :: [BigMap k v] -> ShowS #
Default (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods def :: BigMap k v #
(Ord k, Buildable k, Buildable v) => Buildable (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods build :: BigMap k v -> Builder #
Ord k => At (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods at :: Index (BigMap k v) -> Lens' (BigMap k v) (Maybe (IxValue (BigMap k v))) #
Ord k => Ixed (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods ix :: Index (BigMap k v) -> Traversal' (BigMap k v) (IxValue (BigMap k v)) #
(HasAnnotation k, HasAnnotation v) => HasAnnotation (BigMap k v)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (BigMap k v)) # annOptions :: Maybe AnnOptions #
NiceComparable k => GetOpHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type GetOpKeyHs (BigMap k v) # type GetOpValHs (BigMap k v) #
NiceComparable k => MemOpHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type MemOpKeyHs (BigMap k v) #
NiceComparable k => UpdOpHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic Associated Types type UpdOpKeyHs (BigMap k v) # type UpdOpParamsHs (BigMap k v) #
HasRPCRepr (BigMap k v)
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (BigMap k v) #
(PolyCTypeHasDocC '[k], PolyTypeHasDocC '[v], Ord k) => TypeHasDoc (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (BigMap k v) :: FieldDescriptions # Methods typeDocName :: Proxy (BigMap k v) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (BigMap k v) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (BigMap k v) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (BigMap k v) # typeDocMichelsonRep :: TypeDocMichelsonRep (BigMap k v) #
(Comparable (ToT k), Ord k, IsoValue k, IsoValue v, HasNoBigMapToT v, HasNoOpToT v) => IsoValue (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (BigMap k v) :: T # Methods toVal :: BigMap k v -> Value (ToT (BigMap k v)) # fromVal :: Value (ToT (BigMap k v)) -> BigMap k v #
Container (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type Element (BigMap k v) # Methods toList :: BigMap k v -> [Element (BigMap k v)] # null :: BigMap k v -> Bool # foldr :: (Element (BigMap k v) -> b -> b) -> b -> BigMap k v -> b # foldl :: (b -> Element (BigMap k v) -> b) -> b -> BigMap k v -> b # foldl' :: (b -> Element (BigMap k v) -> b) -> b -> BigMap k v -> b # length :: BigMap k v -> Int # elem :: Element (BigMap k v) -> BigMap k v -> Bool # foldMap :: Monoid m => (Element (BigMap k v) -> m) -> BigMap k v -> m # fold :: BigMap k v -> Element (BigMap k v) # foldr' :: (Element (BigMap k v) -> b -> b) -> b -> BigMap k v -> b # notElem :: Element (BigMap k v) -> BigMap k v -> Bool # all :: (Element (BigMap k v) -> Bool) -> BigMap k v -> Bool # any :: (Element (BigMap k v) -> Bool) -> BigMap k v -> Bool # and :: BigMap k v -> Bool # or :: BigMap k v -> Bool # find :: (Element (BigMap k v) -> Bool) -> BigMap k v -> Maybe (Element (BigMap k v)) # safeHead :: BigMap k v -> Maybe (Element (BigMap k v)) # safeMaximum :: BigMap k v -> Maybe (Element (BigMap k v)) # safeMinimum :: BigMap k v -> Maybe (Element (BigMap k v)) # safeFoldr1 :: (Element (BigMap k v) -> Element (BigMap k v) -> Element (BigMap k v)) -> BigMap k v -> Maybe (Element (BigMap k v)) # safeFoldl1 :: (Element (BigMap k v) -> Element (BigMap k v) -> Element (BigMap k v)) -> BigMap k v -> Maybe (Element (BigMap k v)) #
One (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type OneItem (BigMap k v) # Methods one :: OneItem (BigMap k v) -> BigMap k v #
(NiceComparable key, KnownValue value) => StoreHasSubmap (BigMap key value) SelfRef key value
Instance details Defined in Lorentz.StoreClass Methods storeSubmapOps :: StoreSubmapOps (BigMap key value) SelfRef key value #
type Item (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type Item (BigMap k v) = Item (Map k v)
type Rep (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type Rep (BigMap k v) = D1 ('MetaData "BigMap" "Morley.Michelson.Typed.Haskell.Value" "morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177" 'False) (C1 ('MetaCons "BigMap" 'PrefixI 'True) (S1 ('MetaSel ('Just "bmId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe (BigMapId k v))) :*: S1 ('MetaSel ('Just "bmMap") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Map k v))))
type Index (BigMap k _1)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type Index (BigMap k _1) = k
type IxValue (BigMap _1 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type IxValue (BigMap _1 v) = v
type GetOpKeyHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic type GetOpKeyHs (BigMap k v) = k
type GetOpValHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic type GetOpValHs (BigMap k v) = v
type MemOpKeyHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic type MemOpKeyHs (BigMap k v) = k
type UpdOpKeyHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic type UpdOpKeyHs (BigMap k v) = k
type UpdOpParamsHs (BigMap k v)
Instance details Defined in Lorentz.Polymorphic type UpdOpParamsHs (BigMap k v) = Maybe v
type AsRPC (BigMap k v)
Instance details Defined in Morley.AsRPC type AsRPC (BigMap k v) = BigMapId k v
type TypeDocFieldDescriptions (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (BigMap k v) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (BigMap k v) = 'TBigMap (ToT k) (ToT v)
type Element (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type Element (BigMap k v) = ElementDefault (BigMap k v)
type OneItem (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type OneItem (BigMap k v) = OneItem (Map k v)

newtype BigMapId (k2 :: k) (v :: k1) #

Phantom type that represents the ID of a big_map with keys of type k and values of type v.

Constructors

BigMapId
Fields unBigMapId :: Natural

Instances

Instances details

(Typeable k2, Typeable v, Typeable k1, Typeable k3) => Data (BigMapId k2 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BigMapId k2 v -> c (BigMapId k2 v) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BigMapId k2 v) # toConstr :: BigMapId k2 v -> Constr # dataTypeOf :: BigMapId k2 v -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BigMapId k2 v)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BigMapId k2 v)) # gmapT :: (forall b. Data b => b -> b) -> BigMapId k2 v -> BigMapId k2 v # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BigMapId k2 v -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BigMapId k2 v -> r # gmapQ :: (forall d. Data d => d -> u) -> BigMapId k2 v -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BigMapId k2 v -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BigMapId k2 v -> m (BigMapId k2 v) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BigMapId k2 v -> m (BigMapId k2 v) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BigMapId k2 v -> m (BigMapId k2 v) #
Num (BigMapId k2 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (+) :: BigMapId k2 v -> BigMapId k2 v -> BigMapId k2 v # (-) :: BigMapId k2 v -> BigMapId k2 v -> BigMapId k2 v # (*) :: BigMapId k2 v -> BigMapId k2 v -> BigMapId k2 v # negate :: BigMapId k2 v -> BigMapId k2 v # abs :: BigMapId k2 v -> BigMapId k2 v # signum :: BigMapId k2 v -> BigMapId k2 v # fromInteger :: Integer -> BigMapId k2 v #
Show (BigMapId k2 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> BigMapId k2 v -> ShowS # show :: BigMapId k2 v -> String # showList :: [BigMapId k2 v] -> ShowS #
Buildable (BigMapId k2 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods build :: BigMapId k2 v -> Builder #
HasAnnotation (BigMapId k3 v)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (BigMapId k3 v)) # annOptions :: Maybe AnnOptions #
IsoValue (BigMapId k2 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (BigMapId k2 v) :: T # Methods toVal :: BigMapId k2 v -> Value (ToT (BigMapId k2 v)) # fromVal :: Value (ToT (BigMapId k2 v)) -> BigMapId k2 v #
type ToT (BigMapId k2 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (BigMapId k2 v) = ToT Natural

data Ticket arg #

Ticket type.

Constructors

Ticket
Fields tTicketer :: Address tData :: arg tAmount :: Natural

Instances

Instances details

Show arg => Show (Ticket arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> Ticket arg -> ShowS # show :: Ticket arg -> String # showList :: [Ticket arg] -> ShowS #
Eq arg => Eq (Ticket arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (==) :: Ticket arg -> Ticket arg -> Bool # (/=) :: Ticket arg -> Ticket arg -> Bool #
HasAnnotation d => HasAnnotation (Ticket d)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (Ticket d)) # annOptions :: Maybe AnnOptions #
NiceComparable d => NonZero (Ticket d)
Instance details Defined in Lorentz.Macro Methods nonZero :: forall (s :: [Type]). (Ticket d ': s) :-> (Maybe (Ticket d) ': s) #
PolyTypeHasDocC '[a] => TypeHasDoc (Ticket a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Ticket a) :: FieldDescriptions # Methods typeDocName :: Proxy (Ticket a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Ticket a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Ticket a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Ticket a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Ticket a) #
(Comparable (ToT a), IsoValue a) => IsoValue (Ticket a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Ticket a) :: T # Methods toVal :: Ticket a -> Value (ToT (Ticket a)) # fromVal :: Value (ToT (Ticket a)) -> Ticket a #
type TypeDocFieldDescriptions (Ticket a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Ticket a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (Ticket a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Ticket a) = 'TTicket (ToT a)

data ContractRef arg #

Since Contract name is used to designate contract code, lets call analogy of TContract type as follows.

Note that type argument always designates an argument of entrypoint. If a contract has explicit default entrypoint (and no root entrypoint), ContractRef referring to it can never have the entire parameter as its type argument.

Constructors

ContractRef
Fields crAddress :: Address crEntrypoint :: SomeEntrypointCall arg

Instances

Instances details

cp ~ cp' => FromContractRef cp (ContractRef cp')
Instance details Defined in Lorentz.Address Methods fromContractRef :: ContractRef cp -> ContractRef cp' #
cp ~ cp' => ToContractRef cp (ContractRef cp')
Instance details Defined in Lorentz.Address Methods toContractRef :: ContractRef cp' -> ContractRef cp #
Show (ContractRef arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods showsPrec :: Int -> ContractRef arg -> ShowS # show :: ContractRef arg -> String # showList :: [ContractRef arg] -> ShowS #
IsoValue (ContractRef arg) => Buildable (ContractRef arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods build :: ContractRef arg -> Builder #
Eq (ContractRef arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Methods (==) :: ContractRef arg -> ContractRef arg -> Bool # (/=) :: ContractRef arg -> ContractRef arg -> Bool #
ToAddress (ContractRef cp)
Instance details Defined in Lorentz.Address Methods toAddress :: ContractRef cp -> Address #
HasAnnotation a => HasAnnotation (ContractRef a)
Instance details Defined in Lorentz.Annotation Methods getAnnotation :: FollowEntrypointFlag -> Notes (ToT (ContractRef a)) # annOptions :: Maybe AnnOptions #
HasRPCRepr (ContractRef arg)
Instance details Defined in Morley.AsRPC Associated Types type AsRPC (ContractRef arg) #
PolyTypeHasDocC '[cp] => TypeHasDoc (ContractRef cp)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (ContractRef cp) :: FieldDescriptions # Methods typeDocName :: Proxy (ContractRef cp) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (ContractRef cp) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (ContractRef cp) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (ContractRef cp) # typeDocMichelsonRep :: TypeDocMichelsonRep (ContractRef cp) #
(HasNoOpToT arg, HasNoNestedBigMaps (ToT arg), WellTypedToT arg) => IsoValue (ContractRef arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (ContractRef arg) :: T # Methods toVal :: ContractRef arg -> Value (ToT (ContractRef arg)) # fromVal :: Value (ToT (ContractRef arg)) -> ContractRef arg #
CanCastTo a1 a2 => CanCastTo (ContractRef a1 :: Type) (ContractRef a2 :: Type)
Instance details Defined in Lorentz.Coercions Methods castDummy :: Proxy (ContractRef a1) -> Proxy (ContractRef a2) -> () #
type AsRPC (ContractRef arg)
Instance details Defined in Morley.AsRPC type AsRPC (ContractRef arg) = ContractRef arg
type TypeDocFieldDescriptions (ContractRef cp)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (ContractRef cp) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type ToT (ContractRef arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (ContractRef arg) = 'TContract (ToT arg)

type WellTypedToT a = (IsoValue a, WellTyped (ToT a)) #

type SomeEntrypointCall arg = SomeEntrypointCallT (ToT arg) #

type EntrypointCall param arg = EntrypointCallT (ToT param) (ToT arg) #

class WellTypedToT a => IsoValue a where #

Isomorphism between Michelson values and plain Haskell types.

Default implementation of this typeclass converts ADTs to Michelson "pair"s and "or"s.

Minimal complete definition

Nothing

Associated Types

type ToT a :: T #

Type function that converts a regular Haskell type into a T type.

type ToT a = GValueType (Rep a)

Methods

toVal :: a -> Value (ToT a) #

Converts a Haskell structure into Value representation.

fromVal :: Value (ToT a) -> a #

Converts a Value into Haskell type.

Instances

Instances details

IsoValue Void
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Void :: T # Methods toVal :: Void -> Value (ToT Void) # fromVal :: Value (ToT Void) -> Void #
IsoValue ByteString
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT ByteString :: T # Methods toVal :: ByteString -> Value (ToT ByteString) # fromVal :: Value (ToT ByteString) -> ByteString #
IsoValue UnspecifiedError
Instance details Defined in Lorentz.Errors Associated Types type ToT UnspecifiedError :: T # Methods toVal :: UnspecifiedError -> Value (ToT UnspecifiedError) # fromVal :: Value (ToT UnspecifiedError) -> UnspecifiedError #
IsoValue Never
Instance details Defined in Lorentz.Value Associated Types type ToT Never :: T # Methods toVal :: Never -> Value (ToT Never) # fromVal :: Value (ToT Never) -> Never #
IsoValue OpenChest
Instance details Defined in Lorentz.Value Associated Types type ToT OpenChest :: T # Methods toVal :: OpenChest -> Value (ToT OpenChest) # fromVal :: Value (ToT OpenChest) -> OpenChest #
IsoValue ZSNil
Instance details Defined in Lorentz.Zip Associated Types type ToT ZSNil :: T # Methods toVal :: ZSNil -> Value (ToT ZSNil) # fromVal :: Value (ToT ZSNil) -> ZSNil #
IsoValue MText
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT MText :: T # Methods toVal :: MText -> Value (ToT MText) # fromVal :: Value (ToT MText) -> MText #
IsoValue Operation
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Operation :: T # Methods toVal :: Operation -> Value (ToT Operation) # fromVal :: Value (ToT Operation) -> Operation #
IsoValue EpAddress
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT EpAddress :: T # Methods toVal :: EpAddress -> Value (ToT EpAddress) # fromVal :: Value (ToT EpAddress) -> EpAddress #
IsoValue MyType2
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product Associated Types type ToT MyType2 :: T # Methods toVal :: MyType2 -> Value (ToT MyType2) # fromVal :: Value (ToT MyType2) -> MyType2 #
IsoValue MyCompoundType
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type ToT MyCompoundType :: T # Methods toVal :: MyCompoundType -> Value (ToT MyCompoundType) # fromVal :: Value (ToT MyCompoundType) -> MyCompoundType #
IsoValue MyEnum
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type ToT MyEnum :: T # Methods toVal :: MyEnum -> Value (ToT MyEnum) # fromVal :: Value (ToT MyEnum) -> MyEnum #
IsoValue MyType
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type ToT MyType :: T # Methods toVal :: MyType -> Value (ToT MyType) # fromVal :: Value (ToT MyType) -> MyType #
IsoValue MyType'
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type ToT MyType' :: T # Methods toVal :: MyType' -> Value (ToT MyType') # fromVal :: Value (ToT MyType') -> MyType' #
IsoValue MyTypeWithNamedField
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum Associated Types type ToT MyTypeWithNamedField :: T # Methods toVal :: MyTypeWithNamedField -> Value (ToT MyTypeWithNamedField) # fromVal :: Value (ToT MyTypeWithNamedField) -> MyTypeWithNamedField #
IsoValue Address
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Address :: T # Methods toVal :: Address -> Value (ToT Address) # fromVal :: Value (ToT Address) -> Address #
IsoValue ChainId
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT ChainId :: T # Methods toVal :: ChainId -> Value (ToT ChainId) # fromVal :: Value (ToT ChainId) -> ChainId #
IsoValue Mutez
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Mutez :: T # Methods toVal :: Mutez -> Value (ToT Mutez) # fromVal :: Value (ToT Mutez) -> Mutez #
IsoValue Timestamp
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Timestamp :: T # Methods toVal :: Timestamp -> Value (ToT Timestamp) # fromVal :: Value (ToT Timestamp) -> Timestamp #
IsoValue KeyHash
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT KeyHash :: T # Methods toVal :: KeyHash -> Value (ToT KeyHash) # fromVal :: Value (ToT KeyHash) -> KeyHash #
IsoValue PublicKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT PublicKey :: T # Methods toVal :: PublicKey -> Value (ToT PublicKey) # fromVal :: Value (ToT PublicKey) -> PublicKey #
IsoValue Signature
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Signature :: T # Methods toVal :: Signature -> Value (ToT Signature) # fromVal :: Value (ToT Signature) -> Signature #
IsoValue Bls12381Fr
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bls12381Fr :: T # Methods toVal :: Bls12381Fr -> Value (ToT Bls12381Fr) # fromVal :: Value (ToT Bls12381Fr) -> Bls12381Fr #
IsoValue Bls12381G1
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bls12381G1 :: T # Methods toVal :: Bls12381G1 -> Value (ToT Bls12381G1) # fromVal :: Value (ToT Bls12381G1) -> Bls12381G1 #
IsoValue Bls12381G2
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bls12381G2 :: T # Methods toVal :: Bls12381G2 -> Value (ToT Bls12381G2) # fromVal :: Value (ToT Bls12381G2) -> Bls12381G2 #
IsoValue Chest
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Chest :: T # Methods toVal :: Chest -> Value (ToT Chest) # fromVal :: Value (ToT Chest) -> Chest #
IsoValue ChestKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT ChestKey :: T # Methods toVal :: ChestKey -> Value (ToT ChestKey) # fromVal :: Value (ToT ChestKey) -> ChestKey #
(Bottom, DoNotUseTextError :: Constraint) => IsoValue Text
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Text :: T # Methods toVal :: Text -> Value (ToT Text) # fromVal :: Value (ToT Text) -> Text #
IsoValue Integer
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Integer :: T # Methods toVal :: Integer -> Value (ToT Integer) # fromVal :: Value (ToT Integer) -> Integer #
IsoValue Natural
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Natural :: T # Methods toVal :: Natural -> Value (ToT Natural) # fromVal :: Value (ToT Natural) -> Natural #
IsoValue ()
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT () :: T # Methods toVal :: () -> Value (ToT ()) # fromVal :: Value (ToT ()) -> () #
IsoValue Bool
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT Bool :: T # Methods toVal :: Bool -> Value (ToT Bool) # fromVal :: Value (ToT Bool) -> Bool #
IsoValue a => IsoValue (Identity a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Identity a) :: T # Methods toVal :: Identity a -> Value (ToT (Identity a)) # fromVal :: Value (ToT (Identity a)) -> Identity a #
(Comparable (ToT c), Ord c, IsoValue c) => IsoValue (Set c)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Set c) :: T # Methods toVal :: Set c -> Value (ToT (Set c)) # fromVal :: Value (ToT (Set c)) -> Set c #
IsoValue (FutureContract arg)
Instance details Defined in Lorentz.Address Associated Types type ToT (FutureContract arg) :: T # Methods toVal :: FutureContract arg -> Value (ToT (FutureContract arg)) # fromVal :: Value (ToT (FutureContract arg)) -> FutureContract arg #
IsoValue (ChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type ToT (ChestT a) :: T # Methods toVal :: ChestT a -> Value (ToT (ChestT a)) # fromVal :: Value (ToT (ChestT a)) -> ChestT a #
IsoValue a => IsoValue (OpenChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type ToT (OpenChestT a) :: T # Methods toVal :: OpenChestT a -> Value (ToT (OpenChestT a)) # fromVal :: Value (ToT (OpenChestT a)) -> OpenChestT a #
IsoValue (Packed a)
Instance details Defined in Lorentz.Bytes Associated Types type ToT (Packed a) :: T # Methods toVal :: Packed a -> Value (ToT (Packed a)) # fromVal :: Value (ToT (Packed a)) -> Packed a #
IsoValue (TSignature a)
Instance details Defined in Lorentz.Bytes Associated Types type ToT (TSignature a) :: T # Methods toVal :: TSignature a -> Value (ToT (TSignature a)) # fromVal :: Value (ToT (TSignature a)) -> TSignature a #
WellTypedToT r => IsoValue (ShouldHaveEntrypoints r)
Instance details Defined in Lorentz.Entrypoints.Helpers Associated Types type ToT (ShouldHaveEntrypoints r) :: T # Methods toVal :: ShouldHaveEntrypoints r -> Value (ToT (ShouldHaveEntrypoints r)) # fromVal :: Value (ToT (ShouldHaveEntrypoints r)) -> ShouldHaveEntrypoints r #
(Bottom, WellTypedToT (CustomErrorRep tag), TypeError ('Text "CustomError has no IsoValue instance") :: Constraint) => IsoValue (CustomError tag)	This instance cannot be implemented, use `IsError` instance instead.
Instance details Defined in Lorentz.Errors Associated Types type ToT (CustomError tag) :: T # Methods toVal :: CustomError tag -> Value (ToT (CustomError tag)) # fromVal :: Value (ToT (CustomError tag)) -> CustomError tag #
(Bottom, WellTypedToT (VoidResult r), TypeError ('Text "No IsoValue instance for VoidResult " :<>: 'ShowType r) :: Constraint) => IsoValue (VoidResult r)
Instance details Defined in Lorentz.Macro Associated Types type ToT (VoidResult r) :: T # Methods toVal :: VoidResult r -> Value (ToT (VoidResult r)) # fromVal :: Value (ToT (VoidResult r)) -> VoidResult r #
IsoValue (UParam entries)
Instance details Defined in Lorentz.UParam Associated Types type ToT (UParam entries) :: T # Methods toVal :: UParam entries -> Value (ToT (UParam entries)) # fromVal :: Value (ToT (UParam entries)) -> UParam entries #
IsoValue a => IsoValue (ReadTicket a)
Instance details Defined in Lorentz.Value Associated Types type ToT (ReadTicket a) :: T # Methods toVal :: ReadTicket a -> Value (ToT (ReadTicket a)) # fromVal :: Value (ToT (ReadTicket a)) -> ReadTicket a #
WellTyped t => IsoValue (Value t)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Value t) :: T # Methods toVal :: Value t -> Value (ToT (Value t)) # fromVal :: Value (ToT (Value t)) -> Value t #
(HasNoOpToT arg, HasNoNestedBigMaps (ToT arg), WellTypedToT arg) => IsoValue (ContractRef arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (ContractRef arg) :: T # Methods toVal :: ContractRef arg -> Value (ToT (ContractRef arg)) # fromVal :: Value (ToT (ContractRef arg)) -> ContractRef arg #
(Comparable (ToT a), IsoValue a) => IsoValue (Ticket a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Ticket a) :: T # Methods toVal :: Ticket a -> Value (ToT (Ticket a)) # fromVal :: Value (ToT (Ticket a)) -> Ticket a #
IsoValue a => IsoValue (Maybe a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Maybe a) :: T # Methods toVal :: Maybe a -> Value (ToT (Maybe a)) # fromVal :: Value (ToT (Maybe a)) -> Maybe a #
IsoValue a => IsoValue [a]
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT [a] :: T # Methods toVal :: [a] -> Value (ToT [a]) # fromVal :: Value (ToT [a]) -> [a] #
(IsoValue l, IsoValue r) => IsoValue (Either l r)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Either l r) :: T # Methods toVal :: Either l r -> Value (ToT (Either l r)) # fromVal :: Value (ToT (Either l r)) -> Either l r #
IsoValue (Fixed p)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Fixed p) :: T # Methods toVal :: Fixed p -> Value (ToT (Fixed p)) # fromVal :: Value (ToT (Fixed p)) -> Fixed p #
(Comparable (ToT k), Ord k, IsoValue k, IsoValue v) => IsoValue (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (Map k v) :: T # Methods toVal :: Map k v -> Value (ToT (Map k v)) # fromVal :: Value (ToT (Map k v)) -> Map k v #
IsoValue (TAddress p vd)
Instance details Defined in Lorentz.Address Associated Types type ToT (TAddress p vd) :: T # Methods toVal :: TAddress p vd -> Value (ToT (TAddress p vd)) # fromVal :: Value (ToT (TAddress p vd)) -> TAddress p vd #
(NoLambdaCodeIsomorphismError, WellTyped (LorentzCodeIsNotIsomorphicToMichelsonValues :: T)) => IsoValue (inp :-> out)
Instance details Defined in Lorentz.Base Associated Types type ToT (inp :-> out) :: T # Methods toVal :: (inp :-> out) -> Value (ToT (inp :-> out)) # fromVal :: Value (ToT (inp :-> out)) -> inp :-> out #
IsoValue (Hash alg a)
Instance details Defined in Lorentz.Bytes Associated Types type ToT (Hash alg a) :: T # Methods toVal :: Hash alg a -> Value (ToT (Hash alg a)) # fromVal :: Value (ToT (Hash alg a)) -> Hash alg a #
IsoValue cp => IsoValue (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual Associated Types type ToT (ParameterWrapper deriv cp) :: T # Methods toVal :: ParameterWrapper deriv cp -> Value (ToT (ParameterWrapper deriv cp)) # fromVal :: Value (ToT (ParameterWrapper deriv cp)) -> ParameterWrapper deriv cp #
(KnownList i, ZipInstr i, ZipInstr o) => IsoValue (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Associated Types type ToT (WrappedLambda i o) :: T # Methods toVal :: WrappedLambda i o -> Value (ToT (WrappedLambda i o)) # fromVal :: Value (ToT (WrappedLambda i o)) -> WrappedLambda i o #
(HasNoOpToT r, HasNoNestedBigMaps (ToT r), WellTypedToT a) => IsoValue (View_ a r)
Instance details Defined in Lorentz.Macro Associated Types type ToT (View_ a r) :: T # Methods toVal :: View_ a r -> Value (ToT (View_ a r)) # fromVal :: Value (ToT (View_ a r)) -> View_ a r #
(WellTypedToT r, WellTypedToT a) => IsoValue (Void_ a r)
Instance details Defined in Lorentz.Macro Associated Types type ToT (Void_ a r) :: T # Methods toVal :: Void_ a r -> Value (ToT (Void_ a r)) # fromVal :: Value (ToT (Void_ a r)) -> Void_ a r #
(IsoValue a, IsoValue b) => IsoValue (ZippedStackRepr a b)
Instance details Defined in Lorentz.Zip Associated Types type ToT (ZippedStackRepr a b) :: T # Methods toVal :: ZippedStackRepr a b -> Value (ToT (ZippedStackRepr a b)) # fromVal :: Value (ToT (ZippedStackRepr a b)) -> ZippedStackRepr a b #
(Comparable (ToT k), Ord k, IsoValue k, IsoValue v, HasNoBigMapToT v, HasNoOpToT v) => IsoValue (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (BigMap k v) :: T # Methods toVal :: BigMap k v -> Value (ToT (BigMap k v)) # fromVal :: Value (ToT (BigMap k v)) -> BigMap k v #
(IsoValue a, IsoValue b) => IsoValue (a, b)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b) :: T # Methods toVal :: (a, b) -> Value (ToT (a, b)) # fromVal :: Value (ToT (a, b)) -> (a, b) #
IsoValue a => IsoValue (NamedF Identity a name)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (NamedF Identity a name) :: T # Methods toVal :: NamedF Identity a name -> Value (ToT (NamedF Identity a name)) # fromVal :: Value (ToT (NamedF Identity a name)) -> NamedF Identity a name #
IsoValue a => IsoValue (NamedF Maybe a name)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (NamedF Maybe a name) :: T # Methods toVal :: NamedF Maybe a name -> Value (ToT (NamedF Maybe a name)) # fromVal :: Value (ToT (NamedF Maybe a name)) -> NamedF Maybe a name #
(IsoValue a, IsoValue b, IsoValue c) => IsoValue (a, b, c)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b, c) :: T # Methods toVal :: (a, b, c) -> Value (ToT (a, b, c)) # fromVal :: Value (ToT (a, b, c)) -> (a, b, c) #
IsoValue (BigMapId k2 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (BigMapId k2 v) :: T # Methods toVal :: BigMapId k2 v -> Value (ToT (BigMapId k2 v)) # fromVal :: Value (ToT (BigMapId k2 v)) -> BigMapId k2 v #
(IsoValue a, IsoValue b, IsoValue c, IsoValue d) => IsoValue (a, b, c, d)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b, c, d) :: T # Methods toVal :: (a, b, c, d) -> Value (ToT (a, b, c, d)) # fromVal :: Value (ToT (a, b, c, d)) -> (a, b, c, d) #
(IsoValue a, IsoValue b, IsoValue c, IsoValue d, IsoValue e) => IsoValue (a, b, c, d, e)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b, c, d, e) :: T # Methods toVal :: (a, b, c, d, e) -> Value (ToT (a, b, c, d, e)) # fromVal :: Value (ToT (a, b, c, d, e)) -> (a, b, c, d, e) #
(IsoValue a, IsoValue b, IsoValue c, IsoValue d, IsoValue e, IsoValue f) => IsoValue (a, b, c, d, e, f)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b, c, d, e, f) :: T # Methods toVal :: (a, b, c, d, e, f) -> Value (ToT (a, b, c, d, e, f)) # fromVal :: Value (ToT (a, b, c, d, e, f)) -> (a, b, c, d, e, f) #
(IsoValue a, IsoValue b, IsoValue c, IsoValue d, IsoValue e, IsoValue f, IsoValue g) => IsoValue (a, b, c, d, e, f, g)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type ToT (a, b, c, d, e, f, g) :: T # Methods toVal :: (a, b, c, d, e, f, g) -> Value (ToT (a, b, c, d, e, f, g)) # fromVal :: Value (ToT (a, b, c, d, e, f, g)) -> (a, b, c, d, e, f, g) #

type family ToT a :: T #

Type function that converts a regular Haskell type into a T type.

Instances

Instances details

type ToT Void
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Void = GValueType (Rep Void)
type ToT ByteString
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT ByteString = 'TBytes
type ToT UnspecifiedError
Instance details Defined in Lorentz.Errors type ToT UnspecifiedError = GValueType (Rep UnspecifiedError)
type ToT Never
Instance details Defined in Lorentz.Value type ToT Never = GValueType (Rep Never)
type ToT OpenChest
Instance details Defined in Lorentz.Value type ToT OpenChest = GValueType (Rep OpenChest)
type ToT ZSNil
Instance details Defined in Lorentz.Zip type ToT ZSNil = GValueType (Rep ZSNil)
type ToT MText
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT MText = 'TString
type ToT Operation
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Operation = 'TOperation
type ToT EpAddress
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT EpAddress = 'TAddress
type ToT MyType2
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Product type ToT MyType2 = GValueType (Rep MyType2)
type ToT MyCompoundType
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type ToT MyCompoundType = GValueType (Rep MyCompoundType)
type ToT MyEnum
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type ToT MyEnum = GValueType (Rep MyEnum)
type ToT MyType
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type ToT MyType = GValueType (Rep MyType)
type ToT MyType'
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type ToT MyType' = GValueType (Rep MyType')
type ToT MyTypeWithNamedField
Instance details Defined in Morley.Michelson.Typed.Haskell.Instr.Sum type ToT MyTypeWithNamedField = GValueType (Rep MyTypeWithNamedField)
type ToT Address
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Address = 'TAddress
type ToT ChainId
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT ChainId = 'TChainId
type ToT Mutez
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Mutez = 'TMutez
type ToT Timestamp
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Timestamp = 'TTimestamp
type ToT KeyHash
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT KeyHash = 'TKeyHash
type ToT PublicKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT PublicKey = 'TKey
type ToT Signature
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Signature = 'TSignature
type ToT Bls12381Fr
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Bls12381Fr = 'TBls12381Fr
type ToT Bls12381G1
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Bls12381G1 = 'TBls12381G1
type ToT Bls12381G2
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Bls12381G2 = 'TBls12381G2
type ToT Chest
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Chest = 'TChest
type ToT ChestKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT ChestKey = 'TChestKey
type ToT Text
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Text = ToT MText
type ToT Integer
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Integer = 'TInt
type ToT Natural
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Natural = 'TNat
type ToT ()
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT () = GValueType (Rep ())
type ToT Bool
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT Bool = 'TBool
type ToT (Identity a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Identity a) = ToT a
type ToT (Set c)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Set c) = 'TSet (ToT c)
type ToT (FutureContract arg)
Instance details Defined in Lorentz.Address type ToT (FutureContract arg) = ToT EpAddress
type ToT (ChestT a)
Instance details Defined in Lorentz.Bytes type ToT (ChestT a) = ToT Chest
type ToT (OpenChestT a)
Instance details Defined in Lorentz.Bytes type ToT (OpenChestT a) = GValueType (Rep (OpenChestT a))
type ToT (Packed a)
Instance details Defined in Lorentz.Bytes type ToT (Packed a) = ToT ByteString
type ToT (TSignature a)
Instance details Defined in Lorentz.Bytes type ToT (TSignature a) = ToT Signature
type ToT (ShouldHaveEntrypoints r)
Instance details Defined in Lorentz.Entrypoints.Helpers type ToT (ShouldHaveEntrypoints r) = GValueType (Rep (ShouldHaveEntrypoints r))
type ToT (CustomError tag)
Instance details Defined in Lorentz.Errors type ToT (CustomError tag) = ToT (CustomErrorRep tag)
type ToT (VoidResult r)
Instance details Defined in Lorentz.Macro type ToT (VoidResult r) = TypeError ('Text "No IsoValue instance for VoidResult " :<>: 'ShowType r) :: T
type ToT (UParam entries)
Instance details Defined in Lorentz.UParam type ToT (UParam entries) = GValueType (Rep (UParam entries))
type ToT (ReadTicket a)
Instance details Defined in Lorentz.Value type ToT (ReadTicket a) = GValueType (Rep (ReadTicket a))
type ToT (Value t)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Value t) = t
type ToT (ContractRef arg)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (ContractRef arg) = 'TContract (ToT arg)
type ToT (Ticket a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Ticket a) = 'TTicket (ToT a)
type ToT (Maybe a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Maybe a) = 'TOption (ToT a)
type ToT [a]
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT [a] = 'TList (ToT a)
type ToT (Either l r)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Either l r) = GValueType (Rep (Either l r))
type ToT (Fixed p)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Fixed p) = 'TInt
type ToT (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (Map k v) = 'TMap (ToT k) (ToT v)
type ToT (TAddress p vd)
Instance details Defined in Lorentz.Address type ToT (TAddress p vd) = GValueType (Rep (TAddress p vd))
type ToT (inp :-> out)
Instance details Defined in Lorentz.Base type ToT (inp :-> out) = LorentzCodeIsNotIsomorphicToMichelsonValues :: T
type ToT (Hash alg a)
Instance details Defined in Lorentz.Bytes type ToT (Hash alg a) = ToT ByteString
type ToT (ParameterWrapper deriv cp)
Instance details Defined in Lorentz.Entrypoints.Manual type ToT (ParameterWrapper deriv cp) = GValueType (Rep (ParameterWrapper deriv cp))
type ToT (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda type ToT (WrappedLambda i o) = 'TLambda (ToT (ZippedStack i)) (ToT (ZippedStack o))
type ToT (View_ a r)
Instance details Defined in Lorentz.Macro type ToT (View_ a r) = GValueType (Rep (View_ a r))
type ToT (Void_ a r)
Instance details Defined in Lorentz.Macro type ToT (Void_ a r) = GValueType (Rep (Void_ a r))
type ToT (ZippedStackRepr a b)
Instance details Defined in Lorentz.Zip type ToT (ZippedStackRepr a b) = GValueType (Rep (ZippedStackRepr a b))
type ToT (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (BigMap k v) = 'TBigMap (ToT k) (ToT v)
type ToT (a, b)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (a, b) = GValueType (Rep (a, b))
type ToT (NamedF Identity a name)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (NamedF Identity a name) = ToT (Identity a)
type ToT (NamedF Maybe a name)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (NamedF Maybe a name) = ToT (Maybe a)
type ToT (a, b, c)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (a, b, c) = GValueType (Rep (a, b, c))
type ToT (BigMapId k2 v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (BigMapId k2 v) = ToT Natural
type ToT (a, b, c, d)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (a, b, c, d) = GValueType (Rep (a, b, c, d))
type ToT (a, b, c, d, e)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (a, b, c, d, e) = GValueType (Rep (a, b, c, d, e))
type ToT (a, b, c, d, e, f)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (a, b, c, d, e, f) = GValueType (Rep (a, b, c, d, e, f))
type ToT (a, b, c, d, e, f, g)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type ToT (a, b, c, d, e, f, g) = GValueType (Rep (a, b, c, d, e, f, g))

coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b #

Replace type argument of ContractRef with isomorphic one.

type InstrConstructC dt = (GenericIsoValue dt, GInstrConstruct (Rep dt) ('[] :: [Type])) #

Constraint for instrConstruct and gInstrConstructStack.

type ConstructorFieldTypes dt = GFieldTypes (Rep dt) ('[] :: [Type]) #

Types of all fields in a datatype.

class IsHomomorphic (a :: k) #

Require this type to be homomorphic.

Instances

Instances details

IsHomomorphic (a :: k)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc
(TypeError ('Text "Type is not homomorphic: " :<>: 'ShowType (a b)) :: Constraint) => IsHomomorphic (a b :: k2)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc

class HaveCommonTypeCtor (a :: k) (b :: k1) #

Require two types to be built from the same type constructor.

E.g. HaveCommonTypeCtor (Maybe Integer) (Maybe Natural) is defined, while HaveCmmonTypeCtor (Maybe Integer) [Integer] is not.

Instances

Instances details

HaveCommonTypeCtor (a :: k) (a :: k)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc
HaveCommonTypeCtor ac bc => HaveCommonTypeCtor (ac a :: k2) (bc b :: k4)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc

data DType where #

Doc element with description of a type.

Constructors

DType :: forall a. TypeHasDoc a => Proxy a -> DType

Instances

Instances details

Buildable DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods build :: DType -> Builder #
Eq DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods (==) :: DType -> DType -> Bool # (/=) :: DType -> DType -> Bool #
Ord DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods compare :: DType -> DType -> Ordering # (<) :: DType -> DType -> Bool # (<=) :: DType -> DType -> Bool # (>) :: DType -> DType -> Bool # (>=) :: DType -> DType -> Bool # max :: DType -> DType -> DType # min :: DType -> DType -> DType #
DocItem DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type DocItemPlacement DType :: DocItemPlacementKind # type DocItemReferenced DType :: DocItemReferencedKind # Methods docItemPos :: Natural # docItemSectionName :: Maybe Text # docItemSectionDescription :: Maybe Markdown # docItemSectionNameStyle :: DocSectionNameStyle # docItemRef :: DType -> DocItemRef (DocItemPlacement DType) (DocItemReferenced DType) # docItemToMarkdown :: HeaderLevel -> DType -> Markdown # docItemToToc :: HeaderLevel -> DType -> Markdown # docItemDependencies :: DType -> [SomeDocDefinitionItem] # docItemsOrder :: [DType] -> [DType] #
type DocItemPlacement DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type DocItemPlacement DType = 'DocItemInDefinitions
type DocItemReferenced DType
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type DocItemReferenced DType = 'True

data SomeTypeWithDoc where #

Data hides some type implementing TypeHasDoc.

Constructors

SomeTypeWithDoc :: forall td. TypeHasDoc td => Proxy td -> SomeTypeWithDoc

class (Typeable a, SingI (TypeDocFieldDescriptions a), FieldDescriptionsValid (TypeDocFieldDescriptions a) a) => TypeHasDoc a where #

Description for a Haskell type appearing in documentation.

Minimal complete definition

typeDocMdDescription

Associated Types

type TypeDocFieldDescriptions a :: FieldDescriptions #

Description of constructors and fields of a.

See FieldDescriptions documentation for an example of usage.

Descriptions will be checked at compile time to make sure that only existing constructors and fields are referenced.

For that check to work instance Generic a is required whenever TypeDocFieldDescriptions is not empty.

For implementation of the check see FieldDescriptionsValid type family.

type TypeDocFieldDescriptions a = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]

Methods

typeDocName :: Proxy a -> Text #

Name of type as it appears in definitions section.

Each type must have its own unique name because it will be used in identifier for references.

Default definition derives name from Generics. If it does not fit, consider defining this function manually. (We tried using Data.Data for this, but it produces names including module names which is not do we want).

typeDocMdDescription :: Markdown #

Explanation of a type. Markdown formatting is allowed.

typeDocMdReference :: Proxy a -> WithinParens -> Markdown #

How reference to this type is rendered, in Markdown.

Examples:

[Integer](#type-integer),
[Maybe](#type-Maybe) [()](#type-unit).

Consider using one of the following functions as default implementation; which one to use depends on number of type arguments in your type:

If none of them fits your purposes precisely, consider using customTypeDocMdReference.

typeDocDependencies :: Proxy a -> [SomeDocDefinitionItem] #

All types which this type directly contains.

Used in automatic types discovery.

typeDocHaskellRep :: TypeDocHaskellRep a #

For complex types - their immediate Haskell representation.

For primitive types set this to Nothing.

For homomorphic types use homomorphicTypeDocHaskellRep implementation.

For polymorphic types consider using concreteTypeDocHaskellRep as implementation.

Modifier haskellRepNoFields can be used to hide names of fields, beneficial for newtypes.

Use haskellRepAdjust or haskellRepMap for more involved adjustments.

Also, consider defining an instance of TypeHasFieldNamingStrategy instead of defining this method -- the former can be used downstream, e.g. in lorentz, for better naming consistency.

typeDocMichelsonRep :: TypeDocMichelsonRep a #

Final michelson representation of a type.

For homomorphic types use homomorphicTypeDocMichelsonRep implementation.

For polymorphic types consider using concreteTypeDocMichelsonRep as implementation.

Instances

Instances details

TypeHasDoc ByteString
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions ByteString :: FieldDescriptions # Methods typeDocName :: Proxy ByteString -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy ByteString -> WithinParens -> Markdown # typeDocDependencies :: Proxy ByteString -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep ByteString # typeDocMichelsonRep :: TypeDocMichelsonRep ByteString #
TypeHasDoc Never
Instance details Defined in Lorentz.Value Associated Types type TypeDocFieldDescriptions Never :: FieldDescriptions # Methods typeDocName :: Proxy Never -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Never -> WithinParens -> Markdown # typeDocDependencies :: Proxy Never -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Never # typeDocMichelsonRep :: TypeDocMichelsonRep Never #
TypeHasDoc OpenChest
Instance details Defined in Lorentz.Value Associated Types type TypeDocFieldDescriptions OpenChest :: FieldDescriptions # Methods typeDocName :: Proxy OpenChest -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy OpenChest -> WithinParens -> Markdown # typeDocDependencies :: Proxy OpenChest -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep OpenChest # typeDocMichelsonRep :: TypeDocMichelsonRep OpenChest #
TypeHasDoc MText
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions MText :: FieldDescriptions # Methods typeDocName :: Proxy MText -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy MText -> WithinParens -> Markdown # typeDocDependencies :: Proxy MText -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep MText # typeDocMichelsonRep :: TypeDocMichelsonRep MText #
TypeHasDoc Operation
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Operation :: FieldDescriptions # Methods typeDocName :: Proxy Operation -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Operation -> WithinParens -> Markdown # typeDocDependencies :: Proxy Operation -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Operation # typeDocMichelsonRep :: TypeDocMichelsonRep Operation #
TypeHasDoc EpAddress
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions EpAddress :: FieldDescriptions # Methods typeDocName :: Proxy EpAddress -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy EpAddress -> WithinParens -> Markdown # typeDocDependencies :: Proxy EpAddress -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep EpAddress # typeDocMichelsonRep :: TypeDocMichelsonRep EpAddress #
TypeHasDoc Address
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Address :: FieldDescriptions # Methods typeDocName :: Proxy Address -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Address -> WithinParens -> Markdown # typeDocDependencies :: Proxy Address -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Address # typeDocMichelsonRep :: TypeDocMichelsonRep Address #
TypeHasDoc ChainId
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions ChainId :: FieldDescriptions # Methods typeDocName :: Proxy ChainId -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy ChainId -> WithinParens -> Markdown # typeDocDependencies :: Proxy ChainId -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep ChainId # typeDocMichelsonRep :: TypeDocMichelsonRep ChainId #
TypeHasDoc Mutez
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Mutez :: FieldDescriptions # Methods typeDocName :: Proxy Mutez -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Mutez -> WithinParens -> Markdown # typeDocDependencies :: Proxy Mutez -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Mutez # typeDocMichelsonRep :: TypeDocMichelsonRep Mutez #
TypeHasDoc Timestamp
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Timestamp :: FieldDescriptions # Methods typeDocName :: Proxy Timestamp -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Timestamp -> WithinParens -> Markdown # typeDocDependencies :: Proxy Timestamp -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Timestamp # typeDocMichelsonRep :: TypeDocMichelsonRep Timestamp #
TypeHasDoc KeyHash
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions KeyHash :: FieldDescriptions # Methods typeDocName :: Proxy KeyHash -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy KeyHash -> WithinParens -> Markdown # typeDocDependencies :: Proxy KeyHash -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep KeyHash # typeDocMichelsonRep :: TypeDocMichelsonRep KeyHash #
TypeHasDoc PublicKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions PublicKey :: FieldDescriptions # Methods typeDocName :: Proxy PublicKey -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy PublicKey -> WithinParens -> Markdown # typeDocDependencies :: Proxy PublicKey -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep PublicKey # typeDocMichelsonRep :: TypeDocMichelsonRep PublicKey #
TypeHasDoc Signature
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Signature :: FieldDescriptions # Methods typeDocName :: Proxy Signature -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Signature -> WithinParens -> Markdown # typeDocDependencies :: Proxy Signature -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Signature # typeDocMichelsonRep :: TypeDocMichelsonRep Signature #
TypeHasDoc Chest
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Chest :: FieldDescriptions # Methods typeDocName :: Proxy Chest -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Chest -> WithinParens -> Markdown # typeDocDependencies :: Proxy Chest -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Chest # typeDocMichelsonRep :: TypeDocMichelsonRep Chest #
TypeHasDoc ChestKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions ChestKey :: FieldDescriptions # Methods typeDocName :: Proxy ChestKey -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy ChestKey -> WithinParens -> Markdown # typeDocDependencies :: Proxy ChestKey -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep ChestKey # typeDocMichelsonRep :: TypeDocMichelsonRep ChestKey #
TypeHasDoc Integer
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Integer :: FieldDescriptions # Methods typeDocName :: Proxy Integer -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Integer -> WithinParens -> Markdown # typeDocDependencies :: Proxy Integer -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Integer # typeDocMichelsonRep :: TypeDocMichelsonRep Integer #
TypeHasDoc Natural
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Natural :: FieldDescriptions # Methods typeDocName :: Proxy Natural -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Natural -> WithinParens -> Markdown # typeDocDependencies :: Proxy Natural -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Natural # typeDocMichelsonRep :: TypeDocMichelsonRep Natural #
TypeHasDoc ()
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions () :: FieldDescriptions # Methods typeDocName :: Proxy () -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy () -> WithinParens -> Markdown # typeDocDependencies :: Proxy () -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep () # typeDocMichelsonRep :: TypeDocMichelsonRep () #
TypeHasDoc Bool
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions Bool :: FieldDescriptions # Methods typeDocName :: Proxy Bool -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy Bool -> WithinParens -> Markdown # typeDocDependencies :: Proxy Bool -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep Bool # typeDocMichelsonRep :: TypeDocMichelsonRep Bool #
PolyCTypeHasDocC '[a] => TypeHasDoc (Set a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Set a) :: FieldDescriptions # Methods typeDocName :: Proxy (Set a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Set a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Set a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Set a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Set a) #
TypeHasDoc a => TypeHasDoc (ChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type TypeDocFieldDescriptions (ChestT a) :: FieldDescriptions # Methods typeDocName :: Proxy (ChestT a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (ChestT a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (ChestT a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (ChestT a) # typeDocMichelsonRep :: TypeDocMichelsonRep (ChestT a) #
TypeHasDoc a => TypeHasDoc (OpenChestT a)
Instance details Defined in Lorentz.Bytes Associated Types type TypeDocFieldDescriptions (OpenChestT a) :: FieldDescriptions # Methods typeDocName :: Proxy (OpenChestT a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (OpenChestT a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (OpenChestT a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (OpenChestT a) # typeDocMichelsonRep :: TypeDocMichelsonRep (OpenChestT a) #
TypeHasDoc a => TypeHasDoc (Packed a)
Instance details Defined in Lorentz.Bytes Associated Types type TypeDocFieldDescriptions (Packed a) :: FieldDescriptions # Methods typeDocName :: Proxy (Packed a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Packed a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Packed a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Packed a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Packed a) #
TypeHasDoc a => TypeHasDoc (TSignature a)
Instance details Defined in Lorentz.Bytes Associated Types type TypeDocFieldDescriptions (TSignature a) :: FieldDescriptions # Methods typeDocName :: Proxy (TSignature a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (TSignature a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (TSignature a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (TSignature a) # typeDocMichelsonRep :: TypeDocMichelsonRep (TSignature a) #
(TypeHasDoc r, IsError (VoidResult r)) => TypeHasDoc (VoidResult r)
Instance details Defined in Lorentz.Macro Associated Types type TypeDocFieldDescriptions (VoidResult r) :: FieldDescriptions # Methods typeDocName :: Proxy (VoidResult r) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (VoidResult r) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (VoidResult r) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (VoidResult r) # typeDocMichelsonRep :: TypeDocMichelsonRep (VoidResult r) #
Typeable interface => TypeHasDoc (UParam interface)
Instance details Defined in Lorentz.UParam Associated Types type TypeDocFieldDescriptions (UParam interface) :: FieldDescriptions # Methods typeDocName :: Proxy (UParam interface) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (UParam interface) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (UParam interface) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (UParam interface) # typeDocMichelsonRep :: TypeDocMichelsonRep (UParam interface) #
PolyTypeHasDocC '[cp] => TypeHasDoc (ContractRef cp)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (ContractRef cp) :: FieldDescriptions # Methods typeDocName :: Proxy (ContractRef cp) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (ContractRef cp) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (ContractRef cp) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (ContractRef cp) # typeDocMichelsonRep :: TypeDocMichelsonRep (ContractRef cp) #
PolyTypeHasDocC '[a] => TypeHasDoc (Ticket a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Ticket a) :: FieldDescriptions # Methods typeDocName :: Proxy (Ticket a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Ticket a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Ticket a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Ticket a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Ticket a) #
PolyTypeHasDocC '[a] => TypeHasDoc (Maybe a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Maybe a) :: FieldDescriptions # Methods typeDocName :: Proxy (Maybe a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Maybe a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Maybe a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Maybe a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Maybe a) #
PolyTypeHasDocC '[a] => TypeHasDoc [a]
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions [a] :: FieldDescriptions # Methods typeDocName :: Proxy [a] -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy [a] -> WithinParens -> Markdown # typeDocDependencies :: Proxy [a] -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep [a] # typeDocMichelsonRep :: TypeDocMichelsonRep [a] #
PolyTypeHasDocC '[l, r] => TypeHasDoc (Either l r)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Either l r) :: FieldDescriptions # Methods typeDocName :: Proxy (Either l r) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Either l r) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Either l r) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Either l r) # typeDocMichelsonRep :: TypeDocMichelsonRep (Either l r) #
(PolyCTypeHasDocC '[k], PolyTypeHasDocC '[v], Ord k) => TypeHasDoc (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (Map k v) :: FieldDescriptions # Methods typeDocName :: Proxy (Map k v) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Map k v) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Map k v) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Map k v) # typeDocMichelsonRep :: TypeDocMichelsonRep (Map k v) #
(KnownHashAlgorithm alg, TypeHasDoc a) => TypeHasDoc (Hash alg a)
Instance details Defined in Lorentz.Bytes Associated Types type TypeDocFieldDescriptions (Hash alg a) :: FieldDescriptions # Methods typeDocName :: Proxy (Hash alg a) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Hash alg a) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Hash alg a) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Hash alg a) # typeDocMichelsonRep :: TypeDocMichelsonRep (Hash alg a) #
Each '[Typeable :: [Type] -> Constraint, ReifyList TypeHasDoc] '[i, o] => TypeHasDoc (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda Associated Types type TypeDocFieldDescriptions (WrappedLambda i o) :: FieldDescriptions # Methods typeDocName :: Proxy (WrappedLambda i o) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (WrappedLambda i o) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (WrappedLambda i o) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (WrappedLambda i o) # typeDocMichelsonRep :: TypeDocMichelsonRep (WrappedLambda i o) #
Each '[Typeable :: Type -> Constraint, TypeHasDoc] '[a, r] => TypeHasDoc (View_ a r)
Instance details Defined in Lorentz.Macro Associated Types type TypeDocFieldDescriptions (View_ a r) :: FieldDescriptions # Methods typeDocName :: Proxy (View_ a r) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (View_ a r) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (View_ a r) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (View_ a r) # typeDocMichelsonRep :: TypeDocMichelsonRep (View_ a r) #
Each '[Typeable :: Type -> Constraint, TypeHasDoc] '[a, r] => TypeHasDoc (Void_ a r)
Instance details Defined in Lorentz.Macro Associated Types type TypeDocFieldDescriptions (Void_ a r) :: FieldDescriptions # Methods typeDocName :: Proxy (Void_ a r) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (Void_ a r) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (Void_ a r) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (Void_ a r) # typeDocMichelsonRep :: TypeDocMichelsonRep (Void_ a r) #
(PolyCTypeHasDocC '[k], PolyTypeHasDocC '[v], Ord k) => TypeHasDoc (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (BigMap k v) :: FieldDescriptions # Methods typeDocName :: Proxy (BigMap k v) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (BigMap k v) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (BigMap k v) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (BigMap k v) # typeDocMichelsonRep :: TypeDocMichelsonRep (BigMap k v) #
PolyTypeHasDocC '[a, b] => TypeHasDoc (a, b)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b) :: FieldDescriptions # Methods typeDocName :: Proxy (a, b) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (a, b) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (a, b) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (a, b) # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b) #
(TypeHasDoc (ApplyNamedFunctor f a), KnownSymbol n, KnownIsoT (ApplyNamedFunctor f Integer), Typeable f, Typeable a) => TypeHasDoc (NamedF f a n)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (NamedF f a n) :: FieldDescriptions # Methods typeDocName :: Proxy (NamedF f a n) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (NamedF f a n) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (NamedF f a n) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (NamedF f a n) # typeDocMichelsonRep :: TypeDocMichelsonRep (NamedF f a n) #
PolyTypeHasDocC '[a, b, c] => TypeHasDoc (a, b, c)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b, c) :: FieldDescriptions # Methods typeDocName :: Proxy (a, b, c) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (a, b, c) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (a, b, c) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (a, b, c) # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c) #
PolyTypeHasDocC '[a, b, c, d] => TypeHasDoc (a, b, c, d)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b, c, d) :: FieldDescriptions # Methods typeDocName :: Proxy (a, b, c, d) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (a, b, c, d) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (a, b, c, d) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d) # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d) #
PolyTypeHasDocC '[a, b, c, d, e] => TypeHasDoc (a, b, c, d, e)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b, c, d, e) :: FieldDescriptions # Methods typeDocName :: Proxy (a, b, c, d, e) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (a, b, c, d, e) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (a, b, c, d, e) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d, e) # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d, e) #
PolyTypeHasDocC '[a, b, c, d, e, f] => TypeHasDoc (a, b, c, d, e, f)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b, c, d, e, f) :: FieldDescriptions # Methods typeDocName :: Proxy (a, b, c, d, e, f) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (a, b, c, d, e, f) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (a, b, c, d, e, f) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d, e, f) # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d, e, f) #
PolyTypeHasDocC '[a, b, c, d, e, f, g] => TypeHasDoc (a, b, c, d, e, f, g)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Associated Types type TypeDocFieldDescriptions (a, b, c, d, e, f, g) :: FieldDescriptions # Methods typeDocName :: Proxy (a, b, c, d, e, f, g) -> Text # typeDocMdDescription :: Markdown # typeDocMdReference :: Proxy (a, b, c, d, e, f, g) -> WithinParens -> Markdown # typeDocDependencies :: Proxy (a, b, c, d, e, f, g) -> [SomeDocDefinitionItem] # typeDocHaskellRep :: TypeDocHaskellRep (a, b, c, d, e, f, g) # typeDocMichelsonRep :: TypeDocMichelsonRep (a, b, c, d, e, f, g) #

type family TypeDocFieldDescriptions a :: FieldDescriptions #

Description of constructors and fields of a.

See FieldDescriptions documentation for an example of usage.

Descriptions will be checked at compile time to make sure that only existing constructors and fields are referenced.

For that check to work instance Generic a is required whenever TypeDocFieldDescriptions is not empty.

For implementation of the check see FieldDescriptionsValid type family.

Instances

Instances details

type TypeDocFieldDescriptions ByteString
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions ByteString = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions Never
Instance details Defined in Lorentz.Value type TypeDocFieldDescriptions Never = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions OpenChest
Instance details Defined in Lorentz.Value type TypeDocFieldDescriptions OpenChest = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions MText
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions MText = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions Operation
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Operation = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions EpAddress
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions EpAddress = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions Address
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Address = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions ChainId
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions ChainId = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions Mutez
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Mutez = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions Timestamp
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Timestamp = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions KeyHash
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions KeyHash = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions PublicKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions PublicKey = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions Signature
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Signature = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions Chest
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Chest = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions ChestKey
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions ChestKey = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions Integer
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Integer = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions Natural
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Natural = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions ()
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions () = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions Bool
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions Bool = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (Set a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Set a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (FutureContract p)
Instance details Defined in Lorentz.Doc type TypeDocFieldDescriptions (FutureContract p) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (ChestT a)
Instance details Defined in Lorentz.Bytes type TypeDocFieldDescriptions (ChestT a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (OpenChestT a)
Instance details Defined in Lorentz.Bytes type TypeDocFieldDescriptions (OpenChestT a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (Packed a)
Instance details Defined in Lorentz.Bytes type TypeDocFieldDescriptions (Packed a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (TSignature a)
Instance details Defined in Lorentz.Bytes type TypeDocFieldDescriptions (TSignature a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (VoidResult r)
Instance details Defined in Lorentz.Macro type TypeDocFieldDescriptions (VoidResult r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (UParam interface)
Instance details Defined in Lorentz.UParam type TypeDocFieldDescriptions (UParam interface) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (ContractRef cp)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (ContractRef cp) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (Ticket a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Ticket a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (Maybe a)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Maybe a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions [a]
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions [a] = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (Either l r)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Either l r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (Map k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (Map k v) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (TAddress p vd)
Instance details Defined in Lorentz.Doc type TypeDocFieldDescriptions (TAddress p vd) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (Hash alg a)
Instance details Defined in Lorentz.Bytes type TypeDocFieldDescriptions (Hash alg a) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (WrappedLambda i o)
Instance details Defined in Lorentz.Lambda type TypeDocFieldDescriptions (WrappedLambda i o) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (View_ a r)
Instance details Defined in Lorentz.Macro type TypeDocFieldDescriptions (View_ a r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (Void_ a r)
Instance details Defined in Lorentz.Macro type TypeDocFieldDescriptions (Void_ a r) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (BigMap k v) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (a, b)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (a, b) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (NamedF f a n)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (NamedF f a n) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (a, b, c)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (a, b, c) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (a, b, c, d)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (a, b, c, d) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (a, b, c, d, e)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (a, b, c, d, e) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (a, b, c, d, e, f)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (a, b, c, d, e, f) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]
type TypeDocFieldDescriptions (a, b, c, d, e, f, g)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (a, b, c, d, e, f, g) = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]

class TypeHasFieldNamingStrategy (a :: k) where #

Field naming strategy used by a type. id by default.

Some common options include: > typeFieldNamingStrategy = stripFieldPrefix > typeFieldNamingStrategy = toSnake . dropPrefix

This is used by the default implementation of typeDocHaskellRep and intended to be reused downstream.

You can also use DerivingVia together with FieldCamelCase and FieldSnakeCase to easily define instances of this class:

data MyType = ... deriving TypeHasFieldNamingStrategy via FieldCamelCase

Minimal complete definition

Nothing

Methods

typeFieldNamingStrategy :: Text -> Text #

Instances

Instances details

TypeHasFieldNamingStrategy (a :: k)
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods typeFieldNamingStrategy :: Text -> Text #
TypeHasFieldNamingStrategy FieldCamelCase
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods typeFieldNamingStrategy :: Text -> Text #
TypeHasFieldNamingStrategy FieldSnakeCase
Instance details Defined in Morley.Michelson.Typed.Haskell.Doc Methods typeFieldNamingStrategy :: Text -> Text #

typeDocBuiltMichelsonRep :: TypeHasDoc a => Proxy a -> Builder #

Fully render Michelson representation of a type.

dTypeDep :: TypeHasDoc t => SomeDocDefinitionItem #

Create a DType in form suitable for putting to typeDocDependencies.

dStorage :: TypeHasDoc store => DStorageType #

Shortcut for DStorageType.

customTypeDocMdReference :: (Text, DType) -> [DType] -> WithinParens -> Markdown #

Render a reference to a type which consists of type constructor (you have to provide name of this type constructor and documentation for the whole type) and zero or more type arguments.

homomorphicTypeDocMdReference :: (Typeable t, TypeHasDoc t, IsHomomorphic t) => Proxy t -> WithinParens -> Markdown #

Derive typeDocMdReference, for homomorphic types only.

poly1TypeDocMdReference :: forall (t :: Type -> Type) r a. (r ~ t a, Typeable t, Each '[TypeHasDoc] '[r, a], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown #

Derive typeDocMdReference, for polymorphic type with one type argument, like Maybe Integer.

poly2TypeDocMdReference :: forall (t :: Type -> Type -> Type) r a b. (r ~ t a b, Typeable t, Each '[TypeHasDoc] '[r, a, b], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown #

Derive typeDocMdReference, for polymorphic type with two type arguments, like Lambda Integer Natural.

genericTypeDocDependencies :: (Generic a, GTypeHasDoc (Rep a)) => Proxy a -> [SomeDocDefinitionItem] #

Implement typeDocDependencies via getting all immediate fields of a datatype.

Note: this will not include phantom types, I'm not sure yet how this scenario should be handled (@martoon).

homomorphicTypeDocHaskellRep :: (Generic a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep a #

Implement typeDocHaskellRep for a homomorphic type.

Note that it does not require your type to be of IsHomomorphic instance, which can be useful for some polymorphic types which, for documentation purposes, we want to consider homomorphic.

Example: Operation is in fact polymorphic, but we don't want this fact to be reflected in the documentation.

concreteTypeDocHaskellRep :: (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a), HaveCommonTypeCtor b a) => TypeDocHaskellRep b #

Implement typeDocHaskellRep on example of given concrete type.

This is a best effort attempt to implement typeDocHaskellRep for polymorphic types, as soon as there is no simple way to preserve type variables when automatically deriving Haskell representation of a type.

unsafeConcreteTypeDocHaskellRep :: (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep b #

Version of concreteTypeDocHaskellRep which does not ensure whether the type for which representation is built is any similar to the original type which you implement a TypeHasDoc instance for.

haskellRepNoFields :: TypeDocHaskellRep a -> TypeDocHaskellRep a #

Erase fields from Haskell datatype representation.

Use this when rendering fields names is undesired.

haskellRepStripFieldPrefix :: TypeDocHaskellRep a -> TypeDocHaskellRep a #

Map over fields with stripFieldPrefix. Equivalent to haskellRepMap stripFieldPrefix. Left for compatibility.

haskellAddNewtypeField :: Text -> TypeDocHaskellRep a -> TypeDocHaskellRep a #

Add field name for newtype.

Since newtype field is automatically erased. Use this function to add the desired field name.

homomorphicTypeDocMichelsonRep :: KnownIsoT a => TypeDocMichelsonRep a #

Implement typeDocMichelsonRep for homomorphic type.

concreteTypeDocMichelsonRep :: forall {k} a (b :: k). (Typeable a, KnownIsoT a, HaveCommonTypeCtor b a) => TypeDocMichelsonRep b #

Implement typeDocMichelsonRep on example of given concrete type.

This function exists for the same reason as concreteTypeDocHaskellRep.

unsafeConcreteTypeDocMichelsonRep :: forall {k} a (b :: k). (Typeable a, KnownIsoT a) => TypeDocMichelsonRep b #

Version of unsafeConcreteTypeDocHaskellRep which does not ensure whether the type for which representation is built is any similar to the original type which you implement a TypeHasDoc instance for.

error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => Text -> a #

error that takes Text as an argument.

asks #

Arguments

:: MonadReader r m
=> (r -> a)	The selector function to apply to the environment.
-> m a

Retrieves a function of the current environment.

newtype ReaderT r (m :: Type -> Type) a #

The reader monad transformer, which adds a read-only environment to the given monad.

The return function ignores the environment, while >>= passes the inherited environment to both subcomputations.

Constructors

ReaderT
Fields runReaderT :: r -> m a

Instances

Instances details

MonadError e m => MonadError e (ReaderT r m)
Instance details Defined in Control.Monad.Error.Class Methods throwError :: e -> ReaderT r m a # catchError :: ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a #
Monad m => MonadReader r (ReaderT r m)
Instance details Defined in Control.Monad.Reader.Class Methods ask :: ReaderT r m r # local :: (r -> r) -> ReaderT r m a -> ReaderT r m a # reader :: (r -> a) -> ReaderT r m a #
MonadState s m => MonadState s (ReaderT r m)
Instance details Defined in Control.Monad.State.Class Methods get :: ReaderT r m s # put :: s -> ReaderT r m () # state :: (s -> (a, s)) -> ReaderT r m a #
MonadTrans (ReaderT r)
Instance details Defined in Control.Monad.Trans.Reader Methods lift :: Monad m => m a -> ReaderT r m a #
Representable m => Representable (ReaderT e m)
Instance details Defined in Data.Functor.Rep Associated Types type Rep (ReaderT e m) # Methods tabulate :: (Rep (ReaderT e m) -> a) -> ReaderT e m a # index :: ReaderT e m a -> Rep (ReaderT e m) -> a #
MonadFail m => MonadFail (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods fail :: String -> ReaderT r m a #
MonadFix m => MonadFix (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mfix :: (a -> ReaderT r m a) -> ReaderT r m a #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a #
MonadZip m => MonadZip (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mzip :: ReaderT r m a -> ReaderT r m b -> ReaderT r m (a, b) # mzipWith :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c # munzip :: ReaderT r m (a, b) -> (ReaderT r m a, ReaderT r m b) #
Contravariant m => Contravariant (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods contramap :: (a' -> a) -> ReaderT r m a -> ReaderT r m a' # (>$) :: b -> ReaderT r m b -> ReaderT r m a #
Alternative m => Alternative (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods empty :: ReaderT r m a # (<\|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a # some :: ReaderT r m a -> ReaderT r m [a] # many :: ReaderT r m a -> ReaderT r m [a] #
Applicative m => Applicative (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods pure :: a -> ReaderT r m a # (<>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b # liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c # (>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # (<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a #
Functor m => Functor (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b # (<$) :: a -> ReaderT r m b -> ReaderT r m a #
Monad m => Monad (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods (>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b # (>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # return :: a -> ReaderT r m a #
MonadPlus m => MonadPlus (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mzero :: ReaderT r m a # mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a #
MonadCatch m => MonadCatch (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods catch :: Exception e => ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a #
MonadMask m => MonadMask (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods mask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b # uninterruptibleMask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b # generalBracket :: ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c) #
MonadThrow m => MonadThrow (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods throwM :: Exception e => e -> ReaderT r m a #
InterpreterStateMonad m => InterpreterStateMonad (ReaderT r m)
Instance details Defined in Morley.Michelson.Interpret Methods getInterpreterState :: ReaderT r m InterpreterState # putInterpreterState :: InterpreterState -> ReaderT r m () # stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> ReaderT r m a # modifyInterpreterState :: (InterpreterState -> InterpreterState) -> ReaderT r m () #
PrimMonad m => PrimMonad (ReaderT r m)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState (ReaderT r m) # Methods primitive :: (State# (PrimState (ReaderT r m)) -> (# State# (PrimState (ReaderT r m)), a #)) -> ReaderT r m a #
Monad m => Magnify (ReaderT b m) (ReaderT a m) b a
Instance details Defined in Control.Lens.Zoom Methods magnify :: ((Functor (Magnified (ReaderT b m) c), Contravariant (Magnified (ReaderT b m) c)) => LensLike' (Magnified (ReaderT b m) c) a b) -> ReaderT b m c -> ReaderT a m c #
Zoom m n s t => Zoom (ReaderT e m) (ReaderT e n) s t
Instance details Defined in Control.Lens.Zoom Methods zoom :: LensLike' (Zoomed (ReaderT e m) c) t s -> ReaderT e m c -> ReaderT e n c #
Monad m => Magnify (ReaderT b m) (ReaderT a m) b a
Instance details Defined in Lens.Micro.Mtl.Internal Methods magnify :: LensLike' (Magnified (ReaderT b m) c) a b -> ReaderT b m c -> ReaderT a m c #
Zoom m n s t => Zoom (ReaderT e m) (ReaderT e n) s t
Instance details Defined in Lens.Micro.Mtl.Internal Methods zoom :: LensLike' (Zoomed (ReaderT e m) c) t s -> ReaderT e m c -> ReaderT e n c #
Wrapped (ReaderT r m a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (ReaderT r m a) # Methods _Wrapped' :: Iso' (ReaderT r m a) (Unwrapped (ReaderT r m a)) #
t ~ ReaderT s n b => Rewrapped (ReaderT r m a) t
Instance details Defined in Control.Lens.Wrapped
type Rep (ReaderT e m)
Instance details Defined in Data.Functor.Rep type Rep (ReaderT e m) = (e, Rep m)
type Magnified (ReaderT b m)
Instance details Defined in Control.Lens.Zoom type Magnified (ReaderT b m) = Effect m
type Zoomed (ReaderT e m)
Instance details Defined in Control.Lens.Zoom type Zoomed (ReaderT e m) = Zoomed m
type Magnified (ReaderT b m)
Instance details Defined in Lens.Micro.Mtl.Internal type Magnified (ReaderT b m) = Effect m
type Zoomed (ReaderT e m)
Instance details Defined in Lens.Micro.Mtl.Internal type Zoomed (ReaderT e m) = Zoomed m
type PrimState (ReaderT r m)
Instance details Defined in Control.Monad.Primitive type PrimState (ReaderT r m) = PrimState m
type Unwrapped (ReaderT r m a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (ReaderT r m a) = r -> m a

type family Each (c :: [k -> Constraint]) (as :: [k]) where ... #

Map several constraints over several variables.

f :: Each [Show, Read] [a, b] => a -> b -> String
=
f :: (Show a, Show b, Read a, Read b) => a -> b -> String

To specify list with single constraint / variable, don't forget to prefix it with ':

f :: Each '[Show] [a, b] => a -> b -> String

Equations

Each (_1 :: [k -> Constraint]) ('[] :: [k]) = ()
Each (c :: [k -> Constraint]) (h ': t :: [k]) = (c <+> h, Each c t)

fromIntegral :: (Integral a, Integral b, CheckIntSubType a b) => a -> b #

Statically safe converter between Integral types, which is just intCast under the hood.

It is used to turn the value of type a into the value of type b such that a is subtype of b. It is needed to prevent silent unsafe conversions.

>>> fromIntegral @Int @Word 1
...
... error:
... Can not safely cast 'Int' to 'Word':
... 'Int' is not a subtype of 'Word'
...
>>> fromIntegral @Word @Natural 1
1

mkBigMap :: ToBigMap m => m -> BigMap (ToBigMapKey m) (ToBigMapValue m) #

annQ :: QuasiQuoter #

>>> :t [annQ||]
... :: forall {k} {tag :: k}. Annotation tag

>>> :t [annQ|abc|]
... :: forall {k} {tag :: k}. Annotation tag

type FieldAnn = Annotation FieldTag #

A convenience synonym for field Annotation

unsafeM :: (MonadFail m, Buildable a) => Either a b -> m b #

Similar to unsafe converter, but with the use of monadic fail and returning the result wrapped in a monad.

unsafe :: (HasCallStack, Buildable a) => Either a b -> b #

Unsafe converter from Either, which uses buildable Left to throw an exception with error.

It is primarily needed for making unsafe counter-parts of safe functions. In particular, for replacing unsafeFName x = either (error . pretty) id constructors and converters, which produce many similar functions at the call site, with unsafe . fName $ x.

show :: forall b a. (PrettyShow a, Show a, IsString b) => a -> b #

A version of show that requires the value to have a human-readable Show instance.

type family PrettyShow a #

An open type family for types having a human-readable Show representation. The kind is Constraint in case we need to further constrain the instance, and also for convenience to avoid explicitly writing ~ 'True everywhere.

Instances

Instances details

type PrettyShow KnownExtension
Instance details Defined in Morley.Prelude.Show type PrettyShow KnownExtension = ()
type PrettyShow Word62
Instance details Defined in Morley.Prelude.Show type PrettyShow Word62 = ()
type PrettyShow Word63
Instance details Defined in Morley.Prelude.Show type PrettyShow Word63 = ()
type PrettyShow TypeRep
Instance details Defined in Morley.Prelude.Show type PrettyShow TypeRep = ()
type PrettyShow Int16
Instance details Defined in Morley.Prelude.Show type PrettyShow Int16 = ()
type PrettyShow Int32
Instance details Defined in Morley.Prelude.Show type PrettyShow Int32 = ()
type PrettyShow Int64
Instance details Defined in Morley.Prelude.Show type PrettyShow Int64 = ()
type PrettyShow Int8
Instance details Defined in Morley.Prelude.Show type PrettyShow Int8 = ()
type PrettyShow Word16
Instance details Defined in Morley.Prelude.Show type PrettyShow Word16 = ()
type PrettyShow Word32
Instance details Defined in Morley.Prelude.Show type PrettyShow Word32 = ()
type PrettyShow Word64
Instance details Defined in Morley.Prelude.Show type PrettyShow Word64 = ()
type PrettyShow ByteString
Instance details Defined in Morley.Prelude.Show type PrettyShow ByteString = TypeError ('Text "Show instance for ByteString is not pretty") :: Constraint
type PrettyShow Doc
Instance details Defined in Morley.Prelude.Show type PrettyShow Doc = ()
type PrettyShow Name
Instance details Defined in Morley.Prelude.Show type PrettyShow Name = ()
type PrettyShow UnicodeException
Instance details Defined in Morley.Prelude.Show type PrettyShow UnicodeException = ()
type PrettyShow Text
Instance details Defined in Morley.Prelude.Show type PrettyShow Text = TypeError ('Text "Show instance for Text is not pretty" :$$: 'Text "Consider relying on the Buildable instance") :: Constraint
type PrettyShow NominalDiffTime
Instance details Defined in Morley.Prelude.Show type PrettyShow NominalDiffTime = ()
type PrettyShow LByteString
Instance details Defined in Morley.Prelude.Show type PrettyShow LByteString = TypeError ('Text "Show instance for lazy ByteString is not pretty") :: Constraint
type PrettyShow LText
Instance details Defined in Morley.Prelude.Show type PrettyShow LText = TypeError ('Text "Show instance for lazy Text is not pretty" :$$: 'Text "Consider relying on the Buildable instance") :: Constraint
type PrettyShow Word8
Instance details Defined in Morley.Prelude.Show type PrettyShow Word8 = ()
type PrettyShow Integer
Instance details Defined in Morley.Prelude.Show type PrettyShow Integer = ()
type PrettyShow Natural
Instance details Defined in Morley.Prelude.Show type PrettyShow Natural = ()
type PrettyShow Char
Instance details Defined in Morley.Prelude.Show type PrettyShow Char = TypeError ('Text "Show instance for String and Char is not pretty" :$$: 'Text "Consider relying on the Buildable instance") :: Constraint
type PrettyShow Double
Instance details Defined in Morley.Prelude.Show type PrettyShow Double = ()
type PrettyShow Float
Instance details Defined in Morley.Prelude.Show type PrettyShow Float = ()
type PrettyShow Int
Instance details Defined in Morley.Prelude.Show type PrettyShow Int = ()
type PrettyShow Word
Instance details Defined in Morley.Prelude.Show type PrettyShow Word = ()
type PrettyShow [a]
Instance details Defined in Morley.Prelude.Show type PrettyShow [a] = PrettyShow a
type PrettyShow (Fixed _1)
Instance details Defined in Morley.Prelude.Show type PrettyShow (Fixed _1) = ()

fromIntegralNoOverflow :: (Integral a, Integral b) => a -> Either ArithException b #

Statically safe converter between Integral types checking for overflow/underflow. Returns Right value if conversion does not produce overflow/underflow and Left ArithException with corresponding ArithException (Overflow/Underflow) otherwise.

Note the function is strict in its argument.

>>> fromIntegralNoOverflow @Int @Word 123
Right 123
>>> fromIntegralNoOverflow @Int @Word (-123)
Left arithmetic underflow
>>> fromIntegralNoOverflow @Int @Integer (-123)
Right (-123)
>>> fromIntegralNoOverflow @Int @Natural (-123)
Left arithmetic underflow
>>> fromIntegralNoOverflow @Int @Int8 127
Right 127
>>> fromIntegralNoOverflow @Int @Int8 128
Left arithmetic overflow

fromIntegralOverflowing :: (Integral a, Num b) => a -> b #

Runtime-safe converter between Integral types, which is just fromIntegral under the hood.

It is needed to semantically distinguish usages, where overflow is intended, from those that have to fail on overflow. E.g. Int8 -> Word8 with intended bits reinterpretation from lossy Integer -> Int.

>>> fromIntegralOverflowing @Int8 @Word8 (-1)
255
>>> fromIntegralOverflowing @Natural @Int8 450
-62

Please note that like fromIntegral from base, this will throw on some conversions!

>>> fromIntegralOverflowing @Int @Natural (-1)
*** Exception: arithmetic underflow

See fromIntegralNoOverflow for an alternative that doesn't throw.

fromIntegralToRealFrac :: (Integral a, RealFrac b, CheckIntSubType a Integer) => a -> b #

Statically safe converter between Integral and RealFrac types. Could be applied to cast common types like Float, Double and Scientific.

It is primarily needed to replace usages of fromIntegral, which are safe actually as integral numbers are being casted to fractional ones.

fromIntegralMaybe :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b #

Statically safe converter between Integral types, which is just intCastMaybe under the hood. Unlike fromIntegral accept any a and b. Return Just value if conversion is possible at runtime and Nothing otherwise.

type CheckIntSubType a b = (CheckIntSubTypeErrors a b (IsIntSubType a b), IsIntSubType a b ~ 'True) #

Constraint synonym equivalent to IsIntSubType a b ~ 'True, but with better error messages

all1 :: Boolean b => (a -> b) -> NonEmpty a -> b #

A version of all that works on NonEmpty, thus doesn't require BooleanMonoid instance.

>>> all1 (\x -> if x > 50 then Yay else Nay) $ 100 :| replicate 10 51
Yay

any1 :: Boolean b => (a -> b) -> NonEmpty a -> b #

A version of any that works on NonEmpty, thus doesn't require BooleanMonoid instance.

>>> any1 (\x -> if x > 50 then Yay else Nay) $ 50 :| replicate 10 0
Nay

all :: (Container c, BooleanMonoid b) => (Element c -> b) -> c -> b #

Generalized all.

>>> all (\x -> if x > 50 then Yay else Nay) [1..100]
Nay

any :: (Container c, BooleanMonoid b) => (Element c -> b) -> c -> b #

Generalized any.

>>> any (\x -> if x > 50 then Yay else Nay) [1..100]
Yay

and1 :: Boolean a => NonEmpty a -> a #

A version of and that works on NonEmpty, thus doesn't require BooleanMonoid instance.

>>> and1 $ Yay :| [Nay]
Nay

or1 :: Boolean a => NonEmpty a -> a #

A version of or that works on NonEmpty, thus doesn't require BooleanMonoid instance.

>>> or1 $ Yay :| [Nay]
Yay

class Boolean a #

Generalized boolean operators.

This is useful for defining things that behave like booleans, e.g. predicates, or EDSL for predicates.

>>> Yay && Nay
Nay
>>> and1 $ Yay :| replicate 9 Yay
Yay

There are also instances for these types lifted into IO and (->) a:

>>> (const Yay) && (const Nay) $ ()
Nay
>>> (const Yay) || (const Nay) $ ()
Yay

Minimal complete definition

(&&), (||), not

Instances

Instances details

Boolean Bool
Instance details Defined in Morley.Prelude.Boolean Methods (&&) :: Bool -> Bool -> Bool # (\|\|) :: Bool -> Bool -> Bool # not :: Bool -> Bool #
Boolean bool => Boolean (IO bool)
Instance details Defined in Morley.Prelude.Boolean Methods (&&) :: IO bool -> IO bool -> IO bool # (\|\|) :: IO bool -> IO bool -> IO bool # not :: IO bool -> IO bool #
Boolean bool => Boolean (a -> bool)
Instance details Defined in Morley.Prelude.Boolean Methods (&&) :: (a -> bool) -> (a -> bool) -> a -> bool # (\|\|) :: (a -> bool) -> (a -> bool) -> a -> bool # not :: (a -> bool) -> a -> bool #
(Applicative f, Boolean bool) => Boolean (ApplicativeBoolean f bool)
Instance details Defined in Morley.Prelude.Boolean Methods (&&) :: ApplicativeBoolean f bool -> ApplicativeBoolean f bool -> ApplicativeBoolean f bool # (\|\|) :: ApplicativeBoolean f bool -> ApplicativeBoolean f bool -> ApplicativeBoolean f bool # not :: ApplicativeBoolean f bool -> ApplicativeBoolean f bool #

class Boolean a => BooleanMonoid a where #

Generalized True and False.

This is useful to complete the isomorphism between regular and generalized booleans. It's a separate class because not all boolean-like things form a monoid.

>>> or $ replicate 10 Nay
Nay

Minimal complete definition

true | false

Methods

false :: a #

true :: a #

Instances

Instances details

BooleanMonoid Bool
Instance details Defined in Morley.Prelude.Boolean Methods false :: Bool # true :: Bool #
BooleanMonoid bool => BooleanMonoid (IO bool)
Instance details Defined in Morley.Prelude.Boolean Methods false :: IO bool # true :: IO bool #
BooleanMonoid bool => BooleanMonoid (a -> bool)
Instance details Defined in Morley.Prelude.Boolean Methods false :: a -> bool # true :: a -> bool #
(Applicative f, BooleanMonoid bool) => BooleanMonoid (ApplicativeBoolean f bool)
Instance details Defined in Morley.Prelude.Boolean Methods false :: ApplicativeBoolean f bool # true :: ApplicativeBoolean f bool #

newtype All a #

A generalized version of All monoid wrapper.

>>> All Nay <> All Nay
All {getAll = Nay}
>>> All Yay <> All Nay
All {getAll = Nay}
>>> All Yay <> All Yay
All {getAll = Yay}

Constructors

All
Fields getAll :: a

Instances

Instances details

Data a => Data (All a)
Instance details Defined in Morley.Prelude.Boolean Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All a -> c (All a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (All a) # toConstr :: All a -> Constr # dataTypeOf :: All a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (All a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (All a)) # gmapT :: (forall b. Data b => b -> b) -> All a -> All a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r # gmapQ :: (forall d. Data d => d -> u) -> All a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> All a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> All a -> m (All a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All a -> m (All a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All a -> m (All a) #
BooleanMonoid a => Monoid (All a)
Instance details Defined in Morley.Prelude.Boolean Methods mempty :: All a # mappend :: All a -> All a -> All a # mconcat :: [All a] -> All a #
Boolean a => Semigroup (All a)
Instance details Defined in Morley.Prelude.Boolean Methods (<>) :: All a -> All a -> All a # sconcat :: NonEmpty (All a) -> All a # stimes :: Integral b => b -> All a -> All a #
Bounded a => Bounded (All a)
Instance details Defined in Morley.Prelude.Boolean Methods minBound :: All a # maxBound :: All a #
Enum a => Enum (All a)
Instance details Defined in Morley.Prelude.Boolean Methods succ :: All a -> All a # pred :: All a -> All a # toEnum :: Int -> All a # fromEnum :: All a -> Int # enumFrom :: All a -> [All a] # enumFromThen :: All a -> All a -> [All a] # enumFromTo :: All a -> All a -> [All a] # enumFromThenTo :: All a -> All a -> All a -> [All a] #
Generic (All a)
Instance details Defined in Morley.Prelude.Boolean Associated Types type Rep (All a) :: Type -> Type # Methods from :: All a -> Rep (All a) x # to :: Rep (All a) x -> All a #
Read a => Read (All a)
Instance details Defined in Morley.Prelude.Boolean Methods readsPrec :: Int -> ReadS (All a) # readList :: ReadS [All a] # readPrec :: ReadPrec (All a) # readListPrec :: ReadPrec [All a] #
Show a => Show (All a)
Instance details Defined in Morley.Prelude.Boolean Methods showsPrec :: Int -> All a -> ShowS # show :: All a -> String # showList :: [All a] -> ShowS #
Eq a => Eq (All a)
Instance details Defined in Morley.Prelude.Boolean Methods (==) :: All a -> All a -> Bool # (/=) :: All a -> All a -> Bool #
Ord a => Ord (All a)
Instance details Defined in Morley.Prelude.Boolean Methods compare :: All a -> All a -> Ordering # (<) :: All a -> All a -> Bool # (<=) :: All a -> All a -> Bool # (>) :: All a -> All a -> Bool # (>=) :: All a -> All a -> Bool # max :: All a -> All a -> All a # min :: All a -> All a -> All a #
type Rep (All a)
Instance details Defined in Morley.Prelude.Boolean type Rep (All a) = D1 ('MetaData "All" "Morley.Prelude.Boolean" "morley-prelude-0.5.2-d4b06502381bad5ccf277f59b4f4a7bbf3166347e11bb237c07f536ebab1daf2" 'True) (C1 ('MetaCons "All" 'PrefixI 'True) (S1 ('MetaSel ('Just "getAll") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

newtype Any a #

A generalized version of Any monoid wrapper.

>>> Any Nay <> Any Nay
Any {getAny = Nay}
>>> Any Yay <> Any Nay
Any {getAny = Yay}
>>> Any Yay <> Any Yay
Any {getAny = Yay}

Constructors

Any
Fields getAny :: a

Instances

Instances details

Data a => Data (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any a -> c (Any a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Any a) # toConstr :: Any a -> Constr # dataTypeOf :: Any a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Any a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Any a)) # gmapT :: (forall b. Data b => b -> b) -> Any a -> Any a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r # gmapQ :: (forall d. Data d => d -> u) -> Any a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Any a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any a -> m (Any a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any a -> m (Any a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any a -> m (Any a) #
BooleanMonoid a => Monoid (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods mempty :: Any a # mappend :: Any a -> Any a -> Any a # mconcat :: [Any a] -> Any a #
Boolean a => Semigroup (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods (<>) :: Any a -> Any a -> Any a # sconcat :: NonEmpty (Any a) -> Any a # stimes :: Integral b => b -> Any a -> Any a #
Bounded a => Bounded (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods minBound :: Any a # maxBound :: Any a #
Enum a => Enum (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods succ :: Any a -> Any a # pred :: Any a -> Any a # toEnum :: Int -> Any a # fromEnum :: Any a -> Int # enumFrom :: Any a -> [Any a] # enumFromThen :: Any a -> Any a -> [Any a] # enumFromTo :: Any a -> Any a -> [Any a] # enumFromThenTo :: Any a -> Any a -> Any a -> [Any a] #
Generic (Any a)
Instance details Defined in Morley.Prelude.Boolean Associated Types type Rep (Any a) :: Type -> Type # Methods from :: Any a -> Rep (Any a) x # to :: Rep (Any a) x -> Any a #
Read a => Read (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods readsPrec :: Int -> ReadS (Any a) # readList :: ReadS [Any a] # readPrec :: ReadPrec (Any a) # readListPrec :: ReadPrec [Any a] #
Show a => Show (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods showsPrec :: Int -> Any a -> ShowS # show :: Any a -> String # showList :: [Any a] -> ShowS #
Eq a => Eq (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods (==) :: Any a -> Any a -> Bool # (/=) :: Any a -> Any a -> Bool #
Ord a => Ord (Any a)
Instance details Defined in Morley.Prelude.Boolean Methods compare :: Any a -> Any a -> Ordering # (<) :: Any a -> Any a -> Bool # (<=) :: Any a -> Any a -> Bool # (>) :: Any a -> Any a -> Bool # (>=) :: Any a -> Any a -> Bool # max :: Any a -> Any a -> Any a # min :: Any a -> Any a -> Any a #
type Rep (Any a)
Instance details Defined in Morley.Prelude.Boolean type Rep (Any a) = D1 ('MetaData "Any" "Morley.Prelude.Boolean" "morley-prelude-0.5.2-d4b06502381bad5ccf277f59b4f4a7bbf3166347e11bb237c07f536ebab1daf2" 'True) (C1 ('MetaCons "Any" 'PrefixI 'True) (S1 ('MetaSel ('Just "getAny") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

newtype ApplicativeBoolean (f :: k -> Type) (bool :: k) #

A newtype for deriving a Boolean instance for any Applicative type constructor using DerivingVia.

Constructors

ApplicativeBoolean (f bool)

Instances

Instances details

Applicative f => Applicative (ApplicativeBoolean f)
Instance details Defined in Morley.Prelude.Boolean Methods pure :: a -> ApplicativeBoolean f a # (<>) :: ApplicativeBoolean f (a -> b) -> ApplicativeBoolean f a -> ApplicativeBoolean f b # liftA2 :: (a -> b -> c) -> ApplicativeBoolean f a -> ApplicativeBoolean f b -> ApplicativeBoolean f c # (>) :: ApplicativeBoolean f a -> ApplicativeBoolean f b -> ApplicativeBoolean f b # (<*) :: ApplicativeBoolean f a -> ApplicativeBoolean f b -> ApplicativeBoolean f a #
Functor f => Functor (ApplicativeBoolean f)
Instance details Defined in Morley.Prelude.Boolean Methods fmap :: (a -> b) -> ApplicativeBoolean f a -> ApplicativeBoolean f b # (<$) :: a -> ApplicativeBoolean f b -> ApplicativeBoolean f a #
(Applicative f, Boolean bool) => Boolean (ApplicativeBoolean f bool)
Instance details Defined in Morley.Prelude.Boolean Methods (&&) :: ApplicativeBoolean f bool -> ApplicativeBoolean f bool -> ApplicativeBoolean f bool # (\|\|) :: ApplicativeBoolean f bool -> ApplicativeBoolean f bool -> ApplicativeBoolean f bool # not :: ApplicativeBoolean f bool -> ApplicativeBoolean f bool #
(Applicative f, BooleanMonoid bool) => BooleanMonoid (ApplicativeBoolean f bool)
Instance details Defined in Morley.Prelude.Boolean Methods false :: ApplicativeBoolean f bool # true :: ApplicativeBoolean f bool #

pass :: Applicative f => f () #

Shorter alias for pure ().

>>> pass :: Maybe ()
Just ()

someNE :: Alternative f => f a -> f (NonEmpty a) #

Similar to some, but reflects in types that a non-empty list is returned.

($!) :: (a -> b) -> a -> b infixr 0 #

Stricter version of $ operator. Default Prelude defines this at the toplevel module, so we do as well.

>>> const 3 $ Prelude.undefined
3
>>> const 3 $! Prelude.undefined
*** Exception: Prelude.undefined
...

map :: Functor f => (a -> b) -> f a -> f b #

map generalized to Functor.

>>> map not (Just True)
Just False
>>> map not [True,False,True,True]
[False,True,False,False]

(<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b) infixl 4 #

Alias for fmap . fmap. Convenient to work with two nested Functors.

>>> negate <<$>> Just [1,2,3]
Just [-1,-2,-3]

newEmptyMVar :: MonadIO m => m (MVar a) #

Lifted to MonadIO version of newEmptyMVar.

newMVar :: MonadIO m => a -> m (MVar a) #

Lifted to MonadIO version of newMVar.

putMVar :: MonadIO m => MVar a -> a -> m () #

Lifted to MonadIO version of putMVar.

readMVar :: MonadIO m => MVar a -> m a #

Lifted to MonadIO version of readMVar.

swapMVar :: MonadIO m => MVar a -> a -> m a #

Lifted to MonadIO version of swapMVar.

takeMVar :: MonadIO m => MVar a -> m a #

Lifted to MonadIO version of takeMVar.

tryPutMVar :: MonadIO m => MVar a -> a -> m Bool #

Lifted to MonadIO version of tryPutMVar.

tryReadMVar :: MonadIO m => MVar a -> m (Maybe a) #

Lifted to MonadIO version of tryReadMVar.

tryTakeMVar :: MonadIO m => MVar a -> m (Maybe a) #

Lifted to MonadIO version of tryTakeMVar.

atomically :: MonadIO m => STM a -> m a #

Lifted to MonadIO version of atomically.

newTVarIO :: MonadIO m => a -> m (TVar a) #

Lifted to MonadIO version of newTVarIO.

readTVarIO :: MonadIO m => TVar a -> m a #

Lifted to MonadIO version of readTVarIO.

updateMVar' :: MonadIO m => MVar s -> StateT s IO a -> m a #

Like modifyMVar, but modification is specified as a State computation.

This method is strict in produced s value.

updateTVar' :: TVar s -> StateT s STM a -> STM a #

Like 'modifyTVar'', but modification is specified as a State monad.

exitWith :: MonadIO m => ExitCode -> m a #

Lifted version of exitWith.

exitFailure :: MonadIO m => m a #

Lifted version of exitFailure.

exitSuccess :: MonadIO m => m a #

Lifted version of exitSuccess.

die :: MonadIO m => String -> m a #

Lifted version of die. die is available since base-4.8, but it's more convenient to redefine it instead of using CPP.

appendFile :: MonadIO m => FilePath -> Text -> m () #

Lifted version of appendFile.

getLine :: MonadIO m => m Text #

Lifted version of getLine.

openFile :: MonadIO m => FilePath -> IOMode -> m Handle #

Lifted version of openFile.

See also withFile for more information.

hClose :: MonadIO m => Handle -> m () #

Close a file handle

See also withFile for more information.

withFile :: (MonadIO m, MonadMask m) => FilePath -> IOMode -> (Handle -> m a) -> m a #

Opens a file, manipulates it with the provided function and closes the handle before returning. The Handle can be written to using the hPutStr and hPutStrLn functions.

withFile is essentially the bracket pattern, specialized to files. This should be preferred over openFile + hClose as it properly deals with (asynchronous) exceptions. In cases where withFile is insufficient, for instance because the it is not statically known when manipulating the Handle has finished, one should consider other safe paradigms for resource usage, such as the ResourceT transformer from the resourcet package, before resorting to openFile and hClose.

newIORef :: MonadIO m => a -> m (IORef a) #

Lifted version of newIORef.

readIORef :: MonadIO m => IORef a -> m a #

Lifted version of readIORef.

writeIORef :: MonadIO m => IORef a -> a -> m () #

Lifted version of writeIORef.

modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m () #

Lifted version of modifyIORef.

modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m () #

Lifted version of modifyIORef'.

atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b #

Lifted version of atomicModifyIORef.

atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b #

Lifted version of atomicModifyIORef'.

atomicWriteIORef :: MonadIO m => IORef a -> a -> m () #

Lifted version of atomicWriteIORef.

whenJust :: Applicative f => Maybe a -> (a -> f ()) -> f () #

Specialized version of for_ for Maybe. It's used for code readability. Also helps to avoid space leaks: Foldable.mapM_ space leak.

>>> whenJust Nothing $ \b -> print (not b)
>>> whenJust (Just True) $ \b -> print (not b)
False

whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m () #

Monadic version of whenJust.

whenNothing :: Applicative f => Maybe a -> f a -> f a #

Performs default Applicative action if Nothing is given. Otherwise returns content of Just pured to Applicative.

>>> whenNothing Nothing [True, False]
[True,False]
>>> whenNothing (Just True) [True, False]
[True]

whenNothing_ :: Applicative f => Maybe a -> f () -> f () #

Performs default Applicative action if Nothing is given. Do nothing for Just. Convenient for discarding Just content.

>>> whenNothing_ Nothing $ putTextLn "Nothing!"
Nothing!
>>> whenNothing_ (Just True) $ putTextLn "Nothing!"

whenNothingM :: Monad m => m (Maybe a) -> m a -> m a #

Monadic version of whenNothing.

whenNothingM_ :: Monad m => m (Maybe a) -> m () -> m () #

Monadic version of whenNothingM_.

fromLeft :: a -> Either a b -> a #

Extracts value from Left or return given default value.

>>> fromLeft 0 (Left 3)
3
>>> fromLeft 0 (Right 5)
0

fromRight :: b -> Either a b -> b #

Extracts value from Right or return given default value.

>>> fromRight 0 (Left 3)
0
>>> fromRight 0 (Right 5)
5

leftToMaybe :: Either l r -> Maybe l #

Maps left part of Either to Maybe.

>>> leftToMaybe (Left True)
Just True
>>> leftToMaybe (Right "aba")
Nothing

rightToMaybe :: Either l r -> Maybe r #

Maps right part of Either to Maybe.

>>> rightToMaybe (Left True)
Nothing
>>> rightToMaybe (Right "aba")
Just "aba"

maybeToRight :: l -> Maybe r -> Either l r #

Maps Maybe to Either wrapping default value into Left.

>>> maybeToRight True (Just "aba")
Right "aba"
>>> maybeToRight True Nothing
Left True

maybeToLeft :: r -> Maybe l -> Either l r #

Maps Maybe to Either wrapping default value into Right.

>>> maybeToLeft True (Just "aba")
Left "aba"
>>> maybeToLeft True Nothing
Right True

whenLeftM :: Monad m => m (Either l r) -> (l -> m ()) -> m () #

Monadic version of whenLeft.

whenRightM :: Monad m => m (Either l r) -> (r -> m ()) -> m () #

Monadic version of whenRight.

usingReaderT :: r -> ReaderT r m a -> m a #

Shorter and more readable alias for flip runReaderT.

usingReader :: r -> Reader r a -> a #

Shorter and more readable alias for flip runReader.

usingStateT :: s -> StateT s m a -> m (a, s) #

Shorter and more readable alias for flip runStateT.

usingState :: s -> State s a -> (a, s) #

Shorter and more readable alias for flip runState.

evaluatingStateT :: Functor f => s -> StateT s f a -> f a #

Alias for flip evalStateT. It's not shorter but sometimes more readable. Done by analogy with using* functions family.

evaluatingState :: s -> State s a -> a #

Alias for flip evalState. It's not shorter but sometimes more readable. Done by analogy with using* functions family.

executingStateT :: Functor f => s -> StateT s f a -> f s #

Alias for flip execStateT. It's not shorter but sometimes more readable. Done by analogy with using* functions family.

executingState :: s -> State s a -> s #

Alias for flip execState. It's not shorter but sometimes more readable. Done by analogy with using* functions family.

hoistMaybe :: forall (m :: Type -> Type) a. Applicative m => Maybe a -> MaybeT m a #

Lift a Maybe to the MaybeT monad

hoistEither :: forall (m :: Type -> Type) e a. Applicative m => Either e a -> ExceptT e m a #

Lift a Either to the ExceptT monad

maybeToMonoid :: Monoid m => Maybe m -> m #

Extracts Monoid value from Maybe returning mempty if Nothing.

>>> maybeToMonoid (Just [1,2,3] :: Maybe [Int])
[1,2,3]
>>> maybeToMonoid (Nothing :: Maybe [Int])
[]

class One x where #

Type class for types that can be created from one element. singleton is lone name for this function. Also constructions of different type differ: :[] for lists, two arguments for Maps. Also some data types are monomorphic.

>>> one True :: [Bool]
[True]
>>> one 'a' :: Text
"a"
>>> one (3, "hello") :: HashMap Int String
fromList [(3,"hello")]

Associated Types

type OneItem x #

Methods

one :: OneItem x -> x #

Create a list, map, Text, etc from a single element.

Instances

Instances details

One ByteString
Instance details Defined in Universum.Container.Class Associated Types type OneItem ByteString # Methods one :: OneItem ByteString -> ByteString #
One ByteString
Instance details Defined in Universum.Container.Class Associated Types type OneItem ByteString # Methods one :: OneItem ByteString -> ByteString #
One IntSet
Instance details Defined in Universum.Container.Class Associated Types type OneItem IntSet # Methods one :: OneItem IntSet -> IntSet #
One MorleyLogsBuilder
Instance details Defined in Morley.Michelson.Interpret Associated Types type OneItem MorleyLogsBuilder # Methods one :: OneItem MorleyLogsBuilder -> MorleyLogsBuilder #
One Text
Instance details Defined in Universum.Container.Class Associated Types type OneItem Text # Methods one :: OneItem Text -> Text #
One Text
Instance details Defined in Universum.Container.Class Associated Types type OneItem Text # Methods one :: OneItem Text -> Text #
One (NonEmpty a)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (NonEmpty a) # Methods one :: OneItem (NonEmpty a) -> NonEmpty a #
One (IntMap v)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (IntMap v) # Methods one :: OneItem (IntMap v) -> IntMap v #
One (Seq a)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Seq a) # Methods one :: OneItem (Seq a) -> Seq a #
One (Set v)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Set v) # Methods one :: OneItem (Set v) -> Set v #
Hashable v => One (HashSet v)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (HashSet v) # Methods one :: OneItem (HashSet v) -> HashSet v #
One (Vector a)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Vector a) # Methods one :: OneItem (Vector a) -> Vector a #
Prim a => One (Vector a)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Vector a) # Methods one :: OneItem (Vector a) -> Vector a #
Storable a => One (Vector a)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Vector a) # Methods one :: OneItem (Vector a) -> Vector a #
Unbox a => One (Vector a)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Vector a) # Methods one :: OneItem (Vector a) -> Vector a #
One [a]
Instance details Defined in Universum.Container.Class Associated Types type OneItem [a] # Methods one :: OneItem [a] -> [a] #
One (Map k v)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (Map k v) # Methods one :: OneItem (Map k v) -> Map k v #
One (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type OneItem (BigMap k v) # Methods one :: OneItem (BigMap k v) -> BigMap k v #
n ~ 'S 'Z => One (SizedList' n a)
Instance details Defined in Morley.Util.SizedList Associated Types type OneItem (SizedList' n a) # Methods one :: OneItem (SizedList' n a) -> SizedList' n a #
Hashable k => One (HashMap k v)
Instance details Defined in Universum.Container.Class Associated Types type OneItem (HashMap k v) # Methods one :: OneItem (HashMap k v) -> HashMap k v #

type family OneItem x #

Instances

Instances details

type OneItem ByteString
Instance details Defined in Universum.Container.Class type OneItem ByteString = Word8
type OneItem ByteString
Instance details Defined in Universum.Container.Class type OneItem ByteString = Word8
type OneItem IntSet
Instance details Defined in Universum.Container.Class type OneItem IntSet = Int
type OneItem MorleyLogsBuilder
Instance details Defined in Morley.Michelson.Interpret type OneItem MorleyLogsBuilder = Text
type OneItem Text
Instance details Defined in Universum.Container.Class type OneItem Text = Char
type OneItem Text
Instance details Defined in Universum.Container.Class type OneItem Text = Char
type OneItem (NonEmpty a)
Instance details Defined in Universum.Container.Class type OneItem (NonEmpty a) = a
type OneItem (IntMap v)
Instance details Defined in Universum.Container.Class type OneItem (IntMap v) = (Int, v)
type OneItem (Seq a)
Instance details Defined in Universum.Container.Class type OneItem (Seq a) = a
type OneItem (Set v)
Instance details Defined in Universum.Container.Class type OneItem (Set v) = v
type OneItem (HashSet v)
Instance details Defined in Universum.Container.Class type OneItem (HashSet v) = v
type OneItem (Vector a)
Instance details Defined in Universum.Container.Class type OneItem (Vector a) = a
type OneItem (Vector a)
Instance details Defined in Universum.Container.Class type OneItem (Vector a) = a
type OneItem (Vector a)
Instance details Defined in Universum.Container.Class type OneItem (Vector a) = a
type OneItem (Vector a)
Instance details Defined in Universum.Container.Class type OneItem (Vector a) = a
type OneItem [a]
Instance details Defined in Universum.Container.Class type OneItem [a] = a
type OneItem (Map k v)
Instance details Defined in Universum.Container.Class type OneItem (Map k v) = (k, v)
type OneItem (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type OneItem (BigMap k v) = OneItem (Map k v)
type OneItem (SizedList' n a)
Instance details Defined in Morley.Util.SizedList type OneItem (SizedList' n a) = a
type OneItem (HashMap k v)
Instance details Defined in Universum.Container.Class type OneItem (HashMap k v) = (k, v)

class Container t where #

Very similar to Foldable but also allows instances for monomorphic types like Text but forbids instances for Maybe and similar. This class is used as a replacement for Foldable type class. It solves the following problems:

length, foldr and other functions work on more types for which it makes sense.
You can't accidentally use length on polymorphic Foldable (like list), replace list with Maybe and then debug error for two days.
More efficient implementaions of functions for polymorphic types (like elem for Set).

The drawbacks:

Type signatures of polymorphic functions look more scary.
Orphan instances are involved if you want to use foldr (and similar) on types from libraries.

Minimal complete definition

Nothing

Associated Types

type Element t #

Type of element for some container. Implemented as an asscociated type family because some containers are monomorphic over element type (like Text, IntSet, etc.) so we can't implement nice interface using old higher-kinded types approach. Implementing this as an associated type family instead of top-level family gives you more control over element types.

type Element t = ElementDefault t

Methods

toList :: t -> [Element t] #

Convert container to list of elements.

>>> toList @Text "aba"
"aba"
>>> :t toList @Text "aba"
toList @Text "aba" :: [Char]

null :: t -> Bool #

Checks whether container is empty.

>>> null @Text ""
True
>>> null @Text "aba"
False

foldr :: (Element t -> b -> b) -> b -> t -> b #

foldl :: (b -> Element t -> b) -> b -> t -> b #

foldl' :: (b -> Element t -> b) -> b -> t -> b #

length :: t -> Int #

elem :: Element t -> t -> Bool #

foldMap :: Monoid m => (Element t -> m) -> t -> m #

fold :: t -> Element t #

foldr' :: (Element t -> b -> b) -> b -> t -> b #

notElem :: Element t -> t -> Bool #

find :: (Element t -> Bool) -> t -> Maybe (Element t) #

safeHead :: t -> Maybe (Element t) #

safeMaximum :: t -> Maybe (Element t) #

safeMinimum :: t -> Maybe (Element t) #

safeFoldr1 :: (Element t -> Element t -> Element t) -> t -> Maybe (Element t) #

safeFoldl1 :: (Element t -> Element t -> Element t) -> t -> Maybe (Element t) #

Instances

Instances details

Container ByteString
Instance details Defined in Universum.Container.Class Associated Types type Element ByteString # Methods toList :: ByteString -> [Element ByteString] # null :: ByteString -> Bool # foldr :: (Element ByteString -> b -> b) -> b -> ByteString -> b # foldl :: (b -> Element ByteString -> b) -> b -> ByteString -> b # foldl' :: (b -> Element ByteString -> b) -> b -> ByteString -> b # length :: ByteString -> Int # elem :: Element ByteString -> ByteString -> Bool # foldMap :: Monoid m => (Element ByteString -> m) -> ByteString -> m # fold :: ByteString -> Element ByteString # foldr' :: (Element ByteString -> b -> b) -> b -> ByteString -> b # notElem :: Element ByteString -> ByteString -> Bool # all :: (Element ByteString -> Bool) -> ByteString -> Bool # any :: (Element ByteString -> Bool) -> ByteString -> Bool # and :: ByteString -> Bool # or :: ByteString -> Bool # find :: (Element ByteString -> Bool) -> ByteString -> Maybe (Element ByteString) # safeHead :: ByteString -> Maybe (Element ByteString) # safeMaximum :: ByteString -> Maybe (Element ByteString) # safeMinimum :: ByteString -> Maybe (Element ByteString) # safeFoldr1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Maybe (Element ByteString) # safeFoldl1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Maybe (Element ByteString) #
Container ByteString
Instance details Defined in Universum.Container.Class Associated Types type Element ByteString # Methods toList :: ByteString -> [Element ByteString] # null :: ByteString -> Bool # foldr :: (Element ByteString -> b -> b) -> b -> ByteString -> b # foldl :: (b -> Element ByteString -> b) -> b -> ByteString -> b # foldl' :: (b -> Element ByteString -> b) -> b -> ByteString -> b # length :: ByteString -> Int # elem :: Element ByteString -> ByteString -> Bool # foldMap :: Monoid m => (Element ByteString -> m) -> ByteString -> m # fold :: ByteString -> Element ByteString # foldr' :: (Element ByteString -> b -> b) -> b -> ByteString -> b # notElem :: Element ByteString -> ByteString -> Bool # all :: (Element ByteString -> Bool) -> ByteString -> Bool # any :: (Element ByteString -> Bool) -> ByteString -> Bool # and :: ByteString -> Bool # or :: ByteString -> Bool # find :: (Element ByteString -> Bool) -> ByteString -> Maybe (Element ByteString) # safeHead :: ByteString -> Maybe (Element ByteString) # safeMaximum :: ByteString -> Maybe (Element ByteString) # safeMinimum :: ByteString -> Maybe (Element ByteString) # safeFoldr1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Maybe (Element ByteString) # safeFoldl1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Maybe (Element ByteString) #
Container IntSet
Instance details Defined in Universum.Container.Class Associated Types type Element IntSet # Methods toList :: IntSet -> [Element IntSet] # null :: IntSet -> Bool # foldr :: (Element IntSet -> b -> b) -> b -> IntSet -> b # foldl :: (b -> Element IntSet -> b) -> b -> IntSet -> b # foldl' :: (b -> Element IntSet -> b) -> b -> IntSet -> b # length :: IntSet -> Int # elem :: Element IntSet -> IntSet -> Bool # foldMap :: Monoid m => (Element IntSet -> m) -> IntSet -> m # fold :: IntSet -> Element IntSet # foldr' :: (Element IntSet -> b -> b) -> b -> IntSet -> b # notElem :: Element IntSet -> IntSet -> Bool # all :: (Element IntSet -> Bool) -> IntSet -> Bool # any :: (Element IntSet -> Bool) -> IntSet -> Bool # and :: IntSet -> Bool # or :: IntSet -> Bool # find :: (Element IntSet -> Bool) -> IntSet -> Maybe (Element IntSet) # safeHead :: IntSet -> Maybe (Element IntSet) # safeMaximum :: IntSet -> Maybe (Element IntSet) # safeMinimum :: IntSet -> Maybe (Element IntSet) # safeFoldr1 :: (Element IntSet -> Element IntSet -> Element IntSet) -> IntSet -> Maybe (Element IntSet) # safeFoldl1 :: (Element IntSet -> Element IntSet -> Element IntSet) -> IntSet -> Maybe (Element IntSet) #
Container MText
Instance details Defined in Morley.Michelson.Text Associated Types type Element MText # Methods toList :: MText -> [Element MText] # null :: MText -> Bool # foldr :: (Element MText -> b -> b) -> b -> MText -> b # foldl :: (b -> Element MText -> b) -> b -> MText -> b # foldl' :: (b -> Element MText -> b) -> b -> MText -> b # length :: MText -> Int # elem :: Element MText -> MText -> Bool # foldMap :: Monoid m => (Element MText -> m) -> MText -> m # fold :: MText -> Element MText # foldr' :: (Element MText -> b -> b) -> b -> MText -> b # notElem :: Element MText -> MText -> Bool # all :: (Element MText -> Bool) -> MText -> Bool # any :: (Element MText -> Bool) -> MText -> Bool # and :: MText -> Bool # or :: MText -> Bool # find :: (Element MText -> Bool) -> MText -> Maybe (Element MText) # safeHead :: MText -> Maybe (Element MText) # safeMaximum :: MText -> Maybe (Element MText) # safeMinimum :: MText -> Maybe (Element MText) # safeFoldr1 :: (Element MText -> Element MText -> Element MText) -> MText -> Maybe (Element MText) # safeFoldl1 :: (Element MText -> Element MText -> Element MText) -> MText -> Maybe (Element MText) #
Container Text
Instance details Defined in Universum.Container.Class Associated Types type Element Text # Methods toList :: Text -> [Element Text] # null :: Text -> Bool # foldr :: (Element Text -> b -> b) -> b -> Text -> b # foldl :: (b -> Element Text -> b) -> b -> Text -> b # foldl' :: (b -> Element Text -> b) -> b -> Text -> b # length :: Text -> Int # elem :: Element Text -> Text -> Bool # foldMap :: Monoid m => (Element Text -> m) -> Text -> m # fold :: Text -> Element Text # foldr' :: (Element Text -> b -> b) -> b -> Text -> b # notElem :: Element Text -> Text -> Bool # all :: (Element Text -> Bool) -> Text -> Bool # any :: (Element Text -> Bool) -> Text -> Bool # and :: Text -> Bool # or :: Text -> Bool # find :: (Element Text -> Bool) -> Text -> Maybe (Element Text) # safeHead :: Text -> Maybe (Element Text) # safeMaximum :: Text -> Maybe (Element Text) # safeMinimum :: Text -> Maybe (Element Text) # safeFoldr1 :: (Element Text -> Element Text -> Element Text) -> Text -> Maybe (Element Text) # safeFoldl1 :: (Element Text -> Element Text -> Element Text) -> Text -> Maybe (Element Text) #
Container Text
Instance details Defined in Universum.Container.Class Associated Types type Element Text # Methods toList :: Text -> [Element Text] # null :: Text -> Bool # foldr :: (Element Text -> b -> b) -> b -> Text -> b # foldl :: (b -> Element Text -> b) -> b -> Text -> b # foldl' :: (b -> Element Text -> b) -> b -> Text -> b # length :: Text -> Int # elem :: Element Text -> Text -> Bool # foldMap :: Monoid m => (Element Text -> m) -> Text -> m # fold :: Text -> Element Text # foldr' :: (Element Text -> b -> b) -> b -> Text -> b # notElem :: Element Text -> Text -> Bool # all :: (Element Text -> Bool) -> Text -> Bool # any :: (Element Text -> Bool) -> Text -> Bool # and :: Text -> Bool # or :: Text -> Bool # find :: (Element Text -> Bool) -> Text -> Maybe (Element Text) # safeHead :: Text -> Maybe (Element Text) # safeMaximum :: Text -> Maybe (Element Text) # safeMinimum :: Text -> Maybe (Element Text) # safeFoldr1 :: (Element Text -> Element Text -> Element Text) -> Text -> Maybe (Element Text) # safeFoldl1 :: (Element Text -> Element Text -> Element Text) -> Text -> Maybe (Element Text) #
Container (ZipList a)
Instance details Defined in Universum.Container.Class Associated Types type Element (ZipList a) # Methods toList :: ZipList a -> [Element (ZipList a)] # null :: ZipList a -> Bool # foldr :: (Element (ZipList a) -> b -> b) -> b -> ZipList a -> b # foldl :: (b -> Element (ZipList a) -> b) -> b -> ZipList a -> b # foldl' :: (b -> Element (ZipList a) -> b) -> b -> ZipList a -> b # length :: ZipList a -> Int # elem :: Element (ZipList a) -> ZipList a -> Bool # foldMap :: Monoid m => (Element (ZipList a) -> m) -> ZipList a -> m # fold :: ZipList a -> Element (ZipList a) # foldr' :: (Element (ZipList a) -> b -> b) -> b -> ZipList a -> b # notElem :: Element (ZipList a) -> ZipList a -> Bool # all :: (Element (ZipList a) -> Bool) -> ZipList a -> Bool # any :: (Element (ZipList a) -> Bool) -> ZipList a -> Bool # and :: ZipList a -> Bool # or :: ZipList a -> Bool # find :: (Element (ZipList a) -> Bool) -> ZipList a -> Maybe (Element (ZipList a)) # safeHead :: ZipList a -> Maybe (Element (ZipList a)) # safeMaximum :: ZipList a -> Maybe (Element (ZipList a)) # safeMinimum :: ZipList a -> Maybe (Element (ZipList a)) # safeFoldr1 :: (Element (ZipList a) -> Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> Maybe (Element (ZipList a)) # safeFoldl1 :: (Element (ZipList a) -> Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> Maybe (Element (ZipList a)) #
(TypeError (DisallowInstance "Identity") :: Constraint) => Container (Identity a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Identity a) # Methods toList :: Identity a -> [Element (Identity a)] # null :: Identity a -> Bool # foldr :: (Element (Identity a) -> b -> b) -> b -> Identity a -> b # foldl :: (b -> Element (Identity a) -> b) -> b -> Identity a -> b # foldl' :: (b -> Element (Identity a) -> b) -> b -> Identity a -> b # length :: Identity a -> Int # elem :: Element (Identity a) -> Identity a -> Bool # foldMap :: Monoid m => (Element (Identity a) -> m) -> Identity a -> m # fold :: Identity a -> Element (Identity a) # foldr' :: (Element (Identity a) -> b -> b) -> b -> Identity a -> b # notElem :: Element (Identity a) -> Identity a -> Bool # all :: (Element (Identity a) -> Bool) -> Identity a -> Bool # any :: (Element (Identity a) -> Bool) -> Identity a -> Bool # and :: Identity a -> Bool # or :: Identity a -> Bool # find :: (Element (Identity a) -> Bool) -> Identity a -> Maybe (Element (Identity a)) # safeHead :: Identity a -> Maybe (Element (Identity a)) # safeMaximum :: Identity a -> Maybe (Element (Identity a)) # safeMinimum :: Identity a -> Maybe (Element (Identity a)) # safeFoldr1 :: (Element (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Maybe (Element (Identity a)) # safeFoldl1 :: (Element (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Maybe (Element (Identity a)) #
Container (First a)
Instance details Defined in Universum.Container.Class Associated Types type Element (First a) # Methods toList :: First a -> [Element (First a)] # null :: First a -> Bool # foldr :: (Element (First a) -> b -> b) -> b -> First a -> b # foldl :: (b -> Element (First a) -> b) -> b -> First a -> b # foldl' :: (b -> Element (First a) -> b) -> b -> First a -> b # length :: First a -> Int # elem :: Element (First a) -> First a -> Bool # foldMap :: Monoid m => (Element (First a) -> m) -> First a -> m # fold :: First a -> Element (First a) # foldr' :: (Element (First a) -> b -> b) -> b -> First a -> b # notElem :: Element (First a) -> First a -> Bool # all :: (Element (First a) -> Bool) -> First a -> Bool # any :: (Element (First a) -> Bool) -> First a -> Bool # and :: First a -> Bool # or :: First a -> Bool # find :: (Element (First a) -> Bool) -> First a -> Maybe (Element (First a)) # safeHead :: First a -> Maybe (Element (First a)) # safeMaximum :: First a -> Maybe (Element (First a)) # safeMinimum :: First a -> Maybe (Element (First a)) # safeFoldr1 :: (Element (First a) -> Element (First a) -> Element (First a)) -> First a -> Maybe (Element (First a)) # safeFoldl1 :: (Element (First a) -> Element (First a) -> Element (First a)) -> First a -> Maybe (Element (First a)) #
Container (Last a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Last a) # Methods toList :: Last a -> [Element (Last a)] # null :: Last a -> Bool # foldr :: (Element (Last a) -> b -> b) -> b -> Last a -> b # foldl :: (b -> Element (Last a) -> b) -> b -> Last a -> b # foldl' :: (b -> Element (Last a) -> b) -> b -> Last a -> b # length :: Last a -> Int # elem :: Element (Last a) -> Last a -> Bool # foldMap :: Monoid m => (Element (Last a) -> m) -> Last a -> m # fold :: Last a -> Element (Last a) # foldr' :: (Element (Last a) -> b -> b) -> b -> Last a -> b # notElem :: Element (Last a) -> Last a -> Bool # all :: (Element (Last a) -> Bool) -> Last a -> Bool # any :: (Element (Last a) -> Bool) -> Last a -> Bool # and :: Last a -> Bool # or :: Last a -> Bool # find :: (Element (Last a) -> Bool) -> Last a -> Maybe (Element (Last a)) # safeHead :: Last a -> Maybe (Element (Last a)) # safeMaximum :: Last a -> Maybe (Element (Last a)) # safeMinimum :: Last a -> Maybe (Element (Last a)) # safeFoldr1 :: (Element (Last a) -> Element (Last a) -> Element (Last a)) -> Last a -> Maybe (Element (Last a)) # safeFoldl1 :: (Element (Last a) -> Element (Last a) -> Element (Last a)) -> Last a -> Maybe (Element (Last a)) #
Container (Dual a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Dual a) # Methods toList :: Dual a -> [Element (Dual a)] # null :: Dual a -> Bool # foldr :: (Element (Dual a) -> b -> b) -> b -> Dual a -> b # foldl :: (b -> Element (Dual a) -> b) -> b -> Dual a -> b # foldl' :: (b -> Element (Dual a) -> b) -> b -> Dual a -> b # length :: Dual a -> Int # elem :: Element (Dual a) -> Dual a -> Bool # foldMap :: Monoid m => (Element (Dual a) -> m) -> Dual a -> m # fold :: Dual a -> Element (Dual a) # foldr' :: (Element (Dual a) -> b -> b) -> b -> Dual a -> b # notElem :: Element (Dual a) -> Dual a -> Bool # all :: (Element (Dual a) -> Bool) -> Dual a -> Bool # any :: (Element (Dual a) -> Bool) -> Dual a -> Bool # and :: Dual a -> Bool # or :: Dual a -> Bool # find :: (Element (Dual a) -> Bool) -> Dual a -> Maybe (Element (Dual a)) # safeHead :: Dual a -> Maybe (Element (Dual a)) # safeMaximum :: Dual a -> Maybe (Element (Dual a)) # safeMinimum :: Dual a -> Maybe (Element (Dual a)) # safeFoldr1 :: (Element (Dual a) -> Element (Dual a) -> Element (Dual a)) -> Dual a -> Maybe (Element (Dual a)) # safeFoldl1 :: (Element (Dual a) -> Element (Dual a) -> Element (Dual a)) -> Dual a -> Maybe (Element (Dual a)) #
Container (Product a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Product a) # Methods toList :: Product a -> [Element (Product a)] # null :: Product a -> Bool # foldr :: (Element (Product a) -> b -> b) -> b -> Product a -> b # foldl :: (b -> Element (Product a) -> b) -> b -> Product a -> b # foldl' :: (b -> Element (Product a) -> b) -> b -> Product a -> b # length :: Product a -> Int # elem :: Element (Product a) -> Product a -> Bool # foldMap :: Monoid m => (Element (Product a) -> m) -> Product a -> m # fold :: Product a -> Element (Product a) # foldr' :: (Element (Product a) -> b -> b) -> b -> Product a -> b # notElem :: Element (Product a) -> Product a -> Bool # all :: (Element (Product a) -> Bool) -> Product a -> Bool # any :: (Element (Product a) -> Bool) -> Product a -> Bool # and :: Product a -> Bool # or :: Product a -> Bool # find :: (Element (Product a) -> Bool) -> Product a -> Maybe (Element (Product a)) # safeHead :: Product a -> Maybe (Element (Product a)) # safeMaximum :: Product a -> Maybe (Element (Product a)) # safeMinimum :: Product a -> Maybe (Element (Product a)) # safeFoldr1 :: (Element (Product a) -> Element (Product a) -> Element (Product a)) -> Product a -> Maybe (Element (Product a)) # safeFoldl1 :: (Element (Product a) -> Element (Product a) -> Element (Product a)) -> Product a -> Maybe (Element (Product a)) #
Container (Sum a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Sum a) # Methods toList :: Sum a -> [Element (Sum a)] # null :: Sum a -> Bool # foldr :: (Element (Sum a) -> b -> b) -> b -> Sum a -> b # foldl :: (b -> Element (Sum a) -> b) -> b -> Sum a -> b # foldl' :: (b -> Element (Sum a) -> b) -> b -> Sum a -> b # length :: Sum a -> Int # elem :: Element (Sum a) -> Sum a -> Bool # foldMap :: Monoid m => (Element (Sum a) -> m) -> Sum a -> m # fold :: Sum a -> Element (Sum a) # foldr' :: (Element (Sum a) -> b -> b) -> b -> Sum a -> b # notElem :: Element (Sum a) -> Sum a -> Bool # all :: (Element (Sum a) -> Bool) -> Sum a -> Bool # any :: (Element (Sum a) -> Bool) -> Sum a -> Bool # and :: Sum a -> Bool # or :: Sum a -> Bool # find :: (Element (Sum a) -> Bool) -> Sum a -> Maybe (Element (Sum a)) # safeHead :: Sum a -> Maybe (Element (Sum a)) # safeMaximum :: Sum a -> Maybe (Element (Sum a)) # safeMinimum :: Sum a -> Maybe (Element (Sum a)) # safeFoldr1 :: (Element (Sum a) -> Element (Sum a) -> Element (Sum a)) -> Sum a -> Maybe (Element (Sum a)) # safeFoldl1 :: (Element (Sum a) -> Element (Sum a) -> Element (Sum a)) -> Sum a -> Maybe (Element (Sum a)) #
Container (NonEmpty a)
Instance details Defined in Universum.Container.Class Associated Types type Element (NonEmpty a) # Methods toList :: NonEmpty a -> [Element (NonEmpty a)] # null :: NonEmpty a -> Bool # foldr :: (Element (NonEmpty a) -> b -> b) -> b -> NonEmpty a -> b # foldl :: (b -> Element (NonEmpty a) -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> Element (NonEmpty a) -> b) -> b -> NonEmpty a -> b # length :: NonEmpty a -> Int # elem :: Element (NonEmpty a) -> NonEmpty a -> Bool # foldMap :: Monoid m => (Element (NonEmpty a) -> m) -> NonEmpty a -> m # fold :: NonEmpty a -> Element (NonEmpty a) # foldr' :: (Element (NonEmpty a) -> b -> b) -> b -> NonEmpty a -> b # notElem :: Element (NonEmpty a) -> NonEmpty a -> Bool # all :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Bool # any :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Bool # and :: NonEmpty a -> Bool # or :: NonEmpty a -> Bool # find :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Maybe (Element (NonEmpty a)) # safeHead :: NonEmpty a -> Maybe (Element (NonEmpty a)) # safeMaximum :: NonEmpty a -> Maybe (Element (NonEmpty a)) # safeMinimum :: NonEmpty a -> Maybe (Element (NonEmpty a)) # safeFoldr1 :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> Maybe (Element (NonEmpty a)) # safeFoldl1 :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> Maybe (Element (NonEmpty a)) #
Container (IntMap v)
Instance details Defined in Universum.Container.Class Associated Types type Element (IntMap v) # Methods toList :: IntMap v -> [Element (IntMap v)] # null :: IntMap v -> Bool # foldr :: (Element (IntMap v) -> b -> b) -> b -> IntMap v -> b # foldl :: (b -> Element (IntMap v) -> b) -> b -> IntMap v -> b # foldl' :: (b -> Element (IntMap v) -> b) -> b -> IntMap v -> b # length :: IntMap v -> Int # elem :: Element (IntMap v) -> IntMap v -> Bool # foldMap :: Monoid m => (Element (IntMap v) -> m) -> IntMap v -> m # fold :: IntMap v -> Element (IntMap v) # foldr' :: (Element (IntMap v) -> b -> b) -> b -> IntMap v -> b # notElem :: Element (IntMap v) -> IntMap v -> Bool # all :: (Element (IntMap v) -> Bool) -> IntMap v -> Bool # any :: (Element (IntMap v) -> Bool) -> IntMap v -> Bool # and :: IntMap v -> Bool # or :: IntMap v -> Bool # find :: (Element (IntMap v) -> Bool) -> IntMap v -> Maybe (Element (IntMap v)) # safeHead :: IntMap v -> Maybe (Element (IntMap v)) # safeMaximum :: IntMap v -> Maybe (Element (IntMap v)) # safeMinimum :: IntMap v -> Maybe (Element (IntMap v)) # safeFoldr1 :: (Element (IntMap v) -> Element (IntMap v) -> Element (IntMap v)) -> IntMap v -> Maybe (Element (IntMap v)) # safeFoldl1 :: (Element (IntMap v) -> Element (IntMap v) -> Element (IntMap v)) -> IntMap v -> Maybe (Element (IntMap v)) #
Container (Seq a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Seq a) # Methods toList :: Seq a -> [Element (Seq a)] # null :: Seq a -> Bool # foldr :: (Element (Seq a) -> b -> b) -> b -> Seq a -> b # foldl :: (b -> Element (Seq a) -> b) -> b -> Seq a -> b # foldl' :: (b -> Element (Seq a) -> b) -> b -> Seq a -> b # length :: Seq a -> Int # elem :: Element (Seq a) -> Seq a -> Bool # foldMap :: Monoid m => (Element (Seq a) -> m) -> Seq a -> m # fold :: Seq a -> Element (Seq a) # foldr' :: (Element (Seq a) -> b -> b) -> b -> Seq a -> b # notElem :: Element (Seq a) -> Seq a -> Bool # all :: (Element (Seq a) -> Bool) -> Seq a -> Bool # any :: (Element (Seq a) -> Bool) -> Seq a -> Bool # and :: Seq a -> Bool # or :: Seq a -> Bool # find :: (Element (Seq a) -> Bool) -> Seq a -> Maybe (Element (Seq a)) # safeHead :: Seq a -> Maybe (Element (Seq a)) # safeMaximum :: Seq a -> Maybe (Element (Seq a)) # safeMinimum :: Seq a -> Maybe (Element (Seq a)) # safeFoldr1 :: (Element (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Maybe (Element (Seq a)) # safeFoldl1 :: (Element (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Maybe (Element (Seq a)) #
Ord v => Container (Set v)
Instance details Defined in Universum.Container.Class Associated Types type Element (Set v) # Methods toList :: Set v -> [Element (Set v)] # null :: Set v -> Bool # foldr :: (Element (Set v) -> b -> b) -> b -> Set v -> b # foldl :: (b -> Element (Set v) -> b) -> b -> Set v -> b # foldl' :: (b -> Element (Set v) -> b) -> b -> Set v -> b # length :: Set v -> Int # elem :: Element (Set v) -> Set v -> Bool # foldMap :: Monoid m => (Element (Set v) -> m) -> Set v -> m # fold :: Set v -> Element (Set v) # foldr' :: (Element (Set v) -> b -> b) -> b -> Set v -> b # notElem :: Element (Set v) -> Set v -> Bool # all :: (Element (Set v) -> Bool) -> Set v -> Bool # any :: (Element (Set v) -> Bool) -> Set v -> Bool # and :: Set v -> Bool # or :: Set v -> Bool # find :: (Element (Set v) -> Bool) -> Set v -> Maybe (Element (Set v)) # safeHead :: Set v -> Maybe (Element (Set v)) # safeMaximum :: Set v -> Maybe (Element (Set v)) # safeMinimum :: Set v -> Maybe (Element (Set v)) # safeFoldr1 :: (Element (Set v) -> Element (Set v) -> Element (Set v)) -> Set v -> Maybe (Element (Set v)) # safeFoldl1 :: (Element (Set v) -> Element (Set v) -> Element (Set v)) -> Set v -> Maybe (Element (Set v)) #
Container (ViewsSetF a)
Instance details Defined in Morley.Michelson.Internal.ViewsSet Associated Types type Element (ViewsSetF a) # Methods toList :: ViewsSetF a -> [Element (ViewsSetF a)] # null :: ViewsSetF a -> Bool # foldr :: (Element (ViewsSetF a) -> b -> b) -> b -> ViewsSetF a -> b # foldl :: (b -> Element (ViewsSetF a) -> b) -> b -> ViewsSetF a -> b # foldl' :: (b -> Element (ViewsSetF a) -> b) -> b -> ViewsSetF a -> b # length :: ViewsSetF a -> Int # elem :: Element (ViewsSetF a) -> ViewsSetF a -> Bool # foldMap :: Monoid m => (Element (ViewsSetF a) -> m) -> ViewsSetF a -> m # fold :: ViewsSetF a -> Element (ViewsSetF a) # foldr' :: (Element (ViewsSetF a) -> b -> b) -> b -> ViewsSetF a -> b # notElem :: Element (ViewsSetF a) -> ViewsSetF a -> Bool # all :: (Element (ViewsSetF a) -> Bool) -> ViewsSetF a -> Bool # any :: (Element (ViewsSetF a) -> Bool) -> ViewsSetF a -> Bool # and :: ViewsSetF a -> Bool # or :: ViewsSetF a -> Bool # find :: (Element (ViewsSetF a) -> Bool) -> ViewsSetF a -> Maybe (Element (ViewsSetF a)) # safeHead :: ViewsSetF a -> Maybe (Element (ViewsSetF a)) # safeMaximum :: ViewsSetF a -> Maybe (Element (ViewsSetF a)) # safeMinimum :: ViewsSetF a -> Maybe (Element (ViewsSetF a)) # safeFoldr1 :: (Element (ViewsSetF a) -> Element (ViewsSetF a) -> Element (ViewsSetF a)) -> ViewsSetF a -> Maybe (Element (ViewsSetF a)) # safeFoldl1 :: (Element (ViewsSetF a) -> Element (ViewsSetF a) -> Element (ViewsSetF a)) -> ViewsSetF a -> Maybe (Element (ViewsSetF a)) #
Container (ViewsSet instr)
Instance details Defined in Morley.Michelson.Untyped.View Associated Types type Element (ViewsSet instr) # Methods toList :: ViewsSet instr -> [Element (ViewsSet instr)] # null :: ViewsSet instr -> Bool # foldr :: (Element (ViewsSet instr) -> b -> b) -> b -> ViewsSet instr -> b # foldl :: (b -> Element (ViewsSet instr) -> b) -> b -> ViewsSet instr -> b # foldl' :: (b -> Element (ViewsSet instr) -> b) -> b -> ViewsSet instr -> b # length :: ViewsSet instr -> Int # elem :: Element (ViewsSet instr) -> ViewsSet instr -> Bool # foldMap :: Monoid m => (Element (ViewsSet instr) -> m) -> ViewsSet instr -> m # fold :: ViewsSet instr -> Element (ViewsSet instr) # foldr' :: (Element (ViewsSet instr) -> b -> b) -> b -> ViewsSet instr -> b # notElem :: Element (ViewsSet instr) -> ViewsSet instr -> Bool # all :: (Element (ViewsSet instr) -> Bool) -> ViewsSet instr -> Bool # any :: (Element (ViewsSet instr) -> Bool) -> ViewsSet instr -> Bool # and :: ViewsSet instr -> Bool # or :: ViewsSet instr -> Bool # find :: (Element (ViewsSet instr) -> Bool) -> ViewsSet instr -> Maybe (Element (ViewsSet instr)) # safeHead :: ViewsSet instr -> Maybe (Element (ViewsSet instr)) # safeMaximum :: ViewsSet instr -> Maybe (Element (ViewsSet instr)) # safeMinimum :: ViewsSet instr -> Maybe (Element (ViewsSet instr)) # safeFoldr1 :: (Element (ViewsSet instr) -> Element (ViewsSet instr) -> Element (ViewsSet instr)) -> ViewsSet instr -> Maybe (Element (ViewsSet instr)) # safeFoldl1 :: (Element (ViewsSet instr) -> Element (ViewsSet instr) -> Element (ViewsSet instr)) -> ViewsSet instr -> Maybe (Element (ViewsSet instr)) #
Container (MismatchError a)
Instance details Defined in Morley.Util.MismatchError Associated Types type Element (MismatchError a) # Methods toList :: MismatchError a -> [Element (MismatchError a)] # null :: MismatchError a -> Bool # foldr :: (Element (MismatchError a) -> b -> b) -> b -> MismatchError a -> b # foldl :: (b -> Element (MismatchError a) -> b) -> b -> MismatchError a -> b # foldl' :: (b -> Element (MismatchError a) -> b) -> b -> MismatchError a -> b # length :: MismatchError a -> Int # elem :: Element (MismatchError a) -> MismatchError a -> Bool # foldMap :: Monoid m => (Element (MismatchError a) -> m) -> MismatchError a -> m # fold :: MismatchError a -> Element (MismatchError a) # foldr' :: (Element (MismatchError a) -> b -> b) -> b -> MismatchError a -> b # notElem :: Element (MismatchError a) -> MismatchError a -> Bool # all :: (Element (MismatchError a) -> Bool) -> MismatchError a -> Bool # any :: (Element (MismatchError a) -> Bool) -> MismatchError a -> Bool # and :: MismatchError a -> Bool # or :: MismatchError a -> Bool # find :: (Element (MismatchError a) -> Bool) -> MismatchError a -> Maybe (Element (MismatchError a)) # safeHead :: MismatchError a -> Maybe (Element (MismatchError a)) # safeMaximum :: MismatchError a -> Maybe (Element (MismatchError a)) # safeMinimum :: MismatchError a -> Maybe (Element (MismatchError a)) # safeFoldr1 :: (Element (MismatchError a) -> Element (MismatchError a) -> Element (MismatchError a)) -> MismatchError a -> Maybe (Element (MismatchError a)) # safeFoldl1 :: (Element (MismatchError a) -> Element (MismatchError a) -> Element (MismatchError a)) -> MismatchError a -> Maybe (Element (MismatchError a)) #
Container (SomeSizedList a)
Instance details Defined in Morley.Util.SizedList Associated Types type Element (SomeSizedList a) # Methods toList :: SomeSizedList a -> [Element (SomeSizedList a)] # null :: SomeSizedList a -> Bool # foldr :: (Element (SomeSizedList a) -> b -> b) -> b -> SomeSizedList a -> b # foldl :: (b -> Element (SomeSizedList a) -> b) -> b -> SomeSizedList a -> b # foldl' :: (b -> Element (SomeSizedList a) -> b) -> b -> SomeSizedList a -> b # length :: SomeSizedList a -> Int # elem :: Element (SomeSizedList a) -> SomeSizedList a -> Bool # foldMap :: Monoid m => (Element (SomeSizedList a) -> m) -> SomeSizedList a -> m # fold :: SomeSizedList a -> Element (SomeSizedList a) # foldr' :: (Element (SomeSizedList a) -> b -> b) -> b -> SomeSizedList a -> b # notElem :: Element (SomeSizedList a) -> SomeSizedList a -> Bool # all :: (Element (SomeSizedList a) -> Bool) -> SomeSizedList a -> Bool # any :: (Element (SomeSizedList a) -> Bool) -> SomeSizedList a -> Bool # and :: SomeSizedList a -> Bool # or :: SomeSizedList a -> Bool # find :: (Element (SomeSizedList a) -> Bool) -> SomeSizedList a -> Maybe (Element (SomeSizedList a)) # safeHead :: SomeSizedList a -> Maybe (Element (SomeSizedList a)) # safeMaximum :: SomeSizedList a -> Maybe (Element (SomeSizedList a)) # safeMinimum :: SomeSizedList a -> Maybe (Element (SomeSizedList a)) # safeFoldr1 :: (Element (SomeSizedList a) -> Element (SomeSizedList a) -> Element (SomeSizedList a)) -> SomeSizedList a -> Maybe (Element (SomeSizedList a)) # safeFoldl1 :: (Element (SomeSizedList a) -> Element (SomeSizedList a) -> Element (SomeSizedList a)) -> SomeSizedList a -> Maybe (Element (SomeSizedList a)) #
(Eq v, Hashable v) => Container (HashSet v)
Instance details Defined in Universum.Container.Class Associated Types type Element (HashSet v) # Methods toList :: HashSet v -> [Element (HashSet v)] # null :: HashSet v -> Bool # foldr :: (Element (HashSet v) -> b -> b) -> b -> HashSet v -> b # foldl :: (b -> Element (HashSet v) -> b) -> b -> HashSet v -> b # foldl' :: (b -> Element (HashSet v) -> b) -> b -> HashSet v -> b # length :: HashSet v -> Int # elem :: Element (HashSet v) -> HashSet v -> Bool # foldMap :: Monoid m => (Element (HashSet v) -> m) -> HashSet v -> m # fold :: HashSet v -> Element (HashSet v) # foldr' :: (Element (HashSet v) -> b -> b) -> b -> HashSet v -> b # notElem :: Element (HashSet v) -> HashSet v -> Bool # all :: (Element (HashSet v) -> Bool) -> HashSet v -> Bool # any :: (Element (HashSet v) -> Bool) -> HashSet v -> Bool # and :: HashSet v -> Bool # or :: HashSet v -> Bool # find :: (Element (HashSet v) -> Bool) -> HashSet v -> Maybe (Element (HashSet v)) # safeHead :: HashSet v -> Maybe (Element (HashSet v)) # safeMaximum :: HashSet v -> Maybe (Element (HashSet v)) # safeMinimum :: HashSet v -> Maybe (Element (HashSet v)) # safeFoldr1 :: (Element (HashSet v) -> Element (HashSet v) -> Element (HashSet v)) -> HashSet v -> Maybe (Element (HashSet v)) # safeFoldl1 :: (Element (HashSet v) -> Element (HashSet v) -> Element (HashSet v)) -> HashSet v -> Maybe (Element (HashSet v)) #
Container (Vector a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Vector a) # Methods toList :: Vector a -> [Element (Vector a)] # null :: Vector a -> Bool # foldr :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b # foldl :: (b -> Element (Vector a) -> b) -> b -> Vector a -> b # foldl' :: (b -> Element (Vector a) -> b) -> b -> Vector a -> b # length :: Vector a -> Int # elem :: Element (Vector a) -> Vector a -> Bool # foldMap :: Monoid m => (Element (Vector a) -> m) -> Vector a -> m # fold :: Vector a -> Element (Vector a) # foldr' :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b # notElem :: Element (Vector a) -> Vector a -> Bool # all :: (Element (Vector a) -> Bool) -> Vector a -> Bool # any :: (Element (Vector a) -> Bool) -> Vector a -> Bool # and :: Vector a -> Bool # or :: Vector a -> Bool # find :: (Element (Vector a) -> Bool) -> Vector a -> Maybe (Element (Vector a)) # safeHead :: Vector a -> Maybe (Element (Vector a)) # safeMaximum :: Vector a -> Maybe (Element (Vector a)) # safeMinimum :: Vector a -> Maybe (Element (Vector a)) # safeFoldr1 :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Maybe (Element (Vector a)) # safeFoldl1 :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Maybe (Element (Vector a)) #
(TypeError (DisallowInstance "Maybe") :: Constraint) => Container (Maybe a)
Instance details Defined in Universum.Container.Class Associated Types type Element (Maybe a) # Methods toList :: Maybe a -> [Element (Maybe a)] # null :: Maybe a -> Bool # foldr :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> Element (Maybe a) -> b) -> b -> Maybe a -> b # foldl' :: (b -> Element (Maybe a) -> b) -> b -> Maybe a -> b # length :: Maybe a -> Int # elem :: Element (Maybe a) -> Maybe a -> Bool # foldMap :: Monoid m => (Element (Maybe a) -> m) -> Maybe a -> m # fold :: Maybe a -> Element (Maybe a) # foldr' :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b # notElem :: Element (Maybe a) -> Maybe a -> Bool # all :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool # any :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool # and :: Maybe a -> Bool # or :: Maybe a -> Bool # find :: (Element (Maybe a) -> Bool) -> Maybe a -> Maybe (Element (Maybe a)) # safeHead :: Maybe a -> Maybe (Element (Maybe a)) # safeMaximum :: Maybe a -> Maybe (Element (Maybe a)) # safeMinimum :: Maybe a -> Maybe (Element (Maybe a)) # safeFoldr1 :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe (Element (Maybe a)) # safeFoldl1 :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe (Element (Maybe a)) #
Container [a]
Instance details Defined in Universum.Container.Class Associated Types type Element [a] # Methods toList :: [a] -> [Element [a]] # null :: [a] -> Bool # foldr :: (Element [a] -> b -> b) -> b -> [a] -> b # foldl :: (b -> Element [a] -> b) -> b -> [a] -> b # foldl' :: (b -> Element [a] -> b) -> b -> [a] -> b # length :: [a] -> Int # elem :: Element [a] -> [a] -> Bool # foldMap :: Monoid m => (Element [a] -> m) -> [a] -> m # fold :: [a] -> Element [a] # foldr' :: (Element [a] -> b -> b) -> b -> [a] -> b # notElem :: Element [a] -> [a] -> Bool # all :: (Element [a] -> Bool) -> [a] -> Bool # any :: (Element [a] -> Bool) -> [a] -> Bool # and :: [a] -> Bool # or :: [a] -> Bool # find :: (Element [a] -> Bool) -> [a] -> Maybe (Element [a]) # safeHead :: [a] -> Maybe (Element [a]) # safeMaximum :: [a] -> Maybe (Element [a]) # safeMinimum :: [a] -> Maybe (Element [a]) # safeFoldr1 :: (Element [a] -> Element [a] -> Element [a]) -> [a] -> Maybe (Element [a]) # safeFoldl1 :: (Element [a] -> Element [a] -> Element [a]) -> [a] -> Maybe (Element [a]) #
(TypeError (DisallowInstance "Either") :: Constraint) => Container (Either a b)
Instance details Defined in Universum.Container.Class Associated Types type Element (Either a b) # Methods toList :: Either a b -> [Element (Either a b)] # null :: Either a b -> Bool # foldr :: (Element (Either a b) -> b0 -> b0) -> b0 -> Either a b -> b0 # foldl :: (b0 -> Element (Either a b) -> b0) -> b0 -> Either a b -> b0 # foldl' :: (b0 -> Element (Either a b) -> b0) -> b0 -> Either a b -> b0 # length :: Either a b -> Int # elem :: Element (Either a b) -> Either a b -> Bool # foldMap :: Monoid m => (Element (Either a b) -> m) -> Either a b -> m # fold :: Either a b -> Element (Either a b) # foldr' :: (Element (Either a b) -> b0 -> b0) -> b0 -> Either a b -> b0 # notElem :: Element (Either a b) -> Either a b -> Bool # all :: (Element (Either a b) -> Bool) -> Either a b -> Bool # any :: (Element (Either a b) -> Bool) -> Either a b -> Bool # and :: Either a b -> Bool # or :: Either a b -> Bool # find :: (Element (Either a b) -> Bool) -> Either a b -> Maybe (Element (Either a b)) # safeHead :: Either a b -> Maybe (Element (Either a b)) # safeMaximum :: Either a b -> Maybe (Element (Either a b)) # safeMinimum :: Either a b -> Maybe (Element (Either a b)) # safeFoldr1 :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Maybe (Element (Either a b)) # safeFoldl1 :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Maybe (Element (Either a b)) #
Container (Map k v)
Instance details Defined in Universum.Container.Class Associated Types type Element (Map k v) # Methods toList :: Map k v -> [Element (Map k v)] # null :: Map k v -> Bool # foldr :: (Element (Map k v) -> b -> b) -> b -> Map k v -> b # foldl :: (b -> Element (Map k v) -> b) -> b -> Map k v -> b # foldl' :: (b -> Element (Map k v) -> b) -> b -> Map k v -> b # length :: Map k v -> Int # elem :: Element (Map k v) -> Map k v -> Bool # foldMap :: Monoid m => (Element (Map k v) -> m) -> Map k v -> m # fold :: Map k v -> Element (Map k v) # foldr' :: (Element (Map k v) -> b -> b) -> b -> Map k v -> b # notElem :: Element (Map k v) -> Map k v -> Bool # all :: (Element (Map k v) -> Bool) -> Map k v -> Bool # any :: (Element (Map k v) -> Bool) -> Map k v -> Bool # and :: Map k v -> Bool # or :: Map k v -> Bool # find :: (Element (Map k v) -> Bool) -> Map k v -> Maybe (Element (Map k v)) # safeHead :: Map k v -> Maybe (Element (Map k v)) # safeMaximum :: Map k v -> Maybe (Element (Map k v)) # safeMinimum :: Map k v -> Maybe (Element (Map k v)) # safeFoldr1 :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Maybe (Element (Map k v)) # safeFoldl1 :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Maybe (Element (Map k v)) #
Container (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value Associated Types type Element (BigMap k v) # Methods toList :: BigMap k v -> [Element (BigMap k v)] # null :: BigMap k v -> Bool # foldr :: (Element (BigMap k v) -> b -> b) -> b -> BigMap k v -> b # foldl :: (b -> Element (BigMap k v) -> b) -> b -> BigMap k v -> b # foldl' :: (b -> Element (BigMap k v) -> b) -> b -> BigMap k v -> b # length :: BigMap k v -> Int # elem :: Element (BigMap k v) -> BigMap k v -> Bool # foldMap :: Monoid m => (Element (BigMap k v) -> m) -> BigMap k v -> m # fold :: BigMap k v -> Element (BigMap k v) # foldr' :: (Element (BigMap k v) -> b -> b) -> b -> BigMap k v -> b # notElem :: Element (BigMap k v) -> BigMap k v -> Bool # all :: (Element (BigMap k v) -> Bool) -> BigMap k v -> Bool # any :: (Element (BigMap k v) -> Bool) -> BigMap k v -> Bool # and :: BigMap k v -> Bool # or :: BigMap k v -> Bool # find :: (Element (BigMap k v) -> Bool) -> BigMap k v -> Maybe (Element (BigMap k v)) # safeHead :: BigMap k v -> Maybe (Element (BigMap k v)) # safeMaximum :: BigMap k v -> Maybe (Element (BigMap k v)) # safeMinimum :: BigMap k v -> Maybe (Element (BigMap k v)) # safeFoldr1 :: (Element (BigMap k v) -> Element (BigMap k v) -> Element (BigMap k v)) -> BigMap k v -> Maybe (Element (BigMap k v)) # safeFoldl1 :: (Element (BigMap k v) -> Element (BigMap k v) -> Element (BigMap k v)) -> BigMap k v -> Maybe (Element (BigMap k v)) #
Container (ViewsSet' instr st)
Instance details Defined in Morley.Michelson.Typed.View Associated Types type Element (ViewsSet' instr st) # Methods toList :: ViewsSet' instr st -> [Element (ViewsSet' instr st)] # null :: ViewsSet' instr st -> Bool # foldr :: (Element (ViewsSet' instr st) -> b -> b) -> b -> ViewsSet' instr st -> b # foldl :: (b -> Element (ViewsSet' instr st) -> b) -> b -> ViewsSet' instr st -> b # foldl' :: (b -> Element (ViewsSet' instr st) -> b) -> b -> ViewsSet' instr st -> b # length :: ViewsSet' instr st -> Int # elem :: Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool # foldMap :: Monoid m => (Element (ViewsSet' instr st) -> m) -> ViewsSet' instr st -> m # fold :: ViewsSet' instr st -> Element (ViewsSet' instr st) # foldr' :: (Element (ViewsSet' instr st) -> b -> b) -> b -> ViewsSet' instr st -> b # notElem :: Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool # all :: (Element (ViewsSet' instr st) -> Bool) -> ViewsSet' instr st -> Bool # any :: (Element (ViewsSet' instr st) -> Bool) -> ViewsSet' instr st -> Bool # and :: ViewsSet' instr st -> Bool # or :: ViewsSet' instr st -> Bool # find :: (Element (ViewsSet' instr st) -> Bool) -> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) # safeHead :: ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) # safeMaximum :: ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) # safeMinimum :: ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) # safeFoldr1 :: (Element (ViewsSet' instr st) -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st)) -> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) # safeFoldl1 :: (Element (ViewsSet' instr st) -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st)) -> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)) #
Container (SizedList' n a)
Instance details Defined in Morley.Util.SizedList Associated Types type Element (SizedList' n a) # Methods toList :: SizedList' n a -> [Element (SizedList' n a)] # null :: SizedList' n a -> Bool # foldr :: (Element (SizedList' n a) -> b -> b) -> b -> SizedList' n a -> b # foldl :: (b -> Element (SizedList' n a) -> b) -> b -> SizedList' n a -> b # foldl' :: (b -> Element (SizedList' n a) -> b) -> b -> SizedList' n a -> b # length :: SizedList' n a -> Int # elem :: Element (SizedList' n a) -> SizedList' n a -> Bool # foldMap :: Monoid m => (Element (SizedList' n a) -> m) -> SizedList' n a -> m # fold :: SizedList' n a -> Element (SizedList' n a) # foldr' :: (Element (SizedList' n a) -> b -> b) -> b -> SizedList' n a -> b # notElem :: Element (SizedList' n a) -> SizedList' n a -> Bool # all :: (Element (SizedList' n a) -> Bool) -> SizedList' n a -> Bool # any :: (Element (SizedList' n a) -> Bool) -> SizedList' n a -> Bool # and :: SizedList' n a -> Bool # or :: SizedList' n a -> Bool # find :: (Element (SizedList' n a) -> Bool) -> SizedList' n a -> Maybe (Element (SizedList' n a)) # safeHead :: SizedList' n a -> Maybe (Element (SizedList' n a)) # safeMaximum :: SizedList' n a -> Maybe (Element (SizedList' n a)) # safeMinimum :: SizedList' n a -> Maybe (Element (SizedList' n a)) # safeFoldr1 :: (Element (SizedList' n a) -> Element (SizedList' n a) -> Element (SizedList' n a)) -> SizedList' n a -> Maybe (Element (SizedList' n a)) # safeFoldl1 :: (Element (SizedList' n a) -> Element (SizedList' n a) -> Element (SizedList' n a)) -> SizedList' n a -> Maybe (Element (SizedList' n a)) #
Container (HashMap k v)
Instance details Defined in Universum.Container.Class Associated Types type Element (HashMap k v) # Methods toList :: HashMap k v -> [Element (HashMap k v)] # null :: HashMap k v -> Bool # foldr :: (Element (HashMap k v) -> b -> b) -> b -> HashMap k v -> b # foldl :: (b -> Element (HashMap k v) -> b) -> b -> HashMap k v -> b # foldl' :: (b -> Element (HashMap k v) -> b) -> b -> HashMap k v -> b # length :: HashMap k v -> Int # elem :: Element (HashMap k v) -> HashMap k v -> Bool # foldMap :: Monoid m => (Element (HashMap k v) -> m) -> HashMap k v -> m # fold :: HashMap k v -> Element (HashMap k v) # foldr' :: (Element (HashMap k v) -> b -> b) -> b -> HashMap k v -> b # notElem :: Element (HashMap k v) -> HashMap k v -> Bool # all :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Bool # any :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Bool # and :: HashMap k v -> Bool # or :: HashMap k v -> Bool # find :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Maybe (Element (HashMap k v)) # safeHead :: HashMap k v -> Maybe (Element (HashMap k v)) # safeMaximum :: HashMap k v -> Maybe (Element (HashMap k v)) # safeMinimum :: HashMap k v -> Maybe (Element (HashMap k v)) # safeFoldr1 :: (Element (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> Maybe (Element (HashMap k v)) # safeFoldl1 :: (Element (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> Maybe (Element (HashMap k v)) #
(TypeError (DisallowInstance "tuple") :: Constraint) => Container (a, b)
Instance details Defined in Universum.Container.Class Associated Types type Element (a, b) # Methods toList :: (a, b) -> [Element (a, b)] # null :: (a, b) -> Bool # foldr :: (Element (a, b) -> b0 -> b0) -> b0 -> (a, b) -> b0 # foldl :: (b0 -> Element (a, b) -> b0) -> b0 -> (a, b) -> b0 # foldl' :: (b0 -> Element (a, b) -> b0) -> b0 -> (a, b) -> b0 # length :: (a, b) -> Int # elem :: Element (a, b) -> (a, b) -> Bool # foldMap :: Monoid m => (Element (a, b) -> m) -> (a, b) -> m # fold :: (a, b) -> Element (a, b) # foldr' :: (Element (a, b) -> b0 -> b0) -> b0 -> (a, b) -> b0 # notElem :: Element (a, b) -> (a, b) -> Bool # all :: (Element (a, b) -> Bool) -> (a, b) -> Bool # any :: (Element (a, b) -> Bool) -> (a, b) -> Bool # and :: (a, b) -> Bool # or :: (a, b) -> Bool # find :: (Element (a, b) -> Bool) -> (a, b) -> Maybe (Element (a, b)) # safeHead :: (a, b) -> Maybe (Element (a, b)) # safeMaximum :: (a, b) -> Maybe (Element (a, b)) # safeMinimum :: (a, b) -> Maybe (Element (a, b)) # safeFoldr1 :: (Element (a, b) -> Element (a, b) -> Element (a, b)) -> (a, b) -> Maybe (Element (a, b)) # safeFoldl1 :: (Element (a, b) -> Element (a, b) -> Element (a, b)) -> (a, b) -> Maybe (Element (a, b)) #
Container (Const a b)
Instance details Defined in Universum.Container.Class Associated Types type Element (Const a b) # Methods toList :: Const a b -> [Element (Const a b)] # null :: Const a b -> Bool # foldr :: (Element (Const a b) -> b0 -> b0) -> b0 -> Const a b -> b0 # foldl :: (b0 -> Element (Const a b) -> b0) -> b0 -> Const a b -> b0 # foldl' :: (b0 -> Element (Const a b) -> b0) -> b0 -> Const a b -> b0 # length :: Const a b -> Int # elem :: Element (Const a b) -> Const a b -> Bool # foldMap :: Monoid m => (Element (Const a b) -> m) -> Const a b -> m # fold :: Const a b -> Element (Const a b) # foldr' :: (Element (Const a b) -> b0 -> b0) -> b0 -> Const a b -> b0 # notElem :: Element (Const a b) -> Const a b -> Bool # all :: (Element (Const a b) -> Bool) -> Const a b -> Bool # any :: (Element (Const a b) -> Bool) -> Const a b -> Bool # and :: Const a b -> Bool # or :: Const a b -> Bool # find :: (Element (Const a b) -> Bool) -> Const a b -> Maybe (Element (Const a b)) # safeHead :: Const a b -> Maybe (Element (Const a b)) # safeMaximum :: Const a b -> Maybe (Element (Const a b)) # safeMinimum :: Const a b -> Maybe (Element (Const a b)) # safeFoldr1 :: (Element (Const a b) -> Element (Const a b) -> Element (Const a b)) -> Const a b -> Maybe (Element (Const a b)) # safeFoldl1 :: (Element (Const a b) -> Element (Const a b) -> Element (Const a b)) -> Const a b -> Maybe (Element (Const a b)) #

type family Element t #

Type of element for some container. Implemented as an asscociated type family because some containers are monomorphic over element type (like Text, IntSet, etc.) so we can't implement nice interface using old higher-kinded types approach. Implementing this as an associated type family instead of top-level family gives you more control over element types.

Instances

Instances details

type Element ByteString
Instance details Defined in Universum.Container.Class type Element ByteString = Word8
type Element ByteString
Instance details Defined in Universum.Container.Class type Element ByteString = Word8
type Element IntSet
Instance details Defined in Universum.Container.Class type Element IntSet = Int
type Element MText
Instance details Defined in Morley.Michelson.Text type Element MText = Element Text
type Element Text
Instance details Defined in Universum.Container.Class type Element Text = Char
type Element Text
Instance details Defined in Universum.Container.Class type Element Text = Char
type Element (ZipList a)
Instance details Defined in Universum.Container.Class type Element (ZipList a) = ElementDefault (ZipList a)
type Element (Identity a)
Instance details Defined in Universum.Container.Class type Element (Identity a) = ElementDefault (Identity a)
type Element (First a)
Instance details Defined in Universum.Container.Class type Element (First a) = ElementDefault (First a)
type Element (Last a)
Instance details Defined in Universum.Container.Class type Element (Last a) = ElementDefault (Last a)
type Element (Dual a)
Instance details Defined in Universum.Container.Class type Element (Dual a) = ElementDefault (Dual a)
type Element (Product a)
Instance details Defined in Universum.Container.Class type Element (Product a) = ElementDefault (Product a)
type Element (Sum a)
Instance details Defined in Universum.Container.Class type Element (Sum a) = ElementDefault (Sum a)
type Element (NonEmpty a)
Instance details Defined in Universum.Container.Class type Element (NonEmpty a) = ElementDefault (NonEmpty a)
type Element (IntMap v)
Instance details Defined in Universum.Container.Class type Element (IntMap v) = ElementDefault (IntMap v)
type Element (Seq a)
Instance details Defined in Universum.Container.Class type Element (Seq a) = ElementDefault (Seq a)
type Element (Set v)
Instance details Defined in Universum.Container.Class type Element (Set v) = ElementDefault (Set v)
type Element (ViewsSetF a)
Instance details Defined in Morley.Michelson.Internal.ViewsSet type Element (ViewsSetF a) = Element (Map ViewName a)
type Element (ViewsSet instr)
Instance details Defined in Morley.Michelson.Untyped.View type Element (ViewsSet instr) = Element (Map ViewName (View' instr))
type Element (MismatchError a)
Instance details Defined in Morley.Util.MismatchError type Element (MismatchError a) = ElementDefault (MismatchError a)
type Element (SomeSizedList a)
Instance details Defined in Morley.Util.SizedList type Element (SomeSizedList a) = ElementDefault (SomeSizedList a)
type Element (HashSet v)
Instance details Defined in Universum.Container.Class type Element (HashSet v) = ElementDefault (HashSet v)
type Element (Vector a)
Instance details Defined in Universum.Container.Class type Element (Vector a) = ElementDefault (Vector a)
type Element (Maybe a)
Instance details Defined in Universum.Container.Class type Element (Maybe a) = ElementDefault (Maybe a)
type Element [a]
Instance details Defined in Universum.Container.Class type Element [a] = ElementDefault [a]
type Element (Either a b)
Instance details Defined in Universum.Container.Class type Element (Either a b) = ElementDefault (Either a b)
type Element (Map k v)
Instance details Defined in Universum.Container.Class type Element (Map k v) = ElementDefault (Map k v)
type Element (BigMap k v)
Instance details Defined in Morley.Michelson.Typed.Haskell.Value type Element (BigMap k v) = ElementDefault (BigMap k v)
type Element (ViewsSet' instr st)
Instance details Defined in Morley.Michelson.Typed.View type Element (ViewsSet' instr st) = Element (Map ViewName (SomeView' instr st))
type Element (SizedList' n a)
Instance details Defined in Morley.Util.SizedList type Element (SizedList' n a) = ElementDefault (SizedList' n a)
type Element (HashMap k v)
Instance details Defined in Universum.Container.Class type Element (HashMap k v) = ElementDefault (HashMap k v)
type Element (a, b)
Instance details Defined in Universum.Container.Class type Element (a, b) = ElementDefault (a, b)
type Element (Const a b)
Instance details Defined in Universum.Container.Class type Element (Const a b) = ElementDefault (Const a b)

class FromList l where #

Type class for data types that can be constructed from a list.

Minimal complete definition

Nothing

Associated Types

type ListElement l #

type ListElement l = Item l

type FromListC l #

type FromListC l = ()

Methods

fromList :: [ListElement l] -> l #

Make a value from list.

For simple types like '[]' and Set:

 toList . fromList ≡ id
 fromList . toList ≡ id

For map-like types:

 toPairs . fromList ≡ id
 fromList . toPairs ≡ id

Instances

Instances details

FromList ByteString
Instance details Defined in Universum.Container.Class Associated Types type ListElement ByteString # type FromListC ByteString # Methods fromList :: [ListElement ByteString] -> ByteString #
FromList ByteString
Instance details Defined in Universum.Container.Class Associated Types type ListElement ByteString # type FromListC ByteString # Methods fromList :: [ListElement ByteString] -> ByteString #
FromList IntSet
Instance details Defined in Universum.Container.Class Associated Types type ListElement IntSet # type FromListC IntSet # Methods fromList :: [ListElement IntSet] -> IntSet #
FromList Text
Instance details Defined in Universum.Container.Class Associated Types type ListElement Text # type FromListC Text # Methods fromList :: [ListElement Text] -> Text #
FromList Text
Instance details Defined in Universum.Container.Class Associated Types type ListElement Text # type FromListC Text # Methods fromList :: [ListElement Text] -> Text #
FromList (ZipList a)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (ZipList a) # type FromListC (ZipList a) # Methods fromList :: [ListElement (ZipList a)] -> ZipList a #
FromList (NonEmpty a)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (NonEmpty a) # type FromListC (NonEmpty a) # Methods fromList :: [ListElement (NonEmpty a)] -> NonEmpty a #
FromList (IntMap v)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (IntMap v) # type FromListC (IntMap v) # Methods fromList :: [ListElement (IntMap v)] -> IntMap v #
FromList (Seq a)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (Seq a) # type FromListC (Seq a) # Methods fromList :: [ListElement (Seq a)] -> Seq a #
Ord a => FromList (Set a)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (Set a) # type FromListC (Set a) # Methods fromList :: [ListElement (Set a)] -> Set a #
FromList (SomeSizedList a)
Instance details Defined in Morley.Util.SizedList Associated Types type ListElement (SomeSizedList a) # type FromListC (SomeSizedList a) # Methods fromList :: [ListElement (SomeSizedList a)] -> SomeSizedList a #
FromList (Vector a)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (Vector a) # type FromListC (Vector a) # Methods fromList :: [ListElement (Vector a)] -> Vector a #
FromList [a]
Instance details Defined in Universum.Container.Class Associated Types type ListElement [a] # type FromListC [a] # Methods fromList :: [ListElement [a]] -> [a] #
Ord k => FromList (Map k v)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (Map k v) # type FromListC (Map k v) # Methods fromList :: [ListElement (Map k v)] -> Map k v #
(Eq k, Hashable k) => FromList (HashMap k v)
Instance details Defined in Universum.Container.Class Associated Types type ListElement (HashMap k v) # type FromListC (HashMap k v) # Methods fromList :: [ListElement (HashMap k v)] -> HashMap k v #

type family ListElement l #

Instances

Instances details

type ListElement ByteString
Instance details Defined in Universum.Container.Class type ListElement ByteString = Word8
type ListElement ByteString
Instance details Defined in Universum.Container.Class type ListElement ByteString = Word8
type ListElement IntSet
Instance details Defined in Universum.Container.Class type ListElement IntSet = Item IntSet
type ListElement Text
Instance details Defined in Universum.Container.Class type ListElement Text = Item Text
type ListElement Text
Instance details Defined in Universum.Container.Class type ListElement Text = Item Text
type ListElement (ZipList a)
Instance details Defined in Universum.Container.Class type ListElement (ZipList a) = a
type ListElement (NonEmpty a)
Instance details Defined in Universum.Container.Class type ListElement (NonEmpty a) = Item (NonEmpty a)
type ListElement (IntMap v)
Instance details Defined in Universum.Container.Class type ListElement (IntMap v) = Item (IntMap v)
type ListElement (Seq a)
Instance details Defined in Universum.Container.Class type ListElement (Seq a) = Item (Seq a)
type ListElement (Set a)
Instance details Defined in Universum.Container.Class type ListElement (Set a) = Item (Set a)
type ListElement (SomeSizedList a)
Instance details Defined in Morley.Util.SizedList type ListElement (SomeSizedList a) = a
type ListElement (Vector a)
Instance details Defined in Universum.Container.Class type ListElement (Vector a) = Item (Vector a)
type ListElement [a]
Instance details Defined in Universum.Container.Class type ListElement [a] = Item [a]
type ListElement (Map k v)
Instance details Defined in Universum.Container.Class type ListElement (Map k v) = Item (Map k v)
type ListElement (HashMap k v)
Instance details Defined in Universum.Container.Class type ListElement (HashMap k v) = Item (HashMap k v)

type family FromListC l #

Instances

Instances details

type FromListC ByteString
Instance details Defined in Universum.Container.Class type FromListC ByteString = ()
type FromListC ByteString
Instance details Defined in Universum.Container.Class type FromListC ByteString = ()
type FromListC IntSet
Instance details Defined in Universum.Container.Class type FromListC IntSet = ()
type FromListC Text
Instance details Defined in Universum.Container.Class type FromListC Text = ()
type FromListC Text
Instance details Defined in Universum.Container.Class type FromListC Text = ()
type FromListC (ZipList a)
Instance details Defined in Universum.Container.Class type FromListC (ZipList a) = ()
type FromListC (NonEmpty a)
Instance details Defined in Universum.Container.Class type FromListC (NonEmpty a) = HasCallStack
type FromListC (IntMap v)
Instance details Defined in Universum.Container.Class type FromListC (IntMap v) = ()
type FromListC (Seq a)
Instance details Defined in Universum.Container.Class type FromListC (Seq a) = ()
type FromListC (Set a)
Instance details Defined in Universum.Container.Class type FromListC (Set a) = ()
type FromListC (SomeSizedList a)
Instance details Defined in Morley.Util.SizedList type FromListC (SomeSizedList a) = ()
type FromListC (Vector a)
Instance details Defined in Universum.Container.Class type FromListC (Vector a) = ()
type FromListC [a]
Instance details Defined in Universum.Container.Class type FromListC [a] = ()
type FromListC (Map k v)
Instance details Defined in Universum.Container.Class type FromListC (Map k v) = ()
type FromListC (HashMap k v)
Instance details Defined in Universum.Container.Class type FromListC (HashMap k v) = ()

class ToPairs t where #

Type class for data types that can be converted to List of Pairs. You can define ToPairs by just defining toPairs function.

But the following laws should be met:

toPairs m ≡ zip (keys m) (elems m)
keys      ≡ map fst . toPairs
elems     ≡ map snd . toPairs

Minimal complete definition

toPairs

Methods

toPairs :: t -> [(Key t, Val t)] #

Converts the structure to the list of the key-value pairs. >>> toPairs (HashMap.fromList [(a, "xxx"), (b, "yyy")]) [(a,"xxx"),(b,"yyy")]

keys :: t -> [Key t] #

Converts the structure to the list of the keys.

>>> keys (HashMap.fromList [('a', "xxx"), ('b', "yyy")])
"ab"

elems :: t -> [Val t] #

Converts the structure to the list of the values.

>>> elems (HashMap.fromList [('a', "xxx"), ('b', "yyy")])
["xxx","yyy"]

Instances

Instances details

ToPairs (NonEmpty (k, v))
Instance details Defined in Universum.Container.Class Associated Types type Key (NonEmpty (k, v)) # type Val (NonEmpty (k, v)) # Methods toPairs :: NonEmpty (k, v) -> [(Key (NonEmpty (k, v)), Val (NonEmpty (k, v)))] # keys :: NonEmpty (k, v) -> [Key (NonEmpty (k, v))] # elems :: NonEmpty (k, v) -> [Val (NonEmpty (k, v))] #
ToPairs (IntMap v)
Instance details Defined in Universum.Container.Class Associated Types type Key (IntMap v) # type Val (IntMap v) # Methods toPairs :: IntMap v -> [(Key (IntMap v), Val (IntMap v))] # keys :: IntMap v -> [Key (IntMap v)] # elems :: IntMap v -> [Val (IntMap v)] #
ToPairs (ViewsSetF a)
Instance details Defined in Morley.Michelson.Internal.ViewsSet Associated Types type Key (ViewsSetF a) # type Val (ViewsSetF a) # Methods toPairs :: ViewsSetF a -> [(Key (ViewsSetF a), Val (ViewsSetF a))] # keys :: ViewsSetF a -> [Key (ViewsSetF a)] # elems :: ViewsSetF a -> [Val (ViewsSetF a)] #
ToPairs [(k, v)]
Instance details Defined in Universum.Container.Class Associated Types type Key [(k, v)] # type Val [(k, v)] # Methods toPairs :: [(k, v)] -> [(Key [(k, v)], Val [(k, v)])] # keys :: [(k, v)] -> [Key [(k, v)]] # elems :: [(k, v)] -> [Val [(k, v)]] #
ToPairs (Map k v)
Instance details Defined in Universum.Container.Class Associated Types type Key (Map k v) # type Val (Map k v) # Methods toPairs :: Map k v -> [(Key (Map k v), Val (Map k v))] # keys :: Map k v -> [Key (Map k v)] # elems :: Map k v -> [Val (Map k v)] #
ToPairs (HashMap k v)
Instance details Defined in Universum.Container.Class Associated Types type Key (HashMap k v) # type Val (HashMap k v) # Methods toPairs :: HashMap k v -> [(Key (HashMap k v), Val (HashMap k v))] # keys :: HashMap k v -> [Key (HashMap k v)] # elems :: HashMap k v -> [Val (HashMap k v)] #

flipfoldl' :: (Container t, Element t ~ a) => (a -> b -> b) -> b -> t -> b #

Similar to foldl' but takes a function with its arguments flipped.

>>> flipfoldl' (/) 5 [2,3] :: Rational
15 % 2

sum :: (Container t, Num (Element t)) => t -> Element t #

Stricter version of sum.

>>> sum [1..10]
55
>>> sum (Just 3)
...
    • Do not use 'Foldable' methods on Maybe
      Suggestions:
          Instead of
              for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
          use
              whenJust  :: Applicative f => Maybe a    -> (a -> f ()) -> f ()
              whenRight :: Applicative f => Either l r -> (r -> f ()) -> f ()
...
          Instead of
              fold :: (Foldable t, Monoid m) => t m -> m
          use
              maybeToMonoid :: Monoid m => Maybe m -> m
...

product :: (Container t, Num (Element t)) => t -> Element t #

Stricter version of product.

>>> product [1..10]
3628800
>>> product (Right 3)
...
    • Do not use 'Foldable' methods on Either
      Suggestions:
          Instead of
              for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
          use
              whenJust  :: Applicative f => Maybe a    -> (a -> f ()) -> f ()
              whenRight :: Applicative f => Either l r -> (r -> f ()) -> f ()
...
          Instead of
              fold :: (Foldable t, Monoid m) => t m -> m
          use
              maybeToMonoid :: Monoid m => Maybe m -> m
...

traverse_ :: (Container t, Applicative f) => (Element t -> f b) -> t -> f () #

Constrained to Container version of traverse_.

>>> traverse_ putTextLn ["foo", "bar"]
foo
bar

for_ :: (Container t, Applicative f) => t -> (Element t -> f b) -> f () #

Constrained to Container version of for_.

>>> for_ [1 .. 5 :: Int] $ \i -> when (even i) (print i)
2
4

mapM_ :: (Container t, Monad m) => (Element t -> m b) -> t -> m () #

Constrained to Container version of mapM_.

>>> mapM_ print [True, False]
True
False

forM_ :: (Container t, Monad m) => t -> (Element t -> m b) -> m () #

Constrained to Container version of forM_.

>>> forM_ [True, False] print
True
False

sequenceA_ :: (Container t, Applicative f, Element t ~ f a) => t -> f () #

Constrained to Container version of sequenceA_.

>>> sequenceA_ [putTextLn "foo", print True]
foo
True

sequence_ :: (Container t, Monad m, Element t ~ m a) => t -> m () #

Constrained to Container version of sequence_.

>>> sequence_ [putTextLn "foo", print True]
foo
True

asum :: (Container t, Alternative f, Element t ~ f a) => t -> f a #

Constrained to Container version of asum.

>>> asum [Nothing, Just [False, True], Nothing, Just [True]]
Just [False,True]

concatMapM :: (Applicative f, Monoid m, Container (l m), Element (l m) ~ m, Traversable l) => (a -> f m) -> l a -> f m #

Lifting bind into a monad. Generalized version of concatMap that works with a monadic predicate. Old and simpler specialized to list version had next type:

concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]

Side note: previously it had type

concatMapM :: (Applicative q, Monad m, Traversable m)
           => (a -> q (m b)) -> m a -> q (m b)

Such signature didn't allow to use this function when traversed container type and type of returned by function-argument differed. Now you can use it like e.g.

concatMapM readFile files >>= putTextLn

concatForM :: (Applicative f, Monoid m, Container (l m), Element (l m) ~ m, Traversable l) => l a -> (a -> f m) -> f m #

Like concatMapM, but has its arguments flipped, so can be used instead of the common fmap concat $ forM pattern.

andM :: (Container f, Element f ~ m Bool, Monad m) => f -> m Bool #

Monadic and constrained to Container version of and.

>>> andM [Just True, Just False]
Just False
>>> andM [Just True]
Just True
>>> andM [Just True, Just False, Nothing]
Just False
>>> andM [Just True, Nothing]
Nothing
>>> andM [putTextLn "1" >> pure True, putTextLn "2" >> pure False, putTextLn "3" >> pure True]
1
2
False

orM :: (Container f, Element f ~ m Bool, Monad m) => f -> m Bool #

Monadic and constrained to Container version of or.

>>> orM [Just True, Just False]
Just True
>>> orM [Just True, Nothing]
Just True
>>> orM [Nothing, Just True]
Nothing

allM :: (Container f, Monad m) => (Element f -> m Bool) -> f -> m Bool #

Monadic and constrained to Container version of all.

>>> allM (readMaybe >=> pure . even) ["6", "10"]
Just True
>>> allM (readMaybe >=> pure . even) ["5", "aba"]
Just False
>>> allM (readMaybe >=> pure . even) ["aba", "10"]
Nothing

anyM :: (Container f, Monad m) => (Element f -> m Bool) -> f -> m Bool #

Monadic and constrained to Container version of any.

>>> anyM (readMaybe >=> pure . even) ["5", "10"]
Just True
>>> anyM (readMaybe >=> pure . even) ["10", "aba"]
Just True
>>> anyM (readMaybe >=> pure . even) ["aba", "10"]
Nothing

uncons :: [a] -> Maybe (a, [a]) #

Destructuring list into its head and tail if possible. This function is total.

>>> uncons []
Nothing
>>> uncons [1..5]
Just (1,[2,3,4,5])
>>> uncons (5 : [1..5]) >>= \(f, l) -> pure $ f == length l
Just True

whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f () #

Performs given action over NonEmpty list if given list is non empty.

>>> whenNotNull [] $ \(b :| _) -> print (not b)
>>> whenNotNull [False,True] $ \(b :| _) -> print (not b)
True

whenNotNullM :: Monad m => m [a] -> (NonEmpty a -> m ()) -> m () #

Monadic version of whenNotNull.

foldl1 :: (a -> a -> a) -> NonEmpty a -> a #

A variant of foldl that has no base case, and thus may only be applied to NonEmpty.

>>> foldl1 (+) (1 :| [2,3,4,5])
15

foldr1 :: (a -> a -> a) -> NonEmpty a -> a #

A variant of foldr that has no base case, and thus may only be applied to NonEmpty.

>>> foldr1 (+) (1 :| [2,3,4,5])
15

minimumBy :: (a -> a -> Ordering) -> NonEmpty a -> a #

The least element of a NonEmpty with respect to the given comparison function.

minimum :: Ord a => NonEmpty a -> a #

The least element of a NonEmpty.

>>> minimum (1 :| [2,3,4,5])
1

maximumBy :: (a -> a -> Ordering) -> NonEmpty a -> a #

The largest element of a NonEmpty with respect to the given comparison function.

maximum :: Ord a => NonEmpty a -> a #

The largest element of a NonEmpty.

>>> maximum (1 :| [2,3,4,5])
5

data Bug #

Type that represents exceptions used in cases when a particular codepath is not meant to be ever executed, but happens to be executed anyway.

Constructors

Bug SomeException CallStack

Instances

Instances details

Exception Bug
Instance details Defined in Universum.Exception Methods toException :: Bug -> SomeException # fromException :: SomeException -> Maybe Bug # displayException :: Bug -> String #
Show Bug
Instance details Defined in Universum.Exception Methods showsPrec :: Int -> Bug -> ShowS # show :: Bug -> String # showList :: [Bug] -> ShowS #

pattern Exc :: Exception e => e -> SomeException #

Pattern synonym to easy pattern matching on exceptions. So intead of writing something like this:

isNonCriticalExc e
    | Just (_ :: NodeAttackedError) <- fromException e = True
    | Just DialogUnexpected{} <- fromException e = True
    | otherwise = False

you can use Exc pattern synonym:

isNonCriticalExc = case
    Exc (_ :: NodeAttackedError) -> True  -- matching all exceptions of type NodeAttackedError
    Exc DialogUnexpected{} -> True
    _ -> False

This pattern is bidirectional. You can use Exc e instead of toException e.

bug :: (HasCallStack, Exception e) => e -> a #

Generate a pure value which, when forced, will synchronously throw the exception wrapped into Bug data type.

note :: MonadError e m => e -> Maybe a -> m a #

Throws error for Maybe if Nothing is given. Operates over MonadError.

evaluateWHNF :: MonadIO m => a -> m a #

Lifted alias for evaluate with clearer name.

evaluateWHNF_ :: MonadIO m => a -> m () #

Like evaluateWNHF but discards value.

evaluateNF :: (NFData a, MonadIO m) => a -> m a #

Alias for evaluateWHNF . force with clearer name.

evaluateNF_ :: (NFData a, MonadIO m) => a -> m () #

Alias for evaluateWHNF . rnf. Similar to evaluateNF but discards resulting value.

whenM :: Monad m => m Bool -> m () -> m () #

Monadic version of when.

>>> whenM (pure False) $ putTextLn "No text :("
>>> whenM (pure True)  $ putTextLn "Yes text :)"
Yes text :)
>>> whenM (Just True) (pure ())
Just ()
>>> whenM (Just False) (pure ())
Just ()
>>> whenM Nothing (pure ())
Nothing

unlessM :: Monad m => m Bool -> m () -> m () #

Monadic version of unless.

>>> unlessM (pure False) $ putTextLn "No text :("
No text :(
>>> unlessM (pure True) $ putTextLn "Yes text :)"

ifM :: Monad m => m Bool -> m a -> m a -> m a #

Monadic version of if-then-else.

>>> ifM (pure True) (putTextLn "True text") (putTextLn "False text")
True text

guardM :: MonadPlus m => m Bool -> m () #

Monadic version of guard. Occasionally useful. Here some complex but real-life example:

findSomePath :: IO (Maybe FilePath)

somePath :: MaybeT IO FilePath
somePath = do
    path <- MaybeT findSomePath
    guardM $ liftIO $ doesDirectoryExist path
    return path

ordNub :: Ord a => [a] -> [a] #

Like nub but runs in O(n * log n) time and requires Ord.

>>> ordNub [3, 3, 3, 2, 2, -1, 1]
[3,2,-1,1]

hashNub :: (Eq a, Hashable a) => [a] -> [a] #

Like nub but runs in O(n * log_16(n)) time and requires Hashable.

>>> hashNub [3, 3, 3, 2, 2, -1, 1]
[3,2,-1,1]

sortNub :: Ord a => [a] -> [a] #

Like ordNub but also sorts a list.

>>> sortNub [3, 3, 3, 2, 2, -1, 1]
[-1,1,2,3]

unstableNub :: (Eq a, Hashable a) => [a] -> [a] #

Like hashNub but has better performance and also doesn't save the order.

>>> unstableNub [3, 3, 3, 2, 2, -1, 1]
[1,2,3,-1]

class Print a #

Support class to overload writing of string like values.

Minimal complete definition

hPutStr, hPutStrLn

Instances

Instances details

Print ByteString
Instance details Defined in Universum.Print.Internal Methods hPutStr :: Handle -> ByteString -> IO () # hPutStrLn :: Handle -> ByteString -> IO () #
Print ByteString
Instance details Defined in Universum.Print.Internal Methods hPutStr :: Handle -> ByteString -> IO () # hPutStrLn :: Handle -> ByteString -> IO () #
Print Text
Instance details Defined in Universum.Print.Internal Methods hPutStr :: Handle -> Text -> IO () # hPutStrLn :: Handle -> Text -> IO () #
Print Text
Instance details Defined in Universum.Print.Internal Methods hPutStr :: Handle -> Text -> IO () # hPutStrLn :: Handle -> Text -> IO () #
Print [Char]
Instance details Defined in Universum.Print.Internal Methods hPutStr :: Handle -> [Char] -> IO () # hPutStrLn :: Handle -> [Char] -> IO () #

hPutStr :: (Print a, MonadIO m) => Handle -> a -> m () #

Write a string like value a to a supplied Handle.

hPutStrLn :: (Print a, MonadIO m) => Handle -> a -> m () #

Write a string like value a to a supplied Handle, appending a newline character.

putStr :: (Print a, MonadIO m) => a -> m () #

Write a string like value to stdout/.

putStrLn :: (Print a, MonadIO m) => a -> m () #

Write a string like value to stdout appending a newline character.

print :: forall a m. (MonadIO m, Show a) => a -> m () #

Lifted version of print.

hPrint :: (MonadIO m, Show a) => Handle -> a -> m () #

Lifted version of hPrint

putText :: MonadIO m => Text -> m () #

Specialized to Text version of putStr or forcing type inference.

putTextLn :: MonadIO m => Text -> m () #

Specialized to Text version of putStrLn or forcing type inference.

putLText :: MonadIO m => Text -> m () #

Specialized to Text version of putStr or forcing type inference.

putLTextLn :: MonadIO m => Text -> m () #

Specialized to Text version of putStrLn or forcing type inference.

data Undefined #

Similar to undefined but data type.

Constructors

Undefined

Instances

Instances details

Data Undefined
Instance details Defined in Universum.Debug Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Undefined -> c Undefined # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Undefined # toConstr :: Undefined -> Constr # dataTypeOf :: Undefined -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Undefined) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Undefined) # gmapT :: (forall b. Data b => b -> b) -> Undefined -> Undefined # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Undefined -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Undefined -> r # gmapQ :: (forall d. Data d => d -> u) -> Undefined -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Undefined -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Undefined -> m Undefined # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Undefined -> m Undefined # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Undefined -> m Undefined #
Bounded Undefined
Instance details Defined in Universum.Debug Methods minBound :: Undefined # maxBound :: Undefined #
Enum Undefined
Instance details Defined in Universum.Debug Methods succ :: Undefined -> Undefined # pred :: Undefined -> Undefined # toEnum :: Int -> Undefined # fromEnum :: Undefined -> Int # enumFrom :: Undefined -> [Undefined] # enumFromThen :: Undefined -> Undefined -> [Undefined] # enumFromTo :: Undefined -> Undefined -> [Undefined] # enumFromThenTo :: Undefined -> Undefined -> Undefined -> [Undefined] #
Generic Undefined
Instance details Defined in Universum.Debug Associated Types type Rep Undefined :: Type -> Type # Methods from :: Undefined -> Rep Undefined x # to :: Rep Undefined x -> Undefined #
Read Undefined
Instance details Defined in Universum.Debug Methods readsPrec :: Int -> ReadS Undefined # readList :: ReadS [Undefined] # readPrec :: ReadPrec Undefined # readListPrec :: ReadPrec [Undefined] #
Show Undefined
Instance details Defined in Universum.Debug Methods showsPrec :: Int -> Undefined -> ShowS # show :: Undefined -> String # showList :: [Undefined] -> ShowS #
Eq Undefined
Instance details Defined in Universum.Debug Methods (==) :: Undefined -> Undefined -> Bool # (/=) :: Undefined -> Undefined -> Bool #
Ord Undefined
Instance details Defined in Universum.Debug Methods compare :: Undefined -> Undefined -> Ordering # (<) :: Undefined -> Undefined -> Bool # (<=) :: Undefined -> Undefined -> Bool # (>) :: Undefined -> Undefined -> Bool # (>=) :: Undefined -> Undefined -> Bool # max :: Undefined -> Undefined -> Undefined # min :: Undefined -> Undefined -> Undefined #
type Rep Undefined
Instance details Defined in Universum.Debug type Rep Undefined = D1 ('MetaData "Undefined" "Universum.Debug" "universum-1.7.3-59c527371c359af1add04ae53203790f44f68f61ceeb07825dd237ce65fcd14f" 'False) (C1 ('MetaCons "Undefined" 'PrefixI 'False) (U1 :: Type -> Type))

trace :: Text -> a -> a #

Version of trace that leaves a warning and takes Text.

traceShow :: Show a => a -> b -> b #

Version of traceShow that leaves a warning.

traceShowId :: Show a => a -> a #

Version of traceShowId that leaves a warning.

traceIdWith :: (a -> Text) -> a -> a #

Version of traceId that leaves a warning. Useful to tag printed data, for instance:

traceIdWith (x -> "My data: " <> show x) (veryLargeExpression)

This is especially useful with custom formatters:

traceIdWith (x -> "My data: " <> pretty x) (veryLargeExpression)

traceShowIdWith :: Show s => (a -> s) -> a -> a #

Version of traceShowId that leaves a warning. Useful to tag printed data, for instance:

traceShowIdWith ("My data: ", ) (veryLargeExpression)

traceShowM :: (Show a, Monad m) => a -> m () #

Version of traceShowM that leaves a warning.

traceM :: Monad m => Text -> m () #

Version of traceM that leaves a warning and takes Text.

traceId :: Text -> Text #

Version of traceId that leaves a warning.

class ToString a where #

Type class for converting other strings to String.

Methods

toString :: a -> String #

Instances

Instances details

ToString Text
Instance details Defined in Universum.String.Conversion Methods toString :: Text -> String #
ToString Text
Instance details Defined in Universum.String.Conversion Methods toString :: Text -> String #
ToString String
Instance details Defined in Universum.String.Conversion Methods toString :: String -> String #

class ToLText a where #

Type class for converting other strings to Text.

Methods

toLText :: a -> Text #

Instances

Instances details

ToLText Text
Instance details Defined in Universum.String.Conversion Methods toLText :: Text -> Text0 #
ToLText Text
Instance details Defined in Universum.String.Conversion Methods toLText :: Text -> Text #
ToLText String
Instance details Defined in Universum.String.Conversion Methods toLText :: String -> Text #

class ToText a where #

Type class for converting other strings to Text.

Methods

toText :: a -> Text #

Instances

Instances details

ToText MText
Instance details Defined in Morley.Michelson.Text Methods toText :: MText -> Text #
ToText Text
Instance details Defined in Universum.String.Conversion Methods toText :: Text -> Text #
ToText Text
Instance details Defined in Universum.String.Conversion Methods toText :: Text -> Text0 #
ToText String
Instance details Defined in Universum.String.Conversion Methods toText :: String -> Text #

class ConvertUtf8 a b where #

Type class for conversion to utf8 representation of text.

Methods

encodeUtf8 :: a -> b #

Encode as utf8 string (usually ByteString).

>>> encodeUtf8 @Text @ByteString "патак"
"\208\191\208\176\209\130\208\176\208\186"

decodeUtf8 :: b -> a #

Decode from utf8 string.

>>> decodeUtf8 @Text @ByteString "\208\191\208\176\209\130\208\176\208\186"
"\1087\1072\1090\1072\1082"
>>> putStrLn $ decodeUtf8 @Text @ByteString "\208\191\208\176\209\130\208\176\208\186"
патак

decodeUtf8Strict :: b -> Either UnicodeException a #

Decode as utf8 string but returning execption if byte sequence is malformed.

>>> decodeUtf8 @Text @ByteString "\208\208\176\209\130\208\176\208\186"
"\65533\1072\1090\1072\1082"

>>> decodeUtf8Strict @Text @ByteString "\208\208\176\209\130\208\176\208\186"
Left Cannot decode byte '\xd0': Data.Text.Internal.Encoding.decodeUtf8: Invalid UTF-8 stream

Instances

Instances details

ConvertUtf8 Text ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: Text -> ByteString # decodeUtf8 :: ByteString -> Text # decodeUtf8Strict :: ByteString -> Either UnicodeException Text #
ConvertUtf8 Text ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: Text -> ByteString # decodeUtf8 :: ByteString -> Text # decodeUtf8Strict :: ByteString -> Either UnicodeException Text #
ConvertUtf8 Text ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: Text -> ByteString # decodeUtf8 :: ByteString -> Text # decodeUtf8Strict :: ByteString -> Either UnicodeException Text #
ConvertUtf8 Text ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: Text -> ByteString # decodeUtf8 :: ByteString -> Text # decodeUtf8Strict :: ByteString -> Either UnicodeException Text #
ConvertUtf8 String ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: String -> ByteString # decodeUtf8 :: ByteString -> String # decodeUtf8Strict :: ByteString -> Either UnicodeException String #
ConvertUtf8 String ByteString
Instance details Defined in Universum.String.Conversion Methods encodeUtf8 :: String -> ByteString # decodeUtf8 :: ByteString -> String # decodeUtf8Strict :: ByteString -> Either UnicodeException String #

type LByteString = ByteString #

Type synonym for ByteString.

type LText = Text #

Type synonym for Text.

readEither :: (ToString a, Read b) => a -> Either Text b #

Polymorhpic version of readEither.

>>> readEither @Text @Int "123"
Right 123
>>> readEither @Text @Int "aa"
Left "Prelude.read: no parse"

type With (a :: [k -> Constraint]) (b :: k) = a <+> b #

Map several constraints over a single variable. Note, that With a b ≡ Each a '[b]

a :: With [Show, Read] a => a -> a
=
a :: (Show a, Read a) => a -> a

class SuperComposition a b c | a b -> c where #

This type class allows to implement variadic composition operator.

Methods

(...) :: a -> b -> c infixl 8 #

Allows to apply function to result of another function with multiple arguments.

>>> (show ... (+)) 1 2
"3"
>>> show ... 5
"5"
>>> (null ... zip5) [1] [2] [3] [] [5]
True

Inspired by http://stackoverflow.com/questions/9656797/variadic-compose-function.

Performance

To check the performance there was done a bunch of benchmarks. Benchmarks were made on examples given above and also on the functions of many arguments. The results are showing that the operator (...) performs as fast as plain applications of the operator (.) on almost all the tests, but (...) leads to the performance draw-down if ghc fails to inline it. Slow behavior was noticed on functions without type specifications. That's why keep in mind that providing explicit type declarations for functions is very important when using (...). Relying on type inference will lead to the situation when all optimizations disappear due to very general inferred type. However, functions without type specification but with applied INLINE pragma are fast again.

Instances

Instances details

(a ~ c, r ~ b) => SuperComposition (a -> b) c r
Instance details Defined in Universum.VarArg Methods (...) :: (a -> b) -> c -> r #
(SuperComposition (a -> b) d r1, r ~ (c -> r1)) => SuperComposition (a -> b) (c -> d) r
Instance details Defined in Universum.VarArg Methods (...) :: (a -> b) -> (c -> d) -> r #

exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a #

Convert a ExceptT computation to MaybeT, discarding the value of any exception.

maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a #

Convert a MaybeT computation to ExceptT, with a default exception value.

lenientDecode :: OnDecodeError #

Replace an invalid input byte with the Unicode replacement character U+FFFD.

strictDecode :: OnDecodeError #

Throw a UnicodeException if decoding fails.

type OnDecodeError = OnError Word8 Char #

A handler for a decoding error.

type OnError a b = String -> Maybe a -> Maybe b #

Function type for handling a coding error. It is supplied with two inputs:

A String that describes the error.
The input value that caused the error. If the error arose because the end of input was reached or could not be identified precisely, this value will be Nothing.

If the handler returns a value wrapped with Just, that value will be used in the output as the replacement for the invalid input. If it returns Nothing, no value will be used in the output.

Should the handler need to abort processing, it should use error or throw an exception (preferably a UnicodeException). It may use the description provided to construct a more helpful error report.

data UnicodeException #

An exception type for representing Unicode encoding errors.

Instances

Instances details

Exception UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods toException :: UnicodeException -> SomeException # fromException :: SomeException -> Maybe UnicodeException # displayException :: UnicodeException -> String #
Show UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods showsPrec :: Int -> UnicodeException -> ShowS # show :: UnicodeException -> String # showList :: [UnicodeException] -> ShowS #
NFData UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods rnf :: UnicodeException -> () #
Eq UnicodeException
Instance details Defined in Data.Text.Encoding.Error Methods (==) :: UnicodeException -> UnicodeException -> Bool # (/=) :: UnicodeException -> UnicodeException -> Bool #
type PrettyShow UnicodeException
Instance details Defined in Morley.Prelude.Show type PrettyShow UnicodeException = ()

decodeUtf8' :: ByteString -> Either UnicodeException Text #

Decode a ByteString containing UTF-8 encoded text.

If the input contains any invalid UTF-8 data, the relevant exception will be returned, otherwise the decoded text.

decodeUtf8With :: OnDecodeError -> ByteString -> Text #

Decode a ByteString containing UTF-8 encoded text.

NOTE: The replacement character returned by OnDecodeError MUST be within the BMP plane; surrogate code points will automatically be remapped to the replacement char U+FFFD (since 0.11.3.0), whereas code points beyond the BMP will throw an error (since 1.2.3.1); For earlier versions of text using those unsupported code points would result in undefined behavior.

lines :: Text -> [Text] #

O(n) Breaks a Text up into a list of Texts at newline Chars. The resulting strings do not contain newlines.

unlines :: [Text] -> Text #

O(n) Joins lines, after appending a terminating newline to each.

unwords :: [Text] -> Text #

O(n) Joins words using single space characters.

words :: Text -> [Text] #

O(n) Breaks a Text up into a list of words, delimited by Chars representing white space.

fromStrict :: Text -> Text #

O(c) Convert a strict Text into a lazy Text.

modifyTVar' :: TVar a -> (a -> a) -> STM () #

Strict version of modifyTVar.

Since: stm-2.3

throwM :: (MonadThrow m, Exception e) => e -> m a #

Synonym for throw