Safe Haskell	Safe-Inferred
Language	Haskell2010

LiveCoding

Synopsis

class Typeable a => Data a where
- gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> a -> c a
- gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a
- toConstr :: a -> Constr
- dataTypeOf :: a -> DataType
- dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c a)
- dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a)
- gmapT :: (forall b. Data b => b -> b) -> a -> a
- gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
- gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
- gmapQ :: (forall d. Data d => d -> u) -> a -> [u]
- gmapQi :: Int -> (forall d. Data d => d -> u) -> a -> u
- gmapM :: Monad m => (forall d. Data d => d -> m d) -> a -> m a
- gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
- gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
class Typeable (a :: k)
data TyCon
data Fixity
- = Prefix
- | Infix
data DataType
data DataRep
- = AlgRep [Constr]
- | IntRep
- | FloatRep
- | CharRep
- | NoRep
data ConstrRep
- = AlgConstr ConIndex
- | IntConstr Integer
- | FloatConstr Rational
- | CharConstr Char
data Constr
type ConIndex = Int
tyconUQname :: String -> String
tyconModule :: String -> String
showConstr :: Constr -> String
repConstr :: DataType -> ConstrRep -> Constr
readConstr :: DataType -> String -> Maybe Constr
mkRealConstr :: (Real a, Show a) => DataType -> a -> Constr
mkNoRepType :: String -> DataType
mkIntegralConstr :: (Integral a, Show a) => DataType -> a -> Constr
mkIntType :: String -> DataType
mkFloatType :: String -> DataType
mkDataType :: String -> [Constr] -> DataType
mkConstrTag :: DataType -> String -> Int -> [String] -> Fixity -> Constr
mkConstr :: DataType -> String -> [String] -> Fixity -> Constr
mkCharType :: String -> DataType
mkCharConstr :: DataType -> Char -> Constr
maxConstrIndex :: DataType -> ConIndex
isNorepType :: DataType -> Bool
isAlgType :: DataType -> Bool
indexConstr :: DataType -> ConIndex -> Constr
fromConstrM :: (Monad m, Data a) => (forall d. Data d => m d) -> Constr -> m a
fromConstrB :: Data a => (forall d. Data d => d) -> Constr -> a
fromConstr :: Data a => Constr -> a
dataTypeRep :: DataType -> DataRep
dataTypeName :: DataType -> String
dataTypeConstrs :: DataType -> [Constr]
constrType :: Constr -> DataType
constrRep :: Constr -> ConstrRep
constrIndex :: Constr -> ConIndex
constrFixity :: Constr -> Fixity
constrFields :: Constr -> [String]
newtype Kleisli (m :: Type -> Type) a b = Kleisli {
- runKleisli :: a -> m b
}
class Arrow a => ArrowZero (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) where
- zeroArrow :: a b c
class ArrowZero a => ArrowPlus (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) where
- (<+>) :: a b c -> a b c -> a b c
newtype ArrowMonad (a :: Type -> Type -> Type) b = ArrowMonad (a () b)
class Arrow a => ArrowLoop (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) where
- loop :: a (b, d) (c, d) -> a b c
class Arrow a => ArrowChoice (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) where
- left :: a b c -> a (Either b d) (Either c d)
- right :: a b c -> a (Either d b) (Either d c)
- (+++) :: a b c -> a b' c' -> a (Either b b') (Either c c')
- (|||) :: a b d -> a c d -> a (Either b c) d
class Arrow a => ArrowApply (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type)
class Category a => Arrow (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) where
- arr :: (b -> c) -> a b c
- first :: a b c -> a (b, d) (c, d)
- second :: a b c -> a (d, b) (d, c)
- (***) :: a b c -> a b' c' -> a (b, b') (c, c')
- (&&&) :: a b c -> a b c' -> a b (c, c')
returnA :: Arrow a => a b b
leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d)
(^>>) :: Arrow a => (b -> c) -> a c d -> a b d
(^<<) :: Arrow a => (c -> d) -> a b c -> a b d
(>>^) :: Arrow a => a b c -> (c -> d) -> a b d
(<<^) :: Arrow a => a c d -> (b -> c) -> a b d
type TypeRep = SomeTypeRep
typeRepTyCon :: TypeRep -> TyCon
typeRepFingerprint :: TypeRep -> Fingerprint
typeRepArgs :: TypeRep -> [TypeRep]
typeRep :: forall {k} proxy (a :: k). Typeable a => proxy a -> TypeRep
typeOf7 :: Typeable t => t a b c d e f g -> TypeRep
typeOf6 :: Typeable t => t a b c d e f -> TypeRep
typeOf5 :: Typeable t => t a b c d e -> TypeRep
typeOf4 :: Typeable t => t a b c d -> TypeRep
typeOf3 :: Typeable t => t a b c -> TypeRep
typeOf2 :: Typeable t => t a b -> TypeRep
typeOf1 :: Typeable t => t a -> TypeRep
typeOf :: Typeable a => a -> TypeRep
splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
showsTypeRep :: TypeRep -> ShowS
rnfTypeRep :: TypeRep -> ()
mkFunTy :: TypeRep -> TypeRep -> TypeRep
gcast2 :: forall {k1} {k2} {k3} c (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))
gcast1 :: forall {k1} {k2} c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))
gcast :: forall {k} (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b)
funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep
eqT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b)
cast :: (Typeable a, Typeable b) => a -> Maybe b
tyConPackage :: TyCon -> String
tyConName :: TyCon -> String
tyConModule :: TyCon -> String
tyConFingerprint :: TyCon -> Fingerprint
trLiftedRep :: TypeRep ('BoxedRep 'Lifted)
rnfTyCon :: TyCon -> ()
data Proxy (t :: k) = Proxy
(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
data (a :: k1) :~~: (b :: k2) where
- HRefl :: forall {k1} (a :: k1). a :~~: a
data (a :: k) :~: (b :: k) where
- Refl :: forall {k} (a :: k). a :~: a
newtype ExceptT e (m :: Type -> Type) a = ExceptT (m (Either e a))
mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b
mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b
runExcept :: Except e a -> Either e a
runExceptT :: ExceptT e m a -> m (Either e a)
withExcept :: (e -> e') -> Except e a -> Except e' a
withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a
type Except e = ExceptT e Identity
throwE :: forall (m :: Type -> Type) e a. Monad m => e -> ExceptT e m a
liftPass :: Monad m => Pass w m (Either e a) -> Pass w (ExceptT e m) a
liftListen :: Monad m => Listen w m (Either e a) -> Listen w (ExceptT e m) a
liftCallCC :: CallCC m (Either e a) (Either e b) -> CallCC (ExceptT e m) a b
except :: forall (m :: Type -> Type) e a. Monad m => Either e a -> ExceptT e m a
catchE :: forall (m :: Type -> Type) e a e'. Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a
data LiveProgram m = forall s.Data s => LiveProgram {
- liveState :: s
- liveStep :: s -> m s
}
hoistLiveProgram :: (forall a. m1 a -> m2 a) -> LiveProgram m1 -> LiveProgram m2
data Choice stateL stateR = Choice {
- choiceLeft :: stateL
- choiceRight :: stateR
}
data Parallel stateP1 stateP2 = Parallel {
- stateP1 :: stateP1
- stateP2 :: stateP2
}
type Actuator b = Cell IO b ()
type SF a b = forall m. Cell m a b
type Sensor a = Cell IO () a
data Composition state1 state2 = Composition {
- state1 :: state1
- state2 :: state2
}
data Cell m a b
- = forall s.Data s => Cell {
  - cellState :: s
  - cellStep :: s -> a -> m (b, s)
  }
- | ArrM {
  - runArrM :: a -> m b
  }
toCell :: Functor m => Cell m a b -> Cell m a b
step :: Monad m => Cell m a b -> a -> m (b, Cell m a b)
steps :: Monad m => Cell m a b -> [a] -> m ([b], Cell m a b)
sumC :: (Monad m, Num a, Data a) => Cell m a a
liveCell :: Monad m => Cell m () () -> LiveProgram m
toLiveCell :: Functor m => LiveProgram m -> Cell m () ()
hoistCell :: (forall x. m1 x -> m2 x) -> Cell m1 a b -> Cell m2 a b
buildProg :: Sensor a -> SF a b -> Actuator b -> LiveProgram IO
stepRate :: Num a => a
integrate :: (Data a, Fractional a, Monad m) => Cell m a a
localTime :: (Data a, Fractional a, Monad m) => Cell m b a
liftCell :: (Monad m, MonadTrans t) => Cell m a b -> Cell (t m) a b
arrM :: (a -> m b) -> Cell m a b
constM :: m b -> Cell m a b
constC :: Monad m => b -> Cell m a b
sine :: MonadFix m => Double -> Cell m () Double
asciiArt :: Double -> String
printEverySecond :: Cell IO String ()
printSine :: Double -> LiveProgram IO
newtype CountObserver = CountObserver {
- observe :: IO Integer
}
data Debugging dbgState state = Debugging {
- state :: state
- dbgState :: dbgState
}
newtype Debugger m = Debugger {
- getDebugger :: forall s. Data s => LiveProgram (StateT s m)
}
getC :: Monad m => Cell (StateT s m) a s
putC :: Monad m => Cell (StateT s m) s ()
gshowDebugger :: Debugger IO
withDebugger :: Monad m => LiveProgram m -> Debugger m -> LiveProgram m
withDebuggerC :: Monad m => Cell m a b -> Debugger m -> Cell m a b
countDebugger :: IO (Debugger IO, CountObserver)
await :: CountObserver -> Integer -> IO ()
data Alg m a b where
- Alg :: s -> AlgStructure m a b s -> Alg m a b
type AlgStructure m a b s = StateTransition m a b s -> s
data Coalg m a b where
- Coalg :: s -> (s -> StateTransition m a b s) -> Coalg m a b
data MSF m a b = MSF {
- unMSF :: StateTransition m a b (MSF m a b)
}
type StateTransition m a b s = a -> m (b, s)
finality :: Monad m => Coalg m a b -> MSF m a b
finalityC :: Monad m => Cell m a b -> MSF m a b
coalgebra :: MSF m a b -> Coalg m a b
coalgebraC :: Data (MSF m a b) => MSF m a b -> Cell m a b
algMSF :: MSF m a b -> Alg m a b
initiality :: Functor m => AlgStructure m a b s -> MSF m a b -> s
hoistCellOutput :: (Monad m1, Monad m2) => (forall s. m1 (b1, s) -> m2 (b2, s)) -> Cell m1 a b1 -> Cell m2 a b2
hoistCellKleisli_ :: (Monad m1, Monad m2) => (forall s. (a1 -> m1 (b1, s)) -> a2 -> m2 (b2, s)) -> Cell m1 a1 b1 -> Cell m2 a2 b2
hoistCellKleisli :: (Monad m1, Monad m2) => (forall s. (s -> a1 -> m1 (b1, s)) -> s -> a2 -> m2 (b2, s)) -> Cell m1 a1 b1 -> Cell m2 a2 b2
hoistCellKleisliStateChange :: (Monad m1, Monad m2, forall s. Data s => Data (t s)) => (forall s. (s -> a1 -> m1 (b1, s)) -> t s -> a2 -> m2 (b2, t s)) -> (forall s. s -> t s) -> Cell m1 a1 b1 -> Cell m2 a2 b2
resample :: (Monad m, KnownNat n) => Cell m a b -> Cell m (Vector n a) (Vector n b)
resampleList :: Monad m => Cell m a b -> Cell m [a] [b]
resampleMaybe :: Monad m => Cell m a b -> Cell m (Maybe a) (Maybe b)
resampleListPar :: Monad m => Cell m a b -> Cell m [a] [b]
stateT :: State stateT stateInternal -> stateT
stateInternal :: State stateT stateInternal -> stateInternal
runStateC :: (Data stateT, Monad m) => Cell (StateT stateT m) a b -> stateT -> Cell m a (b, stateT)
runStateC_ :: (Data stateT, Monad m) => Cell (StateT stateT m) a b -> stateT -> Cell m a b
runReaderC :: r -> Cell (ReaderT r m) a b -> Cell m a b
runReaderC' :: Monad m => Cell (ReaderT r m) a b -> Cell m (r, a) b
runWriterC :: (Monoid w, Monad m) => Cell (WriterT w m) a b -> Cell m a (w, b)
class GFinite f where
- gcommute :: Monad m => (f e -> Cell m a b) -> Cell (ReaderT (f e) m) a b
class Finite e where
- commute :: Monad m => (e -> Cell m a b) -> Cell (ReaderT e m) a b
data ExceptState state e
- = NotThrown state
- | Exception e
throwC :: Monad m => Cell (ExceptT e m) e arbitrary
wait :: Monad m => Double -> Cell (ExceptT () m) a a
throwIf :: Monad m => (a -> Bool) -> e -> Cell (ExceptT e m) a a
throwIf_ :: Monad m => (a -> Bool) -> Cell (ExceptT () m) a a
exceptC :: Monad m => Cell (ExceptT e m) (Either e a) a
runExceptC :: (Data e, Monad m) => Cell (ExceptT e m) a b -> Cell m a (Either e b)
(>>>=) :: (Data e1, Monad m) => Cell (ExceptT e1 m) a b -> Cell (ExceptT e2 m) (e1, a) b -> Cell (ExceptT e2 m) a b
(>>>==) :: (Data e1, Monad m) => Cell (ExceptT e1 m) a b -> Cell (ReaderT e1 (ExceptT e2 m)) a b -> Cell (ExceptT e2 m) a b
data CellExcept a b m e where
- Return :: e -> CellExcept a b m e
- Bind :: CellExcept a b m e1 -> (e1 -> CellExcept a b m e2) -> CellExcept a b m e2
- Try :: (Data e, Finite e) => Cell (ExceptT e m) a b -> CellExcept a b m e
runCellExcept :: Monad m => CellExcept a b m e -> Cell (ExceptT e m) a b
try :: (Data e, Finite e) => Cell (ExceptT e m) a b -> CellExcept a b m e
safely :: Monad m => CellExcept a b m Void -> Cell m a b
discardVoid :: Functor m => ExceptT Void m a -> m a
safe :: Monad m => Cell m a b -> CellExcept a b m Void
once :: (Monad m, Data e, Finite e) => (a -> m e) -> CellExcept a arbitrary m e
once_ :: (Monad m, Data e, Finite e) => m e -> CellExcept a arbitrary m e
data Feedback sPrevious sAdditional = Feedback {
- sPrevious :: sPrevious
- sAdditional :: sAdditional
}
feedback :: (Monad m, Data s) => s -> Cell m (a, s) (b, s) -> Cell m a b
delay :: (Data s, Monad m) => s -> Cell m s s
sumFeedback :: (Monad m, Num a, Data a) => Cell m a a
data BufferCommand a
- = Push a
- | Pop
sumFrom :: Monad m => Integer -> Cell m Integer Integer
count :: Monad m => Cell m a Integer
foldC :: (Data b, Monad m) => (a -> b -> b) -> b -> Cell m a b
foldC' :: (Data b, Monad m) => (a -> b -> b) -> b -> Cell m a b
hold :: (Data a, Monad m) => a -> Cell m (Maybe a) a
changes :: (Data a, Eq a, Monad m) => Cell m a (Maybe a)
holdJust :: (Monad m, Data a) => Cell m (Maybe a) (Maybe a)
holdFirst :: (Data a, Monad m) => Cell m a a
boundedFIFO :: (Data a, Monad m) => Int -> Cell m (Maybe a) (Seq a)
fifo :: (Monad m, Data a) => Cell m (Seq a) (Maybe a)
fifoList :: (Monad m, Data a) => Cell m [a] (Maybe a)
fifoFoldable :: (Monad m, Data a, Foldable f) => Cell m (f a) (Maybe a)
edge :: Monad m => Cell m Bool Bool
printTime :: MonadIO m => String -> m ()
printTimeC :: MonadIO m => String -> Cell m () ()
maybePush :: Maybe a -> [BufferCommand a]
maybePop :: Maybe a -> [BufferCommand b]
buffer :: (Monad m, Data a) => Cell m [BufferCommand a] (Maybe a)
buffered :: (Monad m, Data a) => Cell m (Maybe a) (Maybe b) -> Cell m (Maybe a) (Maybe b)
onChange :: (Monad m, Data p, Eq p) => p -> (p -> p -> a -> m b) -> Cell m a (Maybe b)
onChange' :: (Monad m, Data p, Eq p) => (p -> p -> a -> m b) -> Cell m (p, a) (Maybe b)
throwWhen0 :: Monad m => Cell (ExceptT () m) Double Double
sineChangeE :: CellExcept () Double IO Void
sineWait :: Double -> CellExcept () String IO Void
printSineWait :: LiveProgram IO
data ForeverE e s = ForeverE {
- lastException :: e
- initState :: s
- currentState :: s
}
sinesWaitAndTry :: MonadFix m => CellExcept () String m ()
sinesForever' :: MonadFix m => CellExcept () String m Void
foreverE :: (Monad m, Data e) => e -> Cell (ReaderT e (ExceptT e m)) a b -> Cell m a b
foreverC :: (Data e, Monad m) => Cell (ExceptT e m) a b -> Cell m a b
sinesForever :: MonadFix m => Cell m () String
printSinesForever :: LiveProgram IO
newtype Q q x = Q {
- unQ :: x -> q
}
statePrint :: Debugger IO
stateShow :: Data s => s -> String
isUnit :: Data s => s -> Bool
compositionShow :: (Data s1, Data s2) => Composition s1 s2 -> String
parallelShow :: (Data s1, Data s2) => Parallel s1 s2 -> String
foreverEShow :: (Data e, Data s) => ForeverE e s -> String
feedbackShow :: (Data state, Data s) => Feedback state s -> String
exceptShow :: (Data s, Data e) => ExceptState s e -> String
choiceShow :: (Data stateL, Data stateR) => Choice stateL stateR -> String
gcast3 :: forall f t t' a b c. (Typeable t, Typeable t') => f (t a b c) -> Maybe (f (t' a b c))
ext3 :: (Data a, Data b, Data c, Data d, Typeable t, Typeable f) => f a -> f (t b c d) -> f a
ext3Q :: (Data a, Data b, Data c, Data d, Typeable t, Typeable q) => (a -> q) -> (t b c d -> q) -> a -> q
runStateL :: (Data stateT, Monad m) => LiveProgram (StateT stateT m) -> stateT -> LiveProgram m
isRegistered :: Destructor m -> Bool
type HandlingStateT m = StateT (HandlingState m) m
data HandlingState m = HandlingState {
- nHandles :: Key
- destructors :: Destructors m
}
data Handling h = Handling {
- key :: Key
- handle :: h
}
runHandlingStateT :: Monad m => HandlingStateT m a -> m a
runHandlingStateC :: forall m a b. (Monad m, Typeable m) => Cell (HandlingStateT m) a b -> Cell m a b
runHandlingState :: (Monad m, Typeable m) => LiveProgram (HandlingStateT m) -> LiveProgram m
data Migration = Migration {
- runMigration :: forall a b. (Data a, Data b) => a -> b -> Maybe a
}
runSafeMigration :: (Data a, Data b) => Migration -> a -> b -> a
castMigration :: Migration
newtypeMigration :: Migration
userMigration :: (Typeable c, Typeable d) => (c -> d) -> Migration
migrationTo2 :: Typeable t => (forall a b c. (Typeable a, Typeable b, Typeable c) => t b c -> a -> Maybe (t b c)) -> Migration
constMigrationFrom2 :: Typeable t => (forall a b c. (Typeable a, Typeable b, Typeable c) => t b c -> Maybe a) -> Migration
migrationTo1 :: Typeable t => (forall a b. (Typeable a, Typeable b) => t b -> a -> Maybe (t b)) -> Migration
maybeMigrateToDebugging :: (Typeable state', Typeable state) => Debugging dbgState state -> state' -> Maybe (Debugging dbgState state)
migrationToDebugging :: Migration
maybeMigrateFromDebugging :: (Typeable state', Typeable state) => Debugging dbgState state -> Maybe state'
migrationFromDebugging :: Migration
migrationDebugging :: Migration
newtype GenericR' m = GR {
- unGR :: GenericR m
}
migrate :: (Data a, Data b) => a -> b -> a
migrateWith :: (Data a, Data b) => Migration -> a -> b -> a
standardMigration :: Migration
treeMigration :: Migration -> Migration
matchingAlgebraicDataTypes :: (Data a, Data b) => a -> b -> Bool
sameConstructorMigration :: Migration -> Migration
constructorMigration :: Migration -> Migration
tryOneField :: Data a => StateT [GenericR' Maybe] Maybe a
getChildrenSetters :: Data a => Migration -> a -> [GenericT']
getChildrenMaybe :: Data a => a -> [GenericR' Maybe]
setChildren :: Data a => [GenericT'] -> a -> a
hotCodeSwap :: LiveProgram m -> LiveProgram m -> LiveProgram m
hotCodeSwapCell :: Cell m a b -> Cell m a b -> Cell m a b
data NoMigration a
- = Initialized a
- | Uninitialized
fromNoMigration :: a -> NoMigration a -> a
dataTypeNoMigration :: DataType
initializedConstr :: Constr
uninitializedConstr :: Constr
arrChangesM :: (Monad m, Typeable a, Typeable b, Eq a) => (a -> m b) -> Cell m a b
cellNoMigration :: (Typeable s, Functor m) => s -> (s -> a -> m (b, s)) -> Cell m a b
data ParametrisedHandle p m h = ParametrisedHandle {
- createParametrised :: p -> m h
- changeParametrised :: p -> p -> h -> m h
- destroyParametrised :: p -> h -> m ()
}
data Handle m h = Handle {
- create :: m h
- destroy :: h -> m ()
}
combineHandles :: Applicative m => Handle m h1 -> Handle m h2 -> Handle m (h1, h2)
handling :: (Typeable h, Monad m) => Handle m h -> Cell (HandlingStateT m) arbitrary h
defaultChange :: (Eq p, Monad m) => (p -> m h) -> (p -> h -> m ()) -> p -> p -> h -> m h
combineParametrisedHandles :: Applicative m => ParametrisedHandle p1 m h1 -> ParametrisedHandle p2 m h2 -> ParametrisedHandle (p1, p2) m (h1, h2)
handlingParametrised :: (Typeable h, Typeable p, Monad m, Eq p) => ParametrisedHandle p m h -> Cell (HandlingStateT m) p h
toParametrised :: Monad m => Handle m h -> ParametrisedHandle () m h
ioRefHandle :: a -> Handle IO (IORef a)
emptyMVarHandle :: Handle IO (MVar a)
newMVarHandle :: a -> Handle IO (MVar a)
threadHandle :: IO () -> Handle IO ThreadId
nonBlocking :: Typeable b => Bool -> Cell IO a b -> Cell (HandlingStateT IO) (Maybe a) (Maybe b)
data LaunchedProgram (m :: * -> *) = LaunchedProgram {
- programVar :: MVar (LiveProgram IO)
- threadId :: ThreadId
}
class Monad m => Launchable m where
- runIO :: LiveProgram m -> LiveProgram IO
liveMain :: Launchable m => LiveProgram m -> IO ()
launch :: Launchable m => LiveProgram m -> IO (LaunchedProgram m)
update :: Launchable m => LaunchedProgram m -> LiveProgram m -> IO ()
stop :: Launchable m => LaunchedProgram m -> IO ()
launchWithDebugger :: (Monad m, Launchable m) => LiveProgram m -> Debugger m -> IO (LaunchedProgram m)
background :: MVar (LiveProgram IO) -> IO ()
stepProgram :: Monad m => LiveProgram m -> m (LiveProgram m)
stepLaunchedProgram :: (Monad m, Launchable m) => LaunchedProgram m -> IO ()
foreground :: Monad m => LiveProgram m -> m ()

Documentation

class Typeable a => Data a where #

The Data class comprehends a fundamental primitive gfoldl for folding over constructor applications, say terms. This primitive can be instantiated in several ways to map over the immediate subterms of a term; see the gmap combinators later in this class. Indeed, a generic programmer does not necessarily need to use the ingenious gfoldl primitive but rather the intuitive gmap combinators. The gfoldl primitive is completed by means to query top-level constructors, to turn constructor representations into proper terms, and to list all possible datatype constructors. This completion allows us to serve generic programming scenarios like read, show, equality, term generation.

The combinators gmapT, gmapQ, gmapM, etc are all provided with default definitions in terms of gfoldl, leaving open the opportunity to provide datatype-specific definitions. (The inclusion of the gmap combinators as members of class Data allows the programmer or the compiler to derive specialised, and maybe more efficient code per datatype. Note: gfoldl is more higher-order than the gmap combinators. This is subject to ongoing benchmarking experiments. It might turn out that the gmap combinators will be moved out of the class Data.)

Conceptually, the definition of the gmap combinators in terms of the primitive gfoldl requires the identification of the gfoldl function arguments. Technically, we also need to identify the type constructor c for the construction of the result type from the folded term type.

In the definition of gmapQx combinators, we use phantom type constructors for the c in the type of gfoldl because the result type of a query does not involve the (polymorphic) type of the term argument. In the definition of gmapQl we simply use the plain constant type constructor because gfoldl is left-associative anyway and so it is readily suited to fold a left-associative binary operation over the immediate subterms. In the definition of gmapQr, extra effort is needed. We use a higher-order accumulation trick to mediate between left-associative constructor application vs. right-associative binary operation (e.g., (:)). When the query is meant to compute a value of type r, then the result type within generic folding is r -> r. So the result of folding is a function to which we finally pass the right unit.

With the -XDeriveDataTypeable option, GHC can generate instances of the Data class automatically. For example, given the declaration

data T a b = C1 a b | C2 deriving (Typeable, Data)

GHC will generate an instance that is equivalent to

instance (Data a, Data b) => Data (T a b) where
    gfoldl k z (C1 a b) = z C1 `k` a `k` b
    gfoldl k z C2       = z C2

    gunfold k z c = case constrIndex c of
                        1 -> k (k (z C1))
                        2 -> z C2

    toConstr (C1 _ _) = con_C1
    toConstr C2       = con_C2

    dataTypeOf _ = ty_T

con_C1 = mkConstr ty_T "C1" [] Prefix
con_C2 = mkConstr ty_T "C2" [] Prefix
ty_T   = mkDataType "Module.T" [con_C1, con_C2]

This is suitable for datatypes that are exported transparently.

Minimal complete definition

gunfold, toConstr, dataTypeOf

Methods

gfoldl #

Arguments

:: (forall d b. Data d => c (d -> b) -> d -> c b)	defines how nonempty constructor applications are folded. It takes the folded tail of the constructor application and its head, i.e., an immediate subterm, and combines them in some way.
-> (forall g. g -> c g)	defines how the empty constructor application is folded, like the neutral / start element for list folding.
-> a	structure to be folded.
-> c a	result, with a type defined in terms of `a`, but variability is achieved by means of type constructor `c` for the construction of the actual result type.

Left-associative fold operation for constructor applications.

The type of gfoldl is a headache, but operationally it is a simple generalisation of a list fold.

The default definition for gfoldl is const id, which is suitable for abstract datatypes with no substructures.

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a #

Unfolding constructor applications

toConstr :: a -> Constr #

Obtaining the constructor from a given datum. For proper terms, this is meant to be the top-level constructor. Primitive datatypes are here viewed as potentially infinite sets of values (i.e., constructors).

dataTypeOf :: a -> DataType #

The outer type constructor of the type

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c a) #

Mediate types and unary type constructors.

In Data instances of the form

    instance (Data a, ...) => Data (T a)

dataCast1 should be defined as gcast1.

The default definition is const Nothing, which is appropriate for instances of other forms.

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

Mediate types and binary type constructors.

In Data instances of the form

    instance (Data a, Data b, ...) => Data (T a b)

dataCast2 should be defined as gcast2.

The default definition is const Nothing, which is appropriate for instances of other forms.

gmapT :: (forall b. Data b => b -> b) -> a -> a #

A generic transformation that maps over the immediate subterms

The default definition instantiates the type constructor c in the type of gfoldl to an identity datatype constructor, using the isomorphism pair as injection and projection.

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r #

A generic query with a left-associative binary operator

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r #

A generic query with a right-associative binary operator

gmapQ :: (forall d. Data d => d -> u) -> a -> [u] #

A generic query that processes the immediate subterms and returns a list of results. The list is given in the same order as originally specified in the declaration of the data constructors.

gmapQi :: Int -> (forall d. Data d => d -> u) -> a -> u #

A generic query that processes one child by index (zero-based)

gmapM :: Monad m => (forall d. Data d => d -> m d) -> a -> m a #

A generic monadic transformation that maps over the immediate subterms

The default definition instantiates the type constructor c in the type of gfoldl to the monad datatype constructor, defining injection and projection using return and >>=.

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a #

Transformation of at least one immediate subterm does not fail

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a #

Transformation of one immediate subterm with success

Instances

Instances details

Data All	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All -> c All # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c All # toConstr :: All -> Constr # dataTypeOf :: All -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c All) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c All) # gmapT :: (forall b. Data b => b -> b) -> All -> All # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All -> r # gmapQ :: (forall d. Data d => d -> u) -> All -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> All -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> All -> m All # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All #
Data Any	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any -> c Any # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Any # toConstr :: Any -> Constr # dataTypeOf :: Any -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Any) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Any) # gmapT :: (forall b. Data b => b -> b) -> Any -> Any # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r # gmapQ :: (forall d. Data d => d -> u) -> Any -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Any -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any -> m Any # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any #
Data Version	Since: base-4.7.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Version -> c Version # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Version # toConstr :: Version -> Constr # dataTypeOf :: Version -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Version) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version) # gmapT :: (forall b. Data b => b -> b) -> Version -> Version # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r # gmapQ :: (forall d. Data d => d -> u) -> Version -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Version -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Version -> m Version # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version #
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 #
Data IntPtr	Since: base-4.11.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntPtr -> c IntPtr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntPtr # toConstr :: IntPtr -> Constr # dataTypeOf :: IntPtr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IntPtr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntPtr) # gmapT :: (forall b. Data b => b -> b) -> IntPtr -> IntPtr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntPtr -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntPtr -> r # gmapQ :: (forall d. Data d => d -> u) -> IntPtr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IntPtr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr #
Data WordPtr	Since: base-4.11.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WordPtr -> c WordPtr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WordPtr # toConstr :: WordPtr -> Constr # dataTypeOf :: WordPtr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WordPtr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WordPtr) # gmapT :: (forall b. Data b => b -> b) -> WordPtr -> WordPtr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WordPtr -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WordPtr -> r # gmapQ :: (forall d. Data d => d -> u) -> WordPtr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WordPtr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr #
Data Associativity	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Associativity -> c Associativity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Associativity # toConstr :: Associativity -> Constr # dataTypeOf :: Associativity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Associativity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Associativity) # gmapT :: (forall b. Data b => b -> b) -> Associativity -> Associativity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r # gmapQ :: (forall d. Data d => d -> u) -> Associativity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Associativity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity #
Data DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness # toConstr :: DecidedStrictness -> Constr # dataTypeOf :: DecidedStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) # gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness #
Data Fixity	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity # toConstr :: Fixity -> Constr # dataTypeOf :: Fixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #
Data SourceStrictness	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness # toConstr :: SourceStrictness -> Constr # dataTypeOf :: SourceStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) # gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness #
Data SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness # toConstr :: SourceUnpackedness -> Constr # dataTypeOf :: SourceUnpackedness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) # gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness #
Data Int16	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int16 -> c Int16 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int16 # toConstr :: Int16 -> Constr # dataTypeOf :: Int16 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int16) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int16) # gmapT :: (forall b. Data b => b -> b) -> Int16 -> Int16 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int16 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int16 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 #
Data Int32	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 # toConstr :: Int32 -> Constr # dataTypeOf :: Int32 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int32) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) # gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 #
Data Int64	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 # toConstr :: Int64 -> Constr # dataTypeOf :: Int64 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int64) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) # gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 #
Data Int8	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int8 -> c Int8 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int8 # toConstr :: Int8 -> Constr # dataTypeOf :: Int8 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int8) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8) # gmapT :: (forall b. Data b => b -> b) -> Int8 -> Int8 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int8 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int8 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 #
Data Word16	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16 # toConstr :: Word16 -> Constr # dataTypeOf :: Word16 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word16) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16) # gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word16 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word16 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 #
Data Word32	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 # toConstr :: Word32 -> Constr # dataTypeOf :: Word32 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word32) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) # gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 #
Data Word64	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 # toConstr :: Word64 -> Constr # dataTypeOf :: Word64 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word64) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) # gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 #
Data Word8	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8 # toConstr :: Word8 -> Constr # dataTypeOf :: Word8 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word8) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8) # gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 #
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 #
Data Ordering	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering # toConstr :: Ordering -> Constr # dataTypeOf :: Ordering -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) # gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering #
Data DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DiffTime -> c DiffTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DiffTime # toConstr :: DiffTime -> Constr # dataTypeOf :: DiffTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DiffTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DiffTime) # gmapT :: (forall b. Data b => b -> b) -> DiffTime -> DiffTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r # gmapQ :: (forall d. Data d => d -> u) -> DiffTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DiffTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime #
Data NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NominalDiffTime -> c NominalDiffTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NominalDiffTime # toConstr :: NominalDiffTime -> Constr # dataTypeOf :: NominalDiffTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NominalDiffTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NominalDiffTime) # gmapT :: (forall b. Data b => b -> b) -> NominalDiffTime -> NominalDiffTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NominalDiffTime -> r # gmapQ :: (forall d. Data d => d -> u) -> NominalDiffTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NominalDiffTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NominalDiffTime -> m NominalDiffTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NominalDiffTime -> m NominalDiffTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NominalDiffTime -> m NominalDiffTime #
Data UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTCTime -> c UTCTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UTCTime # toConstr :: UTCTime -> Constr # dataTypeOf :: UTCTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UTCTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UTCTime) # gmapT :: (forall b. Data b => b -> b) -> UTCTime -> UTCTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTCTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTCTime -> r # gmapQ :: (forall d. Data d => d -> u) -> UTCTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UTCTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime #
Data UniversalTime
Instance details Defined in Data.Time.Clock.Internal.UniversalTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UniversalTime -> c UniversalTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UniversalTime # toConstr :: UniversalTime -> Constr # dataTypeOf :: UniversalTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UniversalTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UniversalTime) # gmapT :: (forall b. Data b => b -> b) -> UniversalTime -> UniversalTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UniversalTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UniversalTime -> r # gmapQ :: (forall d. Data d => d -> u) -> UniversalTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UniversalTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UniversalTime -> m UniversalTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UniversalTime -> m UniversalTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UniversalTime -> m UniversalTime #
Data LocalTime
Instance details Defined in Data.Time.LocalTime.Internal.LocalTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LocalTime -> c LocalTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LocalTime # toConstr :: LocalTime -> Constr # dataTypeOf :: LocalTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LocalTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LocalTime) # gmapT :: (forall b. Data b => b -> b) -> LocalTime -> LocalTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LocalTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LocalTime -> r # gmapQ :: (forall d. Data d => d -> u) -> LocalTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LocalTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LocalTime -> m LocalTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LocalTime -> m LocalTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LocalTime -> m LocalTime #
Data ZonedTime
Instance details Defined in Data.Time.LocalTime.Internal.ZonedTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZonedTime -> c ZonedTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ZonedTime # toConstr :: ZonedTime -> Constr # dataTypeOf :: ZonedTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ZonedTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ZonedTime) # gmapT :: (forall b. Data b => b -> b) -> ZonedTime -> ZonedTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZonedTime -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZonedTime -> r # gmapQ :: (forall d. Data d => d -> u) -> ZonedTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ZonedTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZonedTime -> m ZonedTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZonedTime -> m ZonedTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZonedTime -> m ZonedTime #
Data Integer	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer # toConstr :: Integer -> Constr # dataTypeOf :: Integer -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) # gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r # gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer #
Data Natural	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural # toConstr :: Natural -> Constr # dataTypeOf :: Natural -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) # gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural #
Data ()	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> () -> c () # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c () # toConstr :: () -> Constr # dataTypeOf :: () -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ()) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ()) # gmapT :: (forall b. Data b => b -> b) -> () -> () # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> () -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> () -> r # gmapQ :: (forall d. Data d => d -> u) -> () -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> () -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> () -> m () # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> () -> m () # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> () -> m () #
Data Bool	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool # toConstr :: Bool -> Constr # dataTypeOf :: Bool -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) # gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r # gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool #
Data Char	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char # toConstr :: Char -> Constr # dataTypeOf :: Char -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) # gmapT :: (forall b. Data b => b -> b) -> Char -> Char # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char #
Data Double	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double # toConstr :: Double -> Constr # dataTypeOf :: Double -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) # gmapT :: (forall b. Data b => b -> b) -> Double -> Double # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double #
Data Float	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float # toConstr :: Float -> Constr # dataTypeOf :: Float -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) # gmapT :: (forall b. Data b => b -> b) -> Float -> Float # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float #
Data Int	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int # toConstr :: Int -> Constr # dataTypeOf :: Int -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) # gmapT :: (forall b. Data b => b -> b) -> Int -> Int # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r # gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int #
Data Word	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word # toConstr :: Word -> Constr # dataTypeOf :: Word -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) # gmapT :: (forall b. Data b => b -> b) -> Word -> Word # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r # gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word #
Data a => Data (ZipList a)	Since: base-4.14.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZipList a -> c (ZipList a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ZipList a) # toConstr :: ZipList a -> Constr # dataTypeOf :: ZipList a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ZipList a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ZipList a)) # gmapT :: (forall b. Data b => b -> b) -> ZipList a -> ZipList a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r # gmapQ :: (forall d. Data d => d -> u) -> ZipList a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ZipList a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) #
Data a => Data (Complex a)	Since: base-2.1
Instance details Defined in Data.Complex Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a) # toConstr :: Complex a -> Constr # dataTypeOf :: Complex a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a)) # gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r # gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #
Data a => Data (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Identity a -> c (Identity a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Identity a) # toConstr :: Identity a -> Constr # dataTypeOf :: Identity a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Identity a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Identity a)) # gmapT :: (forall b. Data b => b -> b) -> Identity a -> Identity a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r # gmapQ :: (forall d. Data d => d -> u) -> Identity a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Identity a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) #
Data a => Data (First a)	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) # toConstr :: First a -> Constr # dataTypeOf :: First a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) # gmapT :: (forall b. Data b => b -> b) -> First a -> First a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r # gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) #
Data a => Data (Last a)	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) # toConstr :: Last a -> Constr # dataTypeOf :: Last a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) # gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r # gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) #
Data a => Data (Down a)	Since: base-4.12.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Down a -> c (Down a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Down a) # toConstr :: Down a -> Constr # dataTypeOf :: Down a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Down a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Down a)) # gmapT :: (forall b. Data b => b -> b) -> Down a -> Down a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Down a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Down a -> r # gmapQ :: (forall d. Data d => d -> u) -> Down a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Down a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) #
Data a => Data (First 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) -> First a -> c (First a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) # toConstr :: First a -> Constr # dataTypeOf :: First a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) # gmapT :: (forall b. Data b => b -> b) -> First a -> First a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r # gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) #
Data a => Data (Last 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) -> Last a -> c (Last a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) # toConstr :: Last a -> Constr # dataTypeOf :: Last a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) # gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r # gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) #
Data a => Data (Max 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) -> Max a -> c (Max a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Max a) # toConstr :: Max a -> Constr # dataTypeOf :: Max a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Max a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a)) # gmapT :: (forall b. Data b => b -> b) -> Max a -> Max a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r # gmapQ :: (forall d. Data d => d -> u) -> Max a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Max a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) #
Data a => Data (Min 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) -> Min a -> c (Min a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Min a) # toConstr :: Min a -> Constr # dataTypeOf :: Min a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Min a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a)) # gmapT :: (forall b. Data b => b -> b) -> Min a -> Min a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r # gmapQ :: (forall d. Data d => d -> u) -> Min a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Min a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min 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) #
Data a => Data (Dual a)	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dual a -> c (Dual a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dual a) # toConstr :: Dual a -> Constr # dataTypeOf :: Dual a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dual a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dual a)) # gmapT :: (forall b. Data b => b -> b) -> Dual a -> Dual a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r # gmapQ :: (forall d. Data d => d -> u) -> Dual a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dual a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) #
Data a => Data (Product a)	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Product a -> c (Product a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product a) # toConstr :: Product a -> Constr # dataTypeOf :: Product a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Product a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product a)) # gmapT :: (forall b. Data b => b -> b) -> Product a -> Product a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r # gmapQ :: (forall d. Data d => d -> u) -> Product a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Product a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) #
Data a => Data (Sum a)	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sum a -> c (Sum a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum a) # toConstr :: Sum a -> Constr # dataTypeOf :: Sum a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sum a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a)) # gmapT :: (forall b. Data b => b -> b) -> Sum a -> Sum a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r # gmapQ :: (forall d. Data d => d -> u) -> Sum a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) #
Data a => Data (ForeignPtr a)	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignPtr a -> c (ForeignPtr a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignPtr a) # toConstr :: ForeignPtr a -> Constr # dataTypeOf :: ForeignPtr a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignPtr a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignPtr a)) # gmapT :: (forall b. Data b => b -> b) -> ForeignPtr a -> ForeignPtr a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r # gmapQ :: (forall d. Data d => d -> u) -> ForeignPtr a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignPtr a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) #
Data p => Data (Par1 p)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Par1 p -> c (Par1 p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Par1 p) # toConstr :: Par1 p -> Constr # dataTypeOf :: Par1 p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Par1 p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Par1 p)) # gmapT :: (forall b. Data b => b -> b) -> Par1 p -> Par1 p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r # gmapQ :: (forall d. Data d => d -> u) -> Par1 p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Par1 p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) #
Data a => Data (Ptr a)	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) # toConstr :: Ptr a -> Constr # dataTypeOf :: Ptr a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) # gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) #
(Data a, Integral a) => Data (Ratio a)	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ratio a -> c (Ratio a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ratio a) # toConstr :: Ratio a -> Constr # dataTypeOf :: Ratio a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ratio a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ratio a)) # gmapT :: (forall b. Data b => b -> b) -> Ratio a -> Ratio a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ratio a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ratio a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) #
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) #
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) #
Data a => Data (ViewL 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) -> ViewL a -> c (ViewL a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ViewL a) # toConstr :: ViewL a -> Constr # dataTypeOf :: ViewL a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ViewL a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ViewL a)) # gmapT :: (forall b. Data b => b -> b) -> ViewL a -> ViewL a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ViewL a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ViewL a -> r # gmapQ :: (forall d. Data d => d -> u) -> ViewL a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ViewL a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ViewL a -> m (ViewL a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewL a -> m (ViewL a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewL a -> m (ViewL a) #
Data a => Data (ViewR 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) -> ViewR a -> c (ViewR a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ViewR a) # toConstr :: ViewR a -> Constr # dataTypeOf :: ViewR a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ViewR a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ViewR a)) # gmapT :: (forall b. Data b => b -> b) -> ViewR a -> ViewR a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ViewR a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ViewR a -> r # gmapQ :: (forall d. Data d => d -> u) -> ViewR a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ViewR a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ViewR a -> m (ViewR a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewR a -> m (ViewR a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewR a -> m (ViewR a) #
Typeable m => Data (Destructor m) Source #
Instance details Defined in LiveCoding.HandlingState Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Destructor m -> c (Destructor m) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Destructor m) # toConstr :: Destructor m -> Constr # dataTypeOf :: Destructor m -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Destructor m)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Destructor m)) # gmapT :: (forall b. Data b => b -> b) -> Destructor m -> Destructor m # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Destructor m -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Destructor m -> r # gmapQ :: (forall d. Data d => d -> u) -> Destructor m -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Destructor m -> u # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> Destructor m -> m0 (Destructor m) # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> Destructor m -> m0 (Destructor m) # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> Destructor m -> m0 (Destructor m) #
Typeable m => Data (HandlingState m) Source #
Instance details Defined in LiveCoding.HandlingState Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HandlingState m -> c (HandlingState m) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HandlingState m) # toConstr :: HandlingState m -> Constr # dataTypeOf :: HandlingState m -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HandlingState m)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HandlingState m)) # gmapT :: (forall b. Data b => b -> b) -> HandlingState m -> HandlingState m # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HandlingState m -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HandlingState m -> r # gmapQ :: (forall d. Data d => d -> u) -> HandlingState m -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HandlingState m -> u # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> HandlingState m -> m0 (HandlingState m) # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> HandlingState m -> m0 (HandlingState m) # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> HandlingState m -> m0 (HandlingState m) #
Typeable a => Data (NoMigration a) Source #	The Data instance for `NoMigration a` doesn't require a `Data` instance for `a`.
Instance details Defined in LiveCoding.Migrate.NoMigration Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NoMigration a -> c (NoMigration a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NoMigration a) # toConstr :: NoMigration a -> Constr # dataTypeOf :: NoMigration a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NoMigration a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NoMigration a)) # gmapT :: (forall b. Data b => b -> b) -> NoMigration a -> NoMigration a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NoMigration a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NoMigration a -> r # gmapQ :: (forall d. Data d => d -> u) -> NoMigration a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NoMigration a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NoMigration a -> m (NoMigration a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NoMigration a -> m (NoMigration a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NoMigration a -> m (NoMigration a) #
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) #
(Data a, Unbox a) => Data (Vector a)
Instance details Defined in Data.Vector.Unboxed.Base 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) #
Data a => Data (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonEmpty a) # toConstr :: NonEmpty a -> Constr # dataTypeOf :: NonEmpty a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonEmpty a)) # gmapT :: (forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r # gmapQ :: (forall d. Data d => d -> u) -> NonEmpty a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) #
Data a => Data (Maybe a)	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) # toConstr :: Maybe a -> Constr # dataTypeOf :: Maybe a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) # gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) #
Data a => Data (a)	Since: base-4.15
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> (a) -> c (a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a) # toConstr :: (a) -> Constr # dataTypeOf :: (a) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a)) # gmapT :: (forall b. Data b => b -> b) -> (a) -> (a) # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a) -> m (a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a) -> m (a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a) -> m (a) #
Data a => Data [a]	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> [a] -> c [a] # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c [a] # toConstr :: [a] -> Constr # dataTypeOf :: [a] -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c [a]) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c [a]) # gmapT :: (forall b. Data b => b -> b) -> [a] -> [a] # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r # gmapQ :: (forall d. Data d => d -> u) -> [a] -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> [a] -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> [a] -> m [a] # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] #
(Typeable m, Typeable a, Data (m a)) => Data (WrappedMonad m a)	Since: base-4.14.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonad m a -> c (WrappedMonad m a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonad m a) # toConstr :: WrappedMonad m a -> Constr # dataTypeOf :: WrappedMonad m a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonad m a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonad m a)) # gmapT :: (forall b. Data b => b -> b) -> WrappedMonad m a -> WrappedMonad m a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r # gmapQ :: (forall d. Data d => d -> u) -> WrappedMonad m a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonad m a -> u # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) #
(Data a, Data b) => Data (Either a b)	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) # toConstr :: Either a b -> Constr # dataTypeOf :: Either a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) #
Data t => Data (Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy t -> c (Proxy t) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy t) # toConstr :: Proxy t -> Constr # dataTypeOf :: Proxy t -> DataType # dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (Proxy t)) # dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (Proxy t)) # gmapT :: (forall b. Data b => b -> b) -> Proxy t -> Proxy t # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r # gmapQ :: (forall d. Data d => d -> u) -> Proxy t -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy t -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) #
(Data a, Data b) => Data (Arg a b)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Arg a b -> c (Arg a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Arg a b) # toConstr :: Arg a b -> Constr # dataTypeOf :: Arg a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Arg a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Arg a b -> Arg a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Arg a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Arg a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) #
(Data a, Data b, Ix a) => Data (Array a b)	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Array a b -> c (Array a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array a b) # toConstr :: Array a b -> Constr # dataTypeOf :: Array a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Array a b -> Array a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Array a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Array a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) #
Data p => Data (U1 p)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> U1 p -> c (U1 p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (U1 p) # toConstr :: U1 p -> Constr # dataTypeOf :: U1 p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (U1 p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (U1 p)) # gmapT :: (forall b. Data b => b -> b) -> U1 p -> U1 p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> U1 p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> U1 p -> r # gmapQ :: (forall d. Data d => d -> u) -> U1 p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> U1 p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) #
Data p => Data (V1 p)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V1 p -> c (V1 p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V1 p) # toConstr :: V1 p -> Constr # dataTypeOf :: V1 p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (V1 p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V1 p)) # gmapT :: (forall b. Data b => b -> b) -> V1 p -> V1 p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r # gmapQ :: (forall d. Data d => d -> u) -> V1 p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> V1 p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) #
(Data stateL, Data stateR) => Data (Choice stateL stateR) Source #
Instance details Defined in LiveCoding.Cell Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Choice stateL stateR -> c (Choice stateL stateR) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Choice stateL stateR) # toConstr :: Choice stateL stateR -> Constr # dataTypeOf :: Choice stateL stateR -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Choice stateL stateR)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Choice stateL stateR)) # gmapT :: (forall b. Data b => b -> b) -> Choice stateL stateR -> Choice stateL stateR # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Choice stateL stateR -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Choice stateL stateR -> r # gmapQ :: (forall d. Data d => d -> u) -> Choice stateL stateR -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Choice stateL stateR -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Choice stateL stateR -> m (Choice stateL stateR) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Choice stateL stateR -> m (Choice stateL stateR) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Choice stateL stateR -> m (Choice stateL stateR) #
(Data state1, Data state2) => Data (Composition state1 state2) Source #
Instance details Defined in LiveCoding.Cell Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Composition state1 state2 -> c (Composition state1 state2) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Composition state1 state2) # toConstr :: Composition state1 state2 -> Constr # dataTypeOf :: Composition state1 state2 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Composition state1 state2)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Composition state1 state2)) # gmapT :: (forall b. Data b => b -> b) -> Composition state1 state2 -> Composition state1 state2 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Composition state1 state2 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Composition state1 state2 -> r # gmapQ :: (forall d. Data d => d -> u) -> Composition state1 state2 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Composition state1 state2 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Composition state1 state2 -> m (Composition state1 state2) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Composition state1 state2 -> m (Composition state1 state2) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Composition state1 state2 -> m (Composition state1 state2) #
(Data stateP1, Data stateP2) => Data (Parallel stateP1 stateP2) Source #
Instance details Defined in LiveCoding.Cell Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Parallel stateP1 stateP2 -> c (Parallel stateP1 stateP2) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Parallel stateP1 stateP2) # toConstr :: Parallel stateP1 stateP2 -> Constr # dataTypeOf :: Parallel stateP1 stateP2 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Parallel stateP1 stateP2)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Parallel stateP1 stateP2)) # gmapT :: (forall b. Data b => b -> b) -> Parallel stateP1 stateP2 -> Parallel stateP1 stateP2 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parallel stateP1 stateP2 -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parallel stateP1 stateP2 -> r # gmapQ :: (forall d. Data d => d -> u) -> Parallel stateP1 stateP2 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Parallel stateP1 stateP2 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Parallel stateP1 stateP2 -> m (Parallel stateP1 stateP2) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Parallel stateP1 stateP2 -> m (Parallel stateP1 stateP2) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Parallel stateP1 stateP2 -> m (Parallel stateP1 stateP2) #
(Data sPrevious, Data sAdditional) => Data (Feedback sPrevious sAdditional) Source #
Instance details Defined in LiveCoding.Cell.Feedback Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Feedback sPrevious sAdditional -> c (Feedback sPrevious sAdditional) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Feedback sPrevious sAdditional) # toConstr :: Feedback sPrevious sAdditional -> Constr # dataTypeOf :: Feedback sPrevious sAdditional -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Feedback sPrevious sAdditional)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Feedback sPrevious sAdditional)) # gmapT :: (forall b. Data b => b -> b) -> Feedback sPrevious sAdditional -> Feedback sPrevious sAdditional # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Feedback sPrevious sAdditional -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Feedback sPrevious sAdditional -> r # gmapQ :: (forall d. Data d => d -> u) -> Feedback sPrevious sAdditional -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Feedback sPrevious sAdditional -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Feedback sPrevious sAdditional -> m (Feedback sPrevious sAdditional) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Feedback sPrevious sAdditional -> m (Feedback sPrevious sAdditional) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Feedback sPrevious sAdditional -> m (Feedback sPrevious sAdditional) #
(Data stateT, Data stateInternal) => Data (State stateT stateInternal) Source #
Instance details Defined in LiveCoding.Cell.Monad.Trans Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> State stateT stateInternal -> c (State stateT stateInternal) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (State stateT stateInternal) # toConstr :: State stateT stateInternal -> Constr # dataTypeOf :: State stateT stateInternal -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (State stateT stateInternal)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (State stateT stateInternal)) # gmapT :: (forall b. Data b => b -> b) -> State stateT stateInternal -> State stateT stateInternal # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> State stateT stateInternal -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> State stateT stateInternal -> r # gmapQ :: (forall d. Data d => d -> u) -> State stateT stateInternal -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> State stateT stateInternal -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> State stateT stateInternal -> m (State stateT stateInternal) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> State stateT stateInternal -> m (State stateT stateInternal) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> State stateT stateInternal -> m (State stateT stateInternal) #
(Data dbgState, Data state) => Data (Debugging dbgState state) Source #
Instance details Defined in LiveCoding.Debugger Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Debugging dbgState state -> c (Debugging dbgState state) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Debugging dbgState state) # toConstr :: Debugging dbgState state -> Constr # dataTypeOf :: Debugging dbgState state -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Debugging dbgState state)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Debugging dbgState state)) # gmapT :: (forall b. Data b => b -> b) -> Debugging dbgState state -> Debugging dbgState state # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Debugging dbgState state -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Debugging dbgState state -> r # gmapQ :: (forall d. Data d => d -> u) -> Debugging dbgState state -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Debugging dbgState state -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Debugging dbgState state -> m (Debugging dbgState state) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Debugging dbgState state -> m (Debugging dbgState state) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Debugging dbgState state -> m (Debugging dbgState state) #
(Data state, Data e) => Data (ExceptState state e) Source #
Instance details Defined in LiveCoding.Exceptions Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExceptState state e -> c (ExceptState state e) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExceptState state e) # toConstr :: ExceptState state e -> Constr # dataTypeOf :: ExceptState state e -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ExceptState state e)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (ExceptState state e)) # gmapT :: (forall b. Data b => b -> b) -> ExceptState state e -> ExceptState state e # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExceptState state e -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExceptState state e -> r # gmapQ :: (forall d. Data d => d -> u) -> ExceptState state e -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ExceptState state e -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExceptState state e -> m (ExceptState state e) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExceptState state e -> m (ExceptState state e) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExceptState state e -> m (ExceptState state e) #
(Data e, Data s) => Data (ForeverE e s) Source #
Instance details Defined in LiveCoding.Forever Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeverE e s -> c (ForeverE e s) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeverE e s) # toConstr :: ForeverE e s -> Constr # dataTypeOf :: ForeverE e s -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeverE e s)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (ForeverE e s)) # gmapT :: (forall b. Data b => b -> b) -> ForeverE e s -> ForeverE e s # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeverE e s -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeverE e s -> r # gmapQ :: (forall d. Data d => d -> u) -> ForeverE e s -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeverE e s -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeverE e s -> m (ForeverE e s) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeverE e s -> m (ForeverE e s) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeverE e s -> m (ForeverE e s) #
(Data a, Data b) => Data (a, b)	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a, b) -> c (a, b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b) # toConstr :: (a, b) -> Constr # dataTypeOf :: (a, b) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a, b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a, b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b) -> (a, b) # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a, b) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a, b) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a, b) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) #
(Typeable a, Typeable b, Typeable c, Data (a b c)) => Data (WrappedArrow a b c)	Since: base-4.14.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> WrappedArrow a b c -> c0 (WrappedArrow a b c) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (WrappedArrow a b c) # toConstr :: WrappedArrow a b c -> Constr # dataTypeOf :: WrappedArrow a b c -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (WrappedArrow a b c)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (WrappedArrow a b c)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> WrappedArrow a b c -> WrappedArrow a b c # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r # gmapQ :: (forall d. Data d => d -> u) -> WrappedArrow a b c -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedArrow a b c -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) #
(Typeable k, Data a, Typeable b) => Data (Const a b)	Since: base-4.10.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Const a b -> c (Const a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Const a b) # toConstr :: Const a b -> Constr # dataTypeOf :: Const a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Const a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Const a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Const a b -> Const a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Const a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Const a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) #
(Data (f a), Data a, Typeable f) => Data (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ap f a -> c (Ap f a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ap f a) # toConstr :: Ap f a -> Constr # dataTypeOf :: Ap f a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ap f a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ap f a)) # gmapT :: (forall b. Data b => b -> b) -> Ap f a -> Ap f a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ap f a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ap f a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ap f a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ap f a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) #
(Data (f a), Data a, Typeable f) => Data (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt f a -> c (Alt f a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt f a) # toConstr :: Alt f a -> Constr # dataTypeOf :: Alt f a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt f a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt f a)) # gmapT :: (forall b. Data b => b -> b) -> Alt f a -> Alt f a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r # gmapQ :: (forall d. Data d => d -> u) -> Alt f a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt f a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) #
(Coercible a b, Data a, Data b) => Data (Coercion a b)	Since: base-4.7.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Coercion a b -> c (Coercion a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Coercion a b) # toConstr :: Coercion a b -> Constr # dataTypeOf :: Coercion a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Coercion a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Coercion a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Coercion a b -> Coercion a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Coercion a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) #
(a ~ b, Data a) => Data (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~: b) -> c (a :~: b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~: b) # toConstr :: (a :~: b) -> Constr # dataTypeOf :: (a :~: b) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~: b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~: b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~: b) -> a :~: b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a :~: b) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~: b) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) #
(Data (f p), Typeable f, Data p) => Data (Rec1 f p)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rec1 f p -> c (Rec1 f p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rec1 f p) # toConstr :: Rec1 f p -> Constr # dataTypeOf :: Rec1 f p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Rec1 f p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rec1 f p)) # gmapT :: (forall b. Data b => b -> b) -> Rec1 f p -> Rec1 f p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 f p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 f p -> r # gmapQ :: (forall d. Data d => d -> u) -> Rec1 f p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Rec1 f p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) #
(KnownNat n, Typeable v, Typeable a, Data (v a)) => Data (Vector v n a)
Instance details Defined in Data.Vector.Generic.Sized.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector v n a -> c (Vector v n a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector v n a) # toConstr :: Vector v n a -> Constr # dataTypeOf :: Vector v n a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector v n a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector v n a)) # gmapT :: (forall b. Data b => b -> b) -> Vector v n a -> Vector v n a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector v n a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector v n a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vector v n a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector v n a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector v n a -> m (Vector v n a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector v n a -> m (Vector v n a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector v n a -> m (Vector v n a) #
(Data a, Data b, Data c) => Data (a, b, c)	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c) -> c0 (a, b, c) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c) # toConstr :: (a, b, c) -> Constr # dataTypeOf :: (a, b, c) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (a, b, c)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (a, b, c)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c) -> (a, b, c) # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a, b, c) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a, b, c) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) #
(Typeable a, Typeable f, Typeable g, Typeable k, Data (f a), Data (g a)) => Data (Product f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Product f g a -> c (Product f g a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product f g a) # toConstr :: Product f g a -> Constr # dataTypeOf :: Product f g a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Product f g a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product f g a)) # gmapT :: (forall b. Data b => b -> b) -> Product f g a -> Product f g a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product f g a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product f g a -> r # gmapQ :: (forall d. Data d => d -> u) -> Product f g a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Product f g a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product f g a -> m (Product f g a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product f g a -> m (Product f g a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product f g a -> m (Product f g a) #
(Typeable a, Typeable f, Typeable g, Typeable k, Data (f a), Data (g a)) => Data (Sum f g a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Sum f g a -> c (Sum f g a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum f g a) # toConstr :: Sum f g a -> Constr # dataTypeOf :: Sum f g a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sum f g a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum f g a)) # gmapT :: (forall b. Data b => b -> b) -> Sum f g a -> Sum f g a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum f g a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum f g a -> r # gmapQ :: (forall d. Data d => d -> u) -> Sum f g a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum f g a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) #
(Typeable i, Typeable j, Typeable a, Typeable b, a ~~ b) => Data (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~~: b) -> c (a :~~: b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~~: b) # toConstr :: (a :~~: b) -> Constr # dataTypeOf :: (a :~~: b) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~~: b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~~: b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~~: b) -> a :~~: b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~~: b) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~~: b) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a :~~: b) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~~: b) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) #
(Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :*: g) p)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :: g) p -> c ((f :: g) p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :: g) p) # toConstr :: (f :: g) p -> Constr # dataTypeOf :: (f :: g) p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :: g) p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :: g) p)) # gmapT :: (forall b. Data b => b -> b) -> (f :: g) p -> (f :: g) p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :: g) p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :: g) p -> r # gmapQ :: (forall d. Data d => d -> u) -> (f :: g) p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :: g) p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :: g) p -> m ((f :: g) p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :: g) p -> m ((f :: g) p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :: g) p -> m ((f :*: g) p) #
(Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :+: g) p)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :+: g) p -> c ((f :+: g) p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :+: g) p) # toConstr :: (f :+: g) p -> Constr # dataTypeOf :: (f :+: g) p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :+: g) p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :+: g) p)) # gmapT :: (forall b. Data b => b -> b) -> (f :+: g) p -> (f :+: g) p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r # gmapQ :: (forall d. Data d => d -> u) -> (f :+: g) p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :+: g) p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) #
(Typeable i, Data p, Data c) => Data (K1 i c p)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> K1 i c p -> c0 (K1 i c p) # gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (K1 i c p) # toConstr :: K1 i c p -> Constr # dataTypeOf :: K1 i c p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (K1 i c p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (K1 i c p)) # gmapT :: (forall b. Data b => b -> b) -> K1 i c p -> K1 i c p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> K1 i c p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> K1 i c p -> r # gmapQ :: (forall d. Data d => d -> u) -> K1 i c p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> K1 i c p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) #
(Data a, Data b, Data c, Data d) => Data (a, b, c, d)	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d) -> c0 (a, b, c, d) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d) # toConstr :: (a, b, c, d) -> Constr # dataTypeOf :: (a, b, c, d) -> DataType # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d)) # dataCast2 :: Typeable t => (forall d0 e. (Data d0, Data e) => c0 (t d0 e)) -> Maybe (c0 (a, b, c, d)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d) -> (a, b, c, d) # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d) -> r # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d) -> [u] # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d) -> u # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) #
(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) #
(Typeable f, Typeable g, Data p, Data (f (g p))) => Data ((f :.: g) p)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :.: g) p -> c ((f :.: g) p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :.: g) p) # toConstr :: (f :.: g) p -> Constr # dataTypeOf :: (f :.: g) p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :.: g) p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :.: g) p)) # gmapT :: (forall b. Data b => b -> b) -> (f :.: g) p -> (f :.: g) p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :.: g) p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :.: g) p -> r # gmapQ :: (forall d. Data d => d -> u) -> (f :.: g) p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :.: g) p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) #
(Data p, Data (f p), Typeable c, Typeable i, Typeable f) => Data (M1 i c f p)	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> M1 i c f p -> c0 (M1 i c f p) # gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (M1 i c f p) # toConstr :: M1 i c f p -> Constr # dataTypeOf :: M1 i c f p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (M1 i c f p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (M1 i c f p)) # gmapT :: (forall b. Data b => b -> b) -> M1 i c f p -> M1 i c f p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> M1 i c f p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> M1 i c f p -> r # gmapQ :: (forall d. Data d => d -> u) -> M1 i c f p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> M1 i c f p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) #
(Data a, Data b, Data c, Data d, Data e) => Data (a, b, c, d, e)	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d, e) -> c0 (a, b, c, d, e) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e) # toConstr :: (a, b, c, d, e) -> Constr # dataTypeOf :: (a, b, c, d, e) -> DataType # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e)) # dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e) -> (a, b, c, d, e) # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e) -> r # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e) -> [u] # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e) -> u # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) #
(Data a, Data b, Data c, Data d, Data e, Data f) => Data (a, b, c, d, e, f)	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d, e, f) -> c0 (a, b, c, d, e, f) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e, f) # toConstr :: (a, b, c, d, e, f) -> Constr # dataTypeOf :: (a, b, c, d, e, f) -> DataType # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e, f)) # dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e, f)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f) -> r # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f) -> [u] # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f) -> u # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) #
(Data a, Data b, Data c, Data d, Data e, Data f, Data g) => Data (a, b, c, d, e, f, g)	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g0. g0 -> c0 g0) -> (a, b, c, d, e, f, g) -> c0 (a, b, c, d, e, f, g) # gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e, f, g) # toConstr :: (a, b, c, d, e, f, g) -> Constr # dataTypeOf :: (a, b, c, d, e, f, g) -> DataType # dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e, f, g)) # dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e, f, g)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f, g) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f, g) -> r # gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f, g) -> [u] # gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f, g) -> u # gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) # gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) # gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) #

class Typeable (a :: k) #

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

Minimal complete definition

typeRep#

data TyCon #

Instances

Instances details

Show TyCon	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TyCon -> ShowS # show :: TyCon -> String # showList :: [TyCon] -> ShowS #
Eq TyCon
Instance details Defined in GHC.Classes Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
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 #

data Fixity #

Fixity of constructors

Constructors

Prefix
Infix

Instances

Instances details

Show Fixity	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Eq Fixity	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #

data DataType #

Representation of datatypes. A package of constructor representations with names of type and module.

Instances

Instances details

Show DataType	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods showsPrec :: Int -> DataType -> ShowS # show :: DataType -> String # showList :: [DataType] -> ShowS #

data DataRep #

Public representation of datatypes

Constructors

AlgRep [Constr]
IntRep
FloatRep
CharRep
NoRep

Instances

Instances details

Show DataRep	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods showsPrec :: Int -> DataRep -> ShowS # show :: DataRep -> String # showList :: [DataRep] -> ShowS #
Eq DataRep	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods (==) :: DataRep -> DataRep -> Bool # (/=) :: DataRep -> DataRep -> Bool #

data ConstrRep #

Public representation of constructors

Constructors

AlgConstr ConIndex
IntConstr Integer
FloatConstr Rational
CharConstr Char

Instances

Instances details

Show ConstrRep	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods showsPrec :: Int -> ConstrRep -> ShowS # show :: ConstrRep -> String # showList :: [ConstrRep] -> ShowS #
Eq ConstrRep	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods (==) :: ConstrRep -> ConstrRep -> Bool # (/=) :: ConstrRep -> ConstrRep -> Bool #

data Constr #

Representation of constructors. Note that equality on constructors with different types may not work -- i.e. the constructors for False and Nothing may compare equal.

Instances

Instances details

Show Constr	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods showsPrec :: Int -> Constr -> ShowS # show :: Constr -> String # showList :: [Constr] -> ShowS #
Eq Constr	Equality of constructors Since: base-4.0.0.0
Instance details Defined in Data.Data Methods (==) :: Constr -> Constr -> Bool # (/=) :: Constr -> Constr -> Bool #

type ConIndex = Int #

Unique index for datatype constructors, counting from 1 in the order they are given in the program text.

tyconUQname :: String -> String #

Gets the unqualified type constructor: drop *.*.*... before name

tyconModule :: String -> String #

Gets the module of a type constructor: take *.*.*... before name

showConstr :: Constr -> String #

Gets the string for a constructor

repConstr :: DataType -> ConstrRep -> Constr #

Look up a constructor by its representation

readConstr :: DataType -> String -> Maybe Constr #

Lookup a constructor via a string

mkRealConstr :: (Real a, Show a) => DataType -> a -> Constr #

mkNoRepType :: String -> DataType #

Constructs a non-representation for a non-representable type

mkIntegralConstr :: (Integral a, Show a) => DataType -> a -> Constr #

mkIntType :: String -> DataType #

Constructs the Int type

mkFloatType :: String -> DataType #

Constructs the Float type

mkDataType :: String -> [Constr] -> DataType #

Constructs an algebraic datatype

mkConstrTag :: DataType -> String -> Int -> [String] -> Fixity -> Constr #

Constructs a constructor

mkConstr :: DataType -> String -> [String] -> Fixity -> Constr #

Constructs a constructor

mkCharType :: String -> DataType #

Constructs the Char type

mkCharConstr :: DataType -> Char -> Constr #

Makes a constructor for Char.

maxConstrIndex :: DataType -> ConIndex #

Gets the maximum constructor index of an algebraic datatype

isNorepType :: DataType -> Bool #

Test for a non-representable type

isAlgType :: DataType -> Bool #

Test for an algebraic type

indexConstr :: DataType -> ConIndex -> Constr #

Gets the constructor for an index (algebraic datatypes only)

fromConstrM :: (Monad m, Data a) => (forall d. Data d => m d) -> Constr -> m a #

Monadic variation on fromConstrB

fromConstrB :: Data a => (forall d. Data d => d) -> Constr -> a #

Build a term and use a generic function for subterms

fromConstr :: Data a => Constr -> a #

Build a term skeleton

dataTypeRep :: DataType -> DataRep #

Gets the public presentation of a datatype

dataTypeName :: DataType -> String #

Gets the type constructor including the module

dataTypeConstrs :: DataType -> [Constr] #

Gets the constructors of an algebraic datatype

constrType :: Constr -> DataType #

Gets the datatype of a constructor

constrRep :: Constr -> ConstrRep #

Gets the public presentation of constructors

constrIndex :: Constr -> ConIndex #

Gets the index of a constructor (algebraic datatypes only)

constrFixity :: Constr -> Fixity #

Gets the fixity of a constructor

constrFields :: Constr -> [String] #

Gets the field labels of a constructor. The list of labels is returned in the same order as they were given in the original constructor declaration.

newtype Kleisli (m :: Type -> Type) a b #

Kleisli arrows of a monad.

Constructors

Kleisli
Fields runKleisli :: a -> m b

Instances

Instances details

Monad m => Category (Kleisli m :: Type -> Type -> TYPE LiftedRep)	Since: base-3.0
Instance details Defined in Control.Arrow Methods id :: forall (a :: k). Kleisli m a a # (.) :: forall (b :: k) (c :: k) (a :: k). Kleisli m b c -> Kleisli m a b -> Kleisli m a c #
Generic1 (Kleisli m a :: Type -> TYPE LiftedRep)
Instance details Defined in Control.Arrow Associated Types type Rep1 (Kleisli m a) :: k -> Type # Methods from1 :: forall (a0 :: k). Kleisli m a a0 -> Rep1 (Kleisli m a) a0 # to1 :: forall (a0 :: k). Rep1 (Kleisli m a) a0 -> Kleisli m a a0 #
Monad m => Arrow (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods arr :: (b -> c) -> Kleisli m b c # first :: Kleisli m b c -> Kleisli m (b, d) (c, d) # second :: Kleisli m b c -> Kleisli m (d, b) (d, c) # (***) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (b, b') (c, c') # (&&&) :: Kleisli m b c -> Kleisli m b c' -> Kleisli m b (c, c') #
Monad m => ArrowApply (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods app :: Kleisli m (Kleisli m b c, b) c #
Monad m => ArrowChoice (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods left :: Kleisli m b c -> Kleisli m (Either b d) (Either c d) # right :: Kleisli m b c -> Kleisli m (Either d b) (Either d c) # (+++) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (Either b b') (Either c c') # (\|\|\|) :: Kleisli m b d -> Kleisli m c d -> Kleisli m (Either b c) d #
MonadFix m => ArrowLoop (Kleisli m)	Beware that for many monads (those for which the `>>=` operation is strict) this instance will not satisfy the right-tightening law required by the `ArrowLoop` class. Since: base-2.1
Instance details Defined in Control.Arrow Methods loop :: Kleisli m (b, d) (c, d) -> Kleisli m b c #
MonadPlus m => ArrowPlus (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods (<+>) :: Kleisli m b c -> Kleisli m b c -> Kleisli m b c #
MonadPlus m => ArrowZero (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods zeroArrow :: Kleisli m b c #
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] #
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 #
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 #
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 #
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 #
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 #
type Rep1 (Kleisli m a :: Type -> TYPE LiftedRep)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow type Rep1 (Kleisli m a :: Type -> TYPE LiftedRep) = D1 ('MetaData "Kleisli" "Control.Arrow" "base" 'True) (C1 ('MetaCons "Kleisli" 'PrefixI 'True) (S1 ('MetaSel ('Just "runKleisli") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) ((FUN 'Many a :: TYPE LiftedRep -> Type) :.: Rec1 m)))
type Rep (Kleisli m a b)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow type Rep (Kleisli m a b) = D1 ('MetaData "Kleisli" "Control.Arrow" "base" 'True) (C1 ('MetaCons "Kleisli" 'PrefixI 'True) (S1 ('MetaSel ('Just "runKleisli") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a -> m b))))

class Arrow a => ArrowZero (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) where #

Methods

zeroArrow :: a b c #

Instances

Instances details

MonadPlus m => ArrowZero (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods zeroArrow :: Kleisli m b c #

class ArrowZero a => ArrowPlus (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) where #

A monoid on arrows.

Methods

(<+>) :: a b c -> a b c -> a b c infixr 5 #

An associative operation with identity zeroArrow.

Instances

Instances details

MonadPlus m => ArrowPlus (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods (<+>) :: Kleisli m b c -> Kleisli m b c -> Kleisli m b c #

newtype ArrowMonad (a :: Type -> Type -> Type) b #

The ArrowApply class is equivalent to Monad: any monad gives rise to a Kleisli arrow, and any instance of ArrowApply defines a monad.

Constructors

ArrowMonad (a () b)

Instances

Instances details

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] #
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 #
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 #
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 #
(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 #

class Arrow a => ArrowLoop (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) where #

The loop operator expresses computations in which an output value is fed back as input, although the computation occurs only once. It underlies the rec value recursion construct in arrow notation. loop should satisfy the following laws:

extension: loop (arr f) = arr (\ b -> fst (fix (\ (c,d) -> f (b,d))))
left tightening: loop (first h >>> f) = h >>> loop f
right tightening: loop (f >>> first h) = loop f >>> h
sliding: loop (f >>> arr (id *** k)) = loop (arr (id *** k) >>> f)
vanishing: loop (loop f) = loop (arr unassoc >>> f >>> arr assoc)
superposing: second (loop f) = loop (arr assoc >>> second f >>> arr unassoc)

where

assoc ((a,b),c) = (a,(b,c))
unassoc (a,(b,c)) = ((a,b),c)

Methods

loop :: a (b, d) (c, d) -> a b c #

Instances

Instances details

MonadFix m => ArrowLoop (Kleisli m)	Beware that for many monads (those for which the `>>=` operation is strict) this instance will not satisfy the right-tightening law required by the `ArrowLoop` class. Since: base-2.1
Instance details Defined in Control.Arrow Methods loop :: Kleisli m (b, d) (c, d) -> Kleisli m b c #
MonadFix m => ArrowLoop (Cell m) Source #
Instance details Defined in LiveCoding.Cell Methods loop :: Cell m (b, d) (c, d) -> Cell m b c #
ArrowLoop (->)	Since: base-2.1
Instance details Defined in Control.Arrow Methods loop :: ((b, d) -> (c, d)) -> b -> c #

class Arrow a => ArrowChoice (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) where #

Choice, for arrows that support it. This class underlies the if and case constructs in arrow notation.

Instances should satisfy the following laws:

```
left (arr f) = arr (left f)
```
```
left (f >>> g) = left f >>> left g
```
```
f >>> arr Left = arr Left >>> left f
```

left f >>> arr (id +++ g) = arr (id +++ g) >>> left f

left (left f) >>> arr assocsum = arr assocsum >>> left f

where

assocsum (Left (Left x)) = Left x
assocsum (Left (Right y)) = Right (Left y)
assocsum (Right z) = Right (Right z)

The other combinators have sensible default definitions, which may be overridden for efficiency.

Minimal complete definition

(left | (+++))

Methods

left :: a b c -> a (Either b d) (Either c d) #

Feed marked inputs through the argument arrow, passing the rest through unchanged to the output.

right :: a b c -> a (Either d b) (Either d c) #

A mirror image of left.

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

(+++) :: a b c -> a b' c' -> a (Either b b') (Either c c') infixr 2 #

Split the input between the two argument arrows, retagging and merging their outputs. Note that this is in general not a functor.

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

(|||) :: a b d -> a c d -> a (Either b c) d infixr 2 #

Fanin: Split the input between the two argument arrows and merge their outputs.

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

Instances

Instances details

Monad m => ArrowChoice (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods left :: Kleisli m b c -> Kleisli m (Either b d) (Either c d) # right :: Kleisli m b c -> Kleisli m (Either d b) (Either d c) # (+++) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (Either b b') (Either c c') # (\|\|\|) :: Kleisli m b d -> Kleisli m c d -> Kleisli m (Either b c) d #
Monad m => ArrowChoice (Cell m) Source #
Instance details Defined in LiveCoding.Cell Methods left :: Cell m b c -> Cell m (Either b d) (Either c d) # right :: Cell m b c -> Cell m (Either d b) (Either d c) # (+++) :: Cell m b c -> Cell m b' c' -> Cell m (Either b b') (Either c c') # (\|\|\|) :: Cell m b d -> Cell m c d -> Cell m (Either b c) d #
ArrowChoice (->)	Since: base-2.1
Instance details Defined in Control.Arrow Methods left :: (b -> c) -> Either b d -> Either c d # right :: (b -> c) -> Either d b -> Either d c # (+++) :: (b -> c) -> (b' -> c') -> Either b b' -> Either c c' # (\|\|\|) :: (b -> d) -> (c -> d) -> Either b c -> d #

class Arrow a => ArrowApply (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) #

Some arrows allow application of arrow inputs to other inputs. Instances should satisfy the following laws:

first (arr (\x -> arr (\y -> (x,y)))) >>> app = id

first (arr (g >>>)) >>> app = second g >>> app

```
first (arr (>>> h)) >>> app = app >>> h
```

Such arrows are equivalent to monads (see ArrowMonad).

Minimal complete definition

app

Instances

Instances details

Monad m => ArrowApply (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods app :: Kleisli m (Kleisli m b c, b) c #
ArrowApply (->)	Since: base-2.1
Instance details Defined in Control.Arrow Methods app :: (b -> c, b) -> c #

class Category a => Arrow (a :: TYPE LiftedRep -> TYPE LiftedRep -> Type) where #

The basic arrow class.

Instances should satisfy the following laws:

```
arr id = id
```
```
arr (f >>> g) = arr f >>> arr g
```
```
first (arr f) = arr (first f)
```
```
first (f >>> g) = first f >>> first g
```
```
first f >>> arr fst = arr fst >>> f
```

first f >>> arr (id *** g) = arr (id *** g) >>> first f

first (first f) >>> arr assoc = arr assoc >>> first f

where

assoc ((a,b),c) = (a,(b,c))

The other combinators have sensible default definitions, which may be overridden for efficiency.

Minimal complete definition

arr, (first | (***))

Methods

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

Lift a function to an arrow.

first :: a b c -> a (b, d) (c, d) #

Send the first component of the input through the argument arrow, and copy the rest unchanged to the output.

second :: a b c -> a (d, b) (d, c) #

A mirror image of first.

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

(***) :: a b c -> a b' c' -> a (b, b') (c, c') infixr 3 #

Split the input between the two argument arrows and combine their output. Note that this is in general not a functor.

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

(&&&) :: 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.

Instances

Instances details

Monad m => Arrow (Kleisli m)	Since: base-2.1
Instance details Defined in Control.Arrow Methods arr :: (b -> c) -> Kleisli m b c # first :: Kleisli m b c -> Kleisli m (b, d) (c, d) # second :: Kleisli m b c -> Kleisli m (d, b) (d, c) # (***) :: Kleisli m b c -> Kleisli m b' c' -> Kleisli m (b, b') (c, c') # (&&&) :: Kleisli m b c -> Kleisli m b c' -> Kleisli m b (c, c') #
Monad m => Arrow (Cell m) Source #
Instance details Defined in LiveCoding.Cell Methods arr :: (b -> c) -> Cell m b c # first :: Cell m b c -> Cell m (b, d) (c, d) # second :: Cell m b c -> Cell m (d, b) (d, c) # (***) :: Cell m b c -> Cell m b' c' -> Cell m (b, b') (c, c') # (&&&) :: Cell m b c -> Cell m b c' -> Cell m b (c, c') #
Arrow (->)	Since: base-2.1
Instance details Defined in Control.Arrow Methods arr :: (b -> c) -> b -> c # first :: (b -> c) -> (b, d) -> (c, d) # second :: (b -> c) -> (d, b) -> (d, c) # (***) :: (b -> c) -> (b' -> c') -> (b, b') -> (c, c') # (&&&) :: (b -> c) -> (b -> c') -> b -> (c, c') #

returnA :: Arrow a => a b b #

The identity arrow, which plays the role of return in arrow notation.

leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d) #

Any instance of ArrowApply can be made into an instance of ArrowChoice by defining left = leftApp.

(^>>) :: Arrow a => (b -> c) -> a c d -> a b d infixr 1 #

Precomposition with a pure function.

(^<<) :: Arrow a => (c -> d) -> a b c -> a b d infixr 1 #

Postcomposition with a pure function (right-to-left variant).

(>>^) :: Arrow a => a b c -> (c -> d) -> a b d infixr 1 #

Postcomposition with a pure function.

(<<^) :: Arrow a => a c d -> (b -> c) -> a b d infixr 1 #

Precomposition with a pure function (right-to-left variant).

type TypeRep = SomeTypeRep #

A quantified type representation.

typeRepTyCon :: TypeRep -> TyCon #

Observe the type constructor of a quantified type representation.

typeRepFingerprint :: TypeRep -> Fingerprint #

Takes a value of type a and returns a concrete representation of that type.

Since: base-4.7.0.0

typeRepArgs :: TypeRep -> [TypeRep] #

Observe the argument types of a type representation

typeRep :: forall {k} proxy (a :: k). Typeable a => proxy a -> TypeRep #

Takes a value of type a and returns a concrete representation of that type.

Since: base-4.7.0.0

typeOf7 :: Typeable t => t a b c d e f g -> TypeRep #

typeOf6 :: Typeable t => t a b c d e f -> TypeRep #

typeOf5 :: Typeable t => t a b c d e -> TypeRep #

typeOf4 :: Typeable t => t a b c d -> TypeRep #

typeOf3 :: Typeable t => t a b c -> TypeRep #

typeOf2 :: Typeable t => t a b -> TypeRep #

typeOf1 :: Typeable t => t a -> TypeRep #

typeOf :: Typeable a => a -> TypeRep #

Observe a type representation for the type of a value.

splitTyConApp :: TypeRep -> (TyCon, [TypeRep]) #

Splits a type constructor application. Note that if the type constructor is polymorphic, this will not return the kinds that were used.

showsTypeRep :: TypeRep -> ShowS #

Show a type representation

rnfTypeRep :: TypeRep -> () #

Force a TypeRep to normal form.

mkFunTy :: TypeRep -> TypeRep -> TypeRep #

Build a function type.

gcast2 :: forall {k1} {k2} {k3} c (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b)) #

Cast over k1 -> k2 -> k3

gcast1 :: forall {k1} {k2} c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a)) #

Cast over k1 -> k2

gcast :: forall {k} (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b) #

A flexible variation parameterised in a type constructor

funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep #

Applies a type to a function type. Returns: Just u if the first argument represents a function of type t -> u and the second argument represents a function of type t. Otherwise, returns Nothing.

eqT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b) #

Extract a witness of equality of two types

Since: base-4.7.0.0

cast :: (Typeable a, Typeable b) => a -> Maybe b #

The type-safe cast operation

tyConPackage :: TyCon -> String #

tyConName :: TyCon -> String #

tyConModule :: TyCon -> String #

tyConFingerprint :: TyCon -> Fingerprint #

trLiftedRep :: TypeRep ('BoxedRep 'Lifted) #

rnfTyCon :: TyCon -> () #

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 #
Foldable (Proxy :: TYPE LiftedRep -> 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 #
Eq1 (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a -> b -> Bool) -> Proxy a -> Proxy b -> Bool #
Ord1 (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Proxy a -> Proxy b -> Ordering #
Read1 (Proxy :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Proxy a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Proxy a] #
Show1 (Proxy :: TYPE LiftedRep -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy a] -> ShowS #
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 #
Data t => Data (Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy t -> c (Proxy t) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy t) # toConstr :: Proxy t -> Constr # dataTypeOf :: Proxy t -> DataType # dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (Proxy t)) # dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (Proxy t)) # gmapT :: (forall b. Data b => b -> b) -> Proxy t -> Proxy t # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r # gmapQ :: (forall d. Data d => d -> u) -> Proxy t -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy t -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) #
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 #
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 #
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 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))

(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c infixr 1 #

Left-to-right composition

(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c infixr 1 #

Right-to-left composition

data (a :: k1) :~~: (b :: k2) where infix 4 #

Kind heterogeneous propositional equality. Like :~:, a :~~: b is inhabited by a terminating value if and only if a is the same type as b.

Since: base-4.10.0.0

Constructors

HRefl :: forall {k1} (a :: k1). a :~~: a

Instances

Instances details

Category ((:~~:) :: k -> k -> Type)	Since: base-4.10.0.0
Instance details Defined in Control.Category Methods id :: forall (a :: k0). a :~~: a # (.) :: forall (b :: k0) (c :: k0) (a :: k0). (b :~~: c) -> (a :~~: b) -> a :~~: c #
TestCoercion ((:~~:) a :: k -> Type)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Coercion Methods testCoercion :: forall (a0 :: k0) (b :: k0). (a :~~: a0) -> (a :~~: b) -> Maybe (Coercion a0 b) #
TestEquality ((:~~:) a :: k -> Type)	Since: base-4.10.0.0
Instance details Defined in Data.Type.Equality Methods testEquality :: forall (a0 :: k0) (b :: k0). (a :~~: a0) -> (a :~~: b) -> Maybe (a0 :~: b) #
(Typeable i, Typeable j, Typeable a, Typeable b, a ~~ b) => Data (a :~~: b)	Since: base-4.10.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~~: b) -> c (a :~~: b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~~: b) # toConstr :: (a :~~: b) -> Constr # dataTypeOf :: (a :~~: b) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~~: b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~~: b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~~: b) -> a :~~: b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~~: b) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~~: b) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a :~~: b) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~~: b) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) #
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 #
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] #
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] #
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 #
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 #
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 #

data (a :: k) :~: (b :: k) where infix 4 #

Propositional equality. If a :~: b is inhabited by some terminating value, then the type a is the same as the type b. To use this equality in practice, pattern-match on the a :~: b to get out the Refl constructor; in the body of the pattern-match, the compiler knows that a ~ b.

Since: base-4.7.0.0

Constructors

Refl :: forall {k} (a :: k). a :~: a

Instances

Instances details

Category ((:~:) :: k -> k -> Type)	Since: base-4.7.0.0
Instance details Defined in Control.Category Methods id :: forall (a :: k0). a :~: a # (.) :: forall (b :: k0) (c :: k0) (a :: k0). (b :~: c) -> (a :~: b) -> a :~: c #
TestCoercion ((:~:) a :: k -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Coercion Methods testCoercion :: forall (a0 :: k0) (b :: k0). (a :~: a0) -> (a :~: b) -> Maybe (Coercion a0 b) #
TestEquality ((:~:) a :: k -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Type.Equality Methods testEquality :: forall (a0 :: k0) (b :: k0). (a :~: a0) -> (a :~: b) -> Maybe (a0 :~: b) #
(a ~ b, Data a) => Data (a :~: b)	Since: base-4.7.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~: b) -> c (a :~: b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~: b) # toConstr :: (a :~: b) -> Constr # dataTypeOf :: (a :~: b) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~: b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~: b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~: b) -> a :~: b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r # gmapQ :: (forall d. Data d => d -> u) -> (a :~: b) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~: b) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (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 #
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] #
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] #
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 #
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 #
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 #

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

MFunctor (ExceptT e :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Morph Methods hoist :: forall m n (b :: k). Monad m => (forall a. m a -> n a) -> ExceptT e m b -> ExceptT e n b #
MMonad (ExceptT e)
Instance details Defined in Control.Monad.Morph Methods embed :: forall (n :: Type -> Type) m b. Monad n => (forall a. m a -> ExceptT e n a) -> ExceptT e m b -> ExceptT e n b #
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 #
(Data e, Finite e, Launchable m) => Launchable (ExceptT e m) Source #	Upon an exception, the program is restarted. To handle or log the exception, see LiveCoding.LiveProgram.Except.
Instance details Defined in LiveCoding.RuntimeIO.Launch Methods runIO :: LiveProgram (ExceptT e m) -> LiveProgram IO Source #
(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 #
type Rep1 (ExceptT e m :: Type -> Type)
Instance details Defined in Control.Monad.Trans.Instances type Rep1 (ExceptT e m :: Type -> Type) = D1 ('MetaData "ExceptT" "Control.Monad.Trans.Except" "transformers-0.5.6.2" 'True) (C1 ('MetaCons "ExceptT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (m :.: Rec1 (Either e))))
type Rep (ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Instances type Rep (ExceptT e m a) = D1 ('MetaData "ExceptT" "Control.Monad.Trans.Except" "transformers-0.5.6.2" 'True) (C1 ('MetaCons "ExceptT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m (Either e a)))))

mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b #

Map the unwrapped computation using the given function.

runExcept (mapExcept f m) = f (runExcept m)

mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b #

Map the unwrapped computation using the given function.

runExceptT (mapExceptT f m) = f (runExceptT m)

runExcept :: Except e a -> Either e a #

Extractor for computations in the exception monad. (The inverse of except).

runExceptT :: ExceptT e m a -> m (Either e a) #

The inverse of ExceptT.

withExcept :: (e -> e') -> Except e a -> Except e' a #

Transform any exceptions thrown by the computation using the given function (a specialization of withExceptT).

withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a #

Transform any exceptions thrown by the computation using the given function.

type Except e = ExceptT e Identity #

The parameterizable exception monad.

Computations are either exceptions or normal values.

The return function returns a normal value, while >>= exits on the first exception. For a variant that continues after an error and collects all the errors, see Errors.

throwE :: forall (m :: Type -> Type) e a. Monad m => e -> ExceptT e m a #

Signal an exception value e.

```
runExceptT (throwE e) = return (Left e)
```
```
throwE e >>= m = throwE e
```

liftPass :: Monad m => Pass w m (Either e a) -> Pass w (ExceptT e m) a #

Lift a pass operation to the new monad.

liftListen :: Monad m => Listen w m (Either e a) -> Listen w (ExceptT e m) a #

Lift a listen operation to the new monad.

liftCallCC :: CallCC m (Either e a) (Either e b) -> CallCC (ExceptT e m) a b #

Lift a callCC operation to the new monad.

except :: forall (m :: Type -> Type) e a. Monad m => Either e a -> ExceptT e m a #

Constructor for computations in the exception monad. (The inverse of runExcept).

catchE #

Arguments

:: forall (m :: Type -> Type) e a e'. Monad m
=> ExceptT e m a	the inner computation
-> (e -> ExceptT e' m a)	a handler for exceptions in the inner computation
-> ExceptT e' m a

Handle an exception.

```
catchE (lift m) h = lift m
```
```
catchE (throwE e) h = h e
```

data LiveProgram m Source #

Constructors

forall s.Data s => LiveProgram
Fields liveState :: s liveStep :: s -> m s

Instances

Instances details

Monad m => Monoid (LiveProgram m) Source #
Instance details Defined in LiveCoding.LiveProgram Methods mempty :: LiveProgram m # mappend :: LiveProgram m -> LiveProgram m -> LiveProgram m # mconcat :: [LiveProgram m] -> LiveProgram m #
Monad m => Semigroup (LiveProgram m) Source #	`mappend` here is _not_ the migration function! (Compare `migrate`.) This instance simply tuples both states and performs the steps sequentially.
Instance details Defined in LiveCoding.LiveProgram Methods (<>) :: LiveProgram m -> LiveProgram m -> LiveProgram m # sconcat :: NonEmpty (LiveProgram m) -> LiveProgram m # stimes :: Integral b => b -> LiveProgram m -> LiveProgram m #

hoistLiveProgram :: (forall a. m1 a -> m2 a) -> LiveProgram m1 -> LiveProgram m2 Source #

data Choice stateL stateR Source #

Constructors

Choice
Fields choiceLeft :: stateL choiceRight :: stateR

Instances

Instances details

(Data stateL, Data stateR) => Data (Choice stateL stateR) Source #

Instance details

Defined in LiveCoding.Cell

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Choice stateL stateR -> c (Choice stateL stateR) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Choice stateL stateR) #

toConstr :: Choice stateL stateR -> Constr #

dataTypeOf :: Choice stateL stateR -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Choice stateL stateR)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Choice stateL stateR)) #

gmapT :: (forall b. Data b => b -> b) -> Choice stateL stateR -> Choice stateL stateR #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Choice stateL stateR -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Choice stateL stateR -> r #

gmapQ :: (forall d. Data d => d -> u) -> Choice stateL stateR -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Choice stateL stateR -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Choice stateL stateR -> m (Choice stateL stateR) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Choice stateL stateR -> m (Choice stateL stateR) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Choice stateL stateR -> m (Choice stateL stateR) #

data Parallel stateP1 stateP2 Source #

Constructors

Parallel
Fields stateP1 :: stateP1 stateP2 :: stateP2

Instances

Instances details

(Data stateP1, Data stateP2) => Data (Parallel stateP1 stateP2) Source #

Instance details

Defined in LiveCoding.Cell

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Parallel stateP1 stateP2 -> c (Parallel stateP1 stateP2) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Parallel stateP1 stateP2) #

toConstr :: Parallel stateP1 stateP2 -> Constr #

dataTypeOf :: Parallel stateP1 stateP2 -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Parallel stateP1 stateP2)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Parallel stateP1 stateP2)) #

gmapT :: (forall b. Data b => b -> b) -> Parallel stateP1 stateP2 -> Parallel stateP1 stateP2 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parallel stateP1 stateP2 -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parallel stateP1 stateP2 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Parallel stateP1 stateP2 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Parallel stateP1 stateP2 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Parallel stateP1 stateP2 -> m (Parallel stateP1 stateP2) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Parallel stateP1 stateP2 -> m (Parallel stateP1 stateP2) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Parallel stateP1 stateP2 -> m (Parallel stateP1 stateP2) #

type Actuator b = Cell IO b () Source #

type SF a b = forall m. Cell m a b Source #

type Sensor a = Cell IO () a Source #

data Composition state1 state2 Source #

Constructors

Composition
Fields state1 :: state1 state2 :: state2

Instances

Instances details

(Data state1, Data state2) => Data (Composition state1 state2) Source #

Instance details

Defined in LiveCoding.Cell

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Composition state1 state2 -> c (Composition state1 state2) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Composition state1 state2) #

toConstr :: Composition state1 state2 -> Constr #

dataTypeOf :: Composition state1 state2 -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Composition state1 state2)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Composition state1 state2)) #

gmapT :: (forall b. Data b => b -> b) -> Composition state1 state2 -> Composition state1 state2 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Composition state1 state2 -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Composition state1 state2 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Composition state1 state2 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Composition state1 state2 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Composition state1 state2 -> m (Composition state1 state2) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Composition state1 state2 -> m (Composition state1 state2) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Composition state1 state2 -> m (Composition state1 state2) #

data Cell m a b Source #

The basic building block of a live program.

You can build cells directly, by using constructors, or through the Functor, Applicative, or Arrow type classes.

The Cell constructor is the main way build a cell, but for efficiency purposes there is an additional constructor.

Constructors

forall s.Data s => Cell	A cell consists of an internal state, and an effectful state transition function.
Fields cellState :: s cellStep :: s -> a -> m (b, s)
ArrM	Effectively a cell with trivial state. Added to improve performance and keep state types simpler.
Fields runArrM :: a -> m b

Instances

Instances details

Monad m => Category (Cell m :: Type -> TYPE LiftedRep -> Type) Source #
Instance details Defined in LiveCoding.Cell Methods id :: forall (a :: k). Cell m a a # (.) :: forall (b :: k) (c :: k) (a :: k). Cell m b c -> Cell m a b -> Cell m a c #
Monad m => Arrow (Cell m) Source #
Instance details Defined in LiveCoding.Cell Methods arr :: (b -> c) -> Cell m b c # first :: Cell m b c -> Cell m (b, d) (c, d) # second :: Cell m b c -> Cell m (d, b) (d, c) # (***) :: Cell m b c -> Cell m b' c' -> Cell m (b, b') (c, c') # (&&&) :: Cell m b c -> Cell m b c' -> Cell m b (c, c') #
Monad m => ArrowChoice (Cell m) Source #
Instance details Defined in LiveCoding.Cell Methods left :: Cell m b c -> Cell m (Either b d) (Either c d) # right :: Cell m b c -> Cell m (Either d b) (Either d c) # (+++) :: Cell m b c -> Cell m b' c' -> Cell m (Either b b') (Either c c') # (\|\|\|) :: Cell m b d -> Cell m c d -> Cell m (Either b c) d #
MonadFix m => ArrowLoop (Cell m) Source #
Instance details Defined in LiveCoding.Cell Methods loop :: Cell m (b, d) (c, d) -> Cell m b c #

toCell :: Functor m => Cell m a b -> Cell m a b Source #

Converts every Cell to the Cell constructor. Semantically, it is the identity function.

step :: Monad m => Cell m a b -> a -> m (b, Cell m a b) Source #

Execute a cell for one step.

steps :: Monad m => Cell m a b -> [a] -> m ([b], Cell m a b) Source #

Execute a cell for several steps. The number of steps is determined by the length of the list of inputs.

sumC :: (Monad m, Num a, Data a) => Cell m a a Source #

Add all inputs and return the delayed sum.

liveCell :: Monad m => Cell m () () -> LiveProgram m Source #

Convert a cell with no inputs and outputs to a live program. Semantically, this is an isomorphism.

toLiveCell :: Functor m => LiveProgram m -> Cell m () () Source #

The inverse to liveCell.

hoistCell :: (forall x. m1 x -> m2 x) -> Cell m1 a b -> Cell m2 a b Source #

Hoist a Cell along a monad morphism.

buildProg :: Sensor a -> SF a b -> Actuator b -> LiveProgram IO Source #

stepRate :: Num a => a Source #

integrate :: (Data a, Fractional a, Monad m) => Cell m a a Source #

localTime :: (Data a, Fractional a, Monad m) => Cell m b a Source #

liftCell :: (Monad m, MonadTrans t) => Cell m a b -> Cell (t m) a b Source #

Lift a Cell into a monad transformer.

arrM :: (a -> m b) -> Cell m a b Source #

constM :: m b -> Cell m a b Source #

constC :: Monad m => b -> Cell m a b Source #

sine :: MonadFix m => Double -> Cell m () Double Source #

asciiArt :: Double -> String Source #

printEverySecond :: Cell IO String () Source #

printSine :: Double -> LiveProgram IO Source #

newtype CountObserver Source #

Constructors

CountObserver
Fields observe :: IO Integer

data Debugging dbgState state Source #

Constructors

Debugging
Fields state :: state dbgState :: dbgState

Instances

Instances details

(Data dbgState, Data state) => Data (Debugging dbgState state) Source #
Instance details Defined in LiveCoding.Debugger Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Debugging dbgState state -> c (Debugging dbgState state) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Debugging dbgState state) # toConstr :: Debugging dbgState state -> Constr # dataTypeOf :: Debugging dbgState state -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Debugging dbgState state)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Debugging dbgState state)) # gmapT :: (forall b. Data b => b -> b) -> Debugging dbgState state -> Debugging dbgState state # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Debugging dbgState state -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Debugging dbgState state -> r # gmapQ :: (forall d. Data d => d -> u) -> Debugging dbgState state -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Debugging dbgState state -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Debugging dbgState state -> m (Debugging dbgState state) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Debugging dbgState state -> m (Debugging dbgState state) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Debugging dbgState state -> m (Debugging dbgState state) #
(Show state, Show dbgState) => Show (Debugging dbgState state) Source #
Instance details Defined in LiveCoding.Debugger Methods showsPrec :: Int -> Debugging dbgState state -> ShowS # show :: Debugging dbgState state -> String # showList :: [Debugging dbgState state] -> ShowS #
(Eq state, Eq dbgState) => Eq (Debugging dbgState state) Source #
Instance details Defined in LiveCoding.Debugger Methods (==) :: Debugging dbgState state -> Debugging dbgState state -> Bool # (/=) :: Debugging dbgState state -> Debugging dbgState state -> Bool #

newtype Debugger m Source #

Constructors

Debugger
Fields getDebugger :: forall s. Data s => LiveProgram (StateT s m)

Instances

Instances details

Monad m => Monoid (Debugger m) Source #
Instance details Defined in LiveCoding.Debugger Methods mempty :: Debugger m # mappend :: Debugger m -> Debugger m -> Debugger m # mconcat :: [Debugger m] -> Debugger m #
Monad m => Semigroup (Debugger m) Source #
Instance details Defined in LiveCoding.Debugger Methods (<>) :: Debugger m -> Debugger m -> Debugger m # sconcat :: NonEmpty (Debugger m) -> Debugger m # stimes :: Integral b => b -> Debugger m -> Debugger m #

getC :: Monad m => Cell (StateT s m) a s Source #

putC :: Monad m => Cell (StateT s m) s () Source #

gshowDebugger :: Debugger IO Source #

withDebugger :: Monad m => LiveProgram m -> Debugger m -> LiveProgram m Source #

withDebuggerC :: Monad m => Cell m a b -> Debugger m -> Cell m a b Source #

countDebugger :: IO (Debugger IO, CountObserver) Source #

await :: CountObserver -> Integer -> IO () Source #

data Alg m a b where Source #

Constructors

Alg :: s -> AlgStructure m a b s -> Alg m a b

type AlgStructure m a b s = StateTransition m a b s -> s Source #

data Coalg m a b where Source #

Constructors

Coalg :: s -> (s -> StateTransition m a b s) -> Coalg m a b

data MSF m a b Source #

Constructors

MSF
Fields unMSF :: StateTransition m a b (MSF m a b)

type StateTransition m a b s = a -> m (b, s) Source #

finality :: Monad m => Coalg m a b -> MSF m a b Source #

finalityC :: Monad m => Cell m a b -> MSF m a b Source #

coalgebra :: MSF m a b -> Coalg m a b Source #

coalgebraC :: Data (MSF m a b) => MSF m a b -> Cell m a b Source #

algMSF :: MSF m a b -> Alg m a b Source #

initiality :: Functor m => AlgStructure m a b s -> MSF m a b -> s Source #

hoistCellOutput :: (Monad m1, Monad m2) => (forall s. m1 (b1, s) -> m2 (b2, s)) -> Cell m1 a b1 -> Cell m2 a b2 Source #

Apply a monad morphism that also transforms the output to a cell.

hoistCellKleisli_ :: (Monad m1, Monad m2) => (forall s. (a1 -> m1 (b1, s)) -> a2 -> m2 (b2, s)) -> Cell m1 a1 b1 -> Cell m2 a2 b2 Source #

Apply a transformation of Kleisli morphisms to a cell.

hoistCellKleisli :: (Monad m1, Monad m2) => (forall s. (s -> a1 -> m1 (b1, s)) -> s -> a2 -> m2 (b2, s)) -> Cell m1 a1 b1 -> Cell m2 a2 b2 Source #

Apply a transformation of stateful Kleisli morphisms to a cell.

hoistCellKleisliStateChange :: (Monad m1, Monad m2, forall s. Data s => Data (t s)) => (forall s. (s -> a1 -> m1 (b1, s)) -> t s -> a2 -> m2 (b2, t s)) -> (forall s. s -> t s) -> Cell m1 a1 b1 -> Cell m2 a2 b2 Source #

Apply a transformation of stateful Kleisli morphisms to a cell, changing the state type.

resample :: (Monad m, KnownNat n) => Cell m a b -> Cell m (Vector n a) (Vector n b) Source #

Execute the inner cell for n steps per outer step.

resampleList :: Monad m => Cell m a b -> Cell m [a] [b] Source #

Execute the cell for as many steps as the input list is long.

resampleMaybe :: Monad m => Cell m a b -> Cell m (Maybe a) (Maybe b) Source #

resampleListPar :: Monad m => Cell m a b -> Cell m [a] [b] Source #

Create as many cells as the input list is long and execute them in parallel (in the sense that each one has a separate state). At each tick the list with the different states grows or shrinks depending on the size of the input list.

Similar to Yampa's parC.

stateT :: State stateT stateInternal -> stateT Source #

stateInternal :: State stateT stateInternal -> stateInternal Source #

runStateC Source #

Arguments

:: (Data stateT, Monad m)
=> Cell (StateT stateT m) a b	A cell with a state effect
-> stateT	The initial state
-> Cell m a (b, stateT)	The cell, returning its current state

Push effectful state into the internal state of a cell

runStateC_ Source #

Arguments

:: (Data stateT, Monad m)
=> Cell (StateT stateT m) a b	A cell with a state effect
-> stateT	The initial state
-> Cell m a b

Like runStateC, but does not return the current state.

runReaderC :: r -> Cell (ReaderT r m) a b -> Cell m a b Source #

Supply a ReaderT environment before running the cell

runReaderC' :: Monad m => Cell (ReaderT r m) a b -> Cell m (r, a) b Source #

Supply a ReaderT environment live

runWriterC :: (Monoid w, Monad m) => Cell (WriterT w m) a b -> Cell m a (w, b) Source #

Run the effects of the WriterT monad, collecting all its output in the second element of the tuple.

class GFinite f where Source #

Methods

gcommute :: Monad m => (f e -> Cell m a b) -> Cell (ReaderT (f e) m) a b Source #

Instances

Instances details

GFinite (U1 :: Type -> Type) Source #
Instance details Defined in LiveCoding.Exceptions.Finite Methods gcommute :: forall (m :: Type -> Type) e a b. Monad m => (U1 e -> Cell m a b) -> Cell (ReaderT (U1 e) m) a b Source #
GFinite (V1 :: Type -> Type) Source #
Instance details Defined in LiveCoding.Exceptions.Finite Methods gcommute :: forall (m :: Type -> Type) e a b. Monad m => (V1 e -> Cell m a b) -> Cell (ReaderT (V1 e) m) a b Source #
(GFinite e1, GFinite e2) => GFinite (e1 :*: e2) Source #
Instance details Defined in LiveCoding.Exceptions.Finite Methods gcommute :: forall (m :: Type -> Type) e a b. Monad m => ((e1 :: e2) e -> Cell m a b) -> Cell (ReaderT ((e1 :: e2) e) m) a b Source #
(GFinite eL, GFinite eR) => GFinite (eL :+: eR) Source #
Instance details Defined in LiveCoding.Exceptions.Finite Methods gcommute :: forall (m :: Type -> Type) e a b. Monad m => ((eL :+: eR) e -> Cell m a b) -> Cell (ReaderT ((eL :+: eR) e) m) a b Source #
Finite e => GFinite (K1 a e :: Type -> Type) Source #
Instance details Defined in LiveCoding.Exceptions.Finite Methods gcommute :: forall (m :: Type -> Type) e0 a0 b. Monad m => (K1 a e e0 -> Cell m a0 b) -> Cell (ReaderT (K1 a e e0) m) a0 b Source #
GFinite f => GFinite (M1 a b f) Source #
Instance details Defined in LiveCoding.Exceptions.Finite Methods gcommute :: forall (m :: Type -> Type) e a0 b0. Monad m => (M1 a b f e -> Cell m a0 b0) -> Cell (ReaderT (M1 a b f e) m) a0 b0 Source #

class Finite e where Source #

A type class for datatypes on which exception handling can branch statically.

These are exactly finite algebraic datatypes, i.e. those defined from sums and products without recursion. If you have a datatype with a Data instance, and there is no recursion in it, then it is probably finite.

Let us assume your data type is:

data Foo = Bar | Baz { baz1 :: Bool, baz2 :: Maybe () }

To define the instance you need to add these two lines of boilerplate (possibly you need to import GHC.Generics and enable some language extensions):

deriving instance Generic Foo
instance Finite Foo

Minimal complete definition

Nothing

Methods

commute :: Monad m => (e -> Cell m a b) -> Cell (ReaderT e m) a b Source #

default commute :: (Generic e, GFinite (Rep e), Monad m) => (e -> Cell m a b) -> Cell (ReaderT e m) a b Source #

Instances

Instances details

Finite Void Source #
Instance details Defined in LiveCoding.Exceptions.Finite Methods commute :: forall (m :: Type -> Type) a b. Monad m => (Void -> Cell m a b) -> Cell (ReaderT Void m) a b Source #
Finite () Source #
Instance details Defined in LiveCoding.Exceptions.Finite Methods commute :: forall (m :: Type -> Type) a b. Monad m => (() -> Cell m a b) -> Cell (ReaderT () m) a b Source #
Finite Bool Source #
Instance details Defined in LiveCoding.Exceptions.Finite Methods commute :: forall (m :: Type -> Type) a b. Monad m => (Bool -> Cell m a b) -> Cell (ReaderT Bool m) a b Source #
(Finite e1, Finite e2) => Finite (Either e1 e2) Source #
Instance details Defined in LiveCoding.Exceptions.Finite Methods commute :: forall (m :: Type -> Type) a b. Monad m => (Either e1 e2 -> Cell m a b) -> Cell (ReaderT (Either e1 e2) m) a b Source #

data ExceptState state e Source #

Constructors

NotThrown state
Exception e

Instances

Instances details

(Data state, Data e) => Data (ExceptState state e) Source #

Instance details

Defined in LiveCoding.Exceptions

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExceptState state e -> c (ExceptState state e) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExceptState state e) #

toConstr :: ExceptState state e -> Constr #

dataTypeOf :: ExceptState state e -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ExceptState state e)) #

dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (ExceptState state e)) #

gmapT :: (forall b. Data b => b -> b) -> ExceptState state e -> ExceptState state e #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExceptState state e -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExceptState state e -> r #

gmapQ :: (forall d. Data d => d -> u) -> ExceptState state e -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExceptState state e -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExceptState state e -> m (ExceptState state e) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExceptState state e -> m (ExceptState state e) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExceptState state e -> m (ExceptState state e) #

throwC :: Monad m => Cell (ExceptT e m) e arbitrary Source #

wait :: Monad m => Double -> Cell (ExceptT () m) a a Source #

throwIf :: Monad m => (a -> Bool) -> e -> Cell (ExceptT e m) a a Source #

throwIf_ :: Monad m => (a -> Bool) -> Cell (ExceptT () m) a a Source #

exceptC :: Monad m => Cell (ExceptT e m) (Either e a) a Source #

When the incoming value is Right a, forward it. When it is Left e, throw it as an exception. Compare with except.

runExceptC :: (Data e, Monad m) => Cell (ExceptT e m) a b -> Cell m a (Either e b) Source #

(>>>=) :: (Data e1, Monad m) => Cell (ExceptT e1 m) a b -> Cell (ExceptT e2 m) (e1, a) b -> Cell (ExceptT e2 m) a b Source #

(>>>==) :: (Data e1, Monad m) => Cell (ExceptT e1 m) a b -> Cell (ReaderT e1 (ExceptT e2 m)) a b -> Cell (ExceptT e2 m) a b Source #

data CellExcept a b m e where Source #

Constructors

Return :: e -> CellExcept a b m e
Bind :: CellExcept a b m e1 -> (e1 -> CellExcept a b m e2) -> CellExcept a b m e2
Try :: (Data e, Finite e) => Cell (ExceptT e m) a b -> CellExcept a b m e

Instances

Instances details

MFunctor (CellExcept a b :: (Type -> Type) -> TYPE LiftedRep -> Type) Source #
Instance details Defined in LiveCoding.CellExcept Methods hoist :: forall m n (b0 :: k). Monad m => (forall a0. m a0 -> n a0) -> CellExcept a b m b0 -> CellExcept a b n b0 #
Monad m => Applicative (CellExcept a b m) Source #
Instance details Defined in LiveCoding.CellExcept Methods pure :: a0 -> CellExcept a b m a0 # (<>) :: CellExcept a b m (a0 -> b0) -> CellExcept a b m a0 -> CellExcept a b m b0 # liftA2 :: (a0 -> b0 -> c) -> CellExcept a b m a0 -> CellExcept a b m b0 -> CellExcept a b m c # (>) :: CellExcept a b m a0 -> CellExcept a b m b0 -> CellExcept a b m b0 # (<*) :: CellExcept a b m a0 -> CellExcept a b m b0 -> CellExcept a b m a0 #
Monad m => Functor (CellExcept a b m) Source #
Instance details Defined in LiveCoding.CellExcept Methods fmap :: (a0 -> b0) -> CellExcept a b m a0 -> CellExcept a b m b0 # (<$) :: a0 -> CellExcept a b m b0 -> CellExcept a b m a0 #
Monad m => Monad (CellExcept a b m) Source #
Instance details Defined in LiveCoding.CellExcept Methods (>>=) :: CellExcept a b m a0 -> (a0 -> CellExcept a b m b0) -> CellExcept a b m b0 # (>>) :: CellExcept a b m a0 -> CellExcept a b m b0 -> CellExcept a b m b0 # return :: a0 -> CellExcept a b m a0 #

runCellExcept :: Monad m => CellExcept a b m e -> Cell (ExceptT e m) a b Source #

try :: (Data e, Finite e) => Cell (ExceptT e m) a b -> CellExcept a b m e Source #

safely :: Monad m => CellExcept a b m Void -> Cell m a b Source #

discardVoid :: Functor m => ExceptT Void m a -> m a Source #

safe :: Monad m => Cell m a b -> CellExcept a b m Void Source #

once :: (Monad m, Data e, Finite e) => (a -> m e) -> CellExcept a arbitrary m e Source #

Run a monadic action and immediately raise its result as an exception.

once_ :: (Monad m, Data e, Finite e) => m e -> CellExcept a arbitrary m e Source #

Like once, but the action does not have an input.

data Feedback sPrevious sAdditional Source #

Constructors

Feedback
Fields sPrevious :: sPrevious sAdditional :: sAdditional

Instances

Instances details

(Data sPrevious, Data sAdditional) => Data (Feedback sPrevious sAdditional) Source #

Instance details

Defined in LiveCoding.Cell.Feedback

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Feedback sPrevious sAdditional -> c (Feedback sPrevious sAdditional) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Feedback sPrevious sAdditional) #

toConstr :: Feedback sPrevious sAdditional -> Constr #

dataTypeOf :: Feedback sPrevious sAdditional -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Feedback sPrevious sAdditional)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Feedback sPrevious sAdditional)) #

gmapT :: (forall b. Data b => b -> b) -> Feedback sPrevious sAdditional -> Feedback sPrevious sAdditional #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Feedback sPrevious sAdditional -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Feedback sPrevious sAdditional -> r #

gmapQ :: (forall d. Data d => d -> u) -> Feedback sPrevious sAdditional -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Feedback sPrevious sAdditional -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Feedback sPrevious sAdditional -> m (Feedback sPrevious sAdditional) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Feedback sPrevious sAdditional -> m (Feedback sPrevious sAdditional) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Feedback sPrevious sAdditional -> m (Feedback sPrevious sAdditional) #

feedback :: (Monad m, Data s) => s -> Cell m (a, s) (b, s) -> Cell m a b Source #

delay :: (Data s, Monad m) => s -> Cell m s s Source #

sumFeedback :: (Monad m, Num a, Data a) => Cell m a a Source #

data BufferCommand a Source #

A command to send to buffer.

Constructors

Push a	Add an `a` to the buffer.
Pop	Remove the oldest element from the buffer.

sumFrom :: Monad m => Integer -> Cell m Integer Integer Source #

Sum all past inputs, starting by the given number

count :: Monad m => Cell m a Integer Source #

Count the number of ticks, starting at 0

foldC :: (Data b, Monad m) => (a -> b -> b) -> b -> Cell m a b Source #

Accumulate all incoming data, using the given fold function and start value. For example, if foldC f b receives inputs a0, a1,... it will output b, f a0 b, f a1 $ f a0 b, and so on.

foldC' :: (Data b, Monad m) => (a -> b -> b) -> b -> Cell m a b Source #

Like foldC, but does not delay the output.

hold :: (Data a, Monad m) => a -> Cell m (Maybe a) a Source #

Initialise with a value a. If the input is Nothing, hold a will output the stored indefinitely. A new value can be stored by inputting Just a.

changes :: (Data a, Eq a, Monad m) => Cell m a (Maybe a) Source #

Outputs Just a whenever the the value a changes and Nothing otherwise. The first output is always Nothing. The following holds:

   delay a >>> changes >>> hold a == delay a

holdJust :: (Monad m, Data a) => Cell m (Maybe a) (Maybe a) Source #

Like hold, but returns Nothing until it is initialised by a Just a value.

holdFirst :: (Data a, Monad m) => Cell m a a Source #

Hold the first value and output it indefinitely.

boundedFIFO :: (Data a, Monad m) => Int -> Cell m (Maybe a) (Seq a) Source #

boundedFIFO n keeps the first n present values.

fifo :: (Monad m, Data a) => Cell m (Seq a) (Maybe a) Source #

Buffers and returns the elements in First-In-First-Out order, returning Nothing whenever the buffer is empty.

fifoList :: (Monad m, Data a) => Cell m [a] (Maybe a) Source #

Like fifo, but accepts lists as input. Each step is O(n) in the length of the list.

fifoFoldable :: (Monad m, Data a, Foldable f) => Cell m (f a) (Maybe a) Source #

Like fifoList, but generalised to any Foldable.

edge :: Monad m => Cell m Bool Bool Source #

Returns True iff the current input value is True and the last input value was False.

printTime :: MonadIO m => String -> m () Source #

Print the current UTC time, prepended with the first 8 characters of the given message.

printTimeC :: MonadIO m => String -> Cell m () () Source #

Like printTime, but as a cell.

maybePush :: Maybe a -> [BufferCommand a] Source #

Pushes Just a and does nothing on Nothing.

maybePop :: Maybe a -> [BufferCommand b] Source #

Pops on Just a and does nothing on Nothing.

buffer :: (Monad m, Data a) => Cell m [BufferCommand a] (Maybe a) Source #

Single-consumer, multi-producer buffer.

The output value is the oldest value in the buffer, if it exists.

Add elements by inputting Push a.
Remove elements by inputting Pop.

buffered :: (Monad m, Data a) => Cell m (Maybe a) (Maybe b) -> Cell m (Maybe a) (Maybe b) Source #

Equip a Cell with a buffer.

Whenever Just a value enters buffered cell, it is added to the buffer.
Whenever cell emits Just b, the oldest value is dropped from the buffer.
cell is always fed with Just the oldest value from the buffer, except when the buffer is empty, then it is fed Nothing.

This construction guarantees that cell produces exactly one output for every input value.

onChange Source #

Arguments

:: (Monad m, Data p, Eq p)
=> p	This parameter has to change during live coding to trigger an action
-> (p -> p -> a -> m b)	This action gets passed the old parameter and the new parameter
-> Cell m a (Maybe b)

Perform an action whenever the parameter p changes, and the code is reloaded.

Note that this does not trigger any actions when adding, or removing an onChange cell. For this functionality, see LiveCoding.Handle. Also, when moving such a cell, the action may not be triggered reliably.

onChange' Source #

Arguments

:: (Monad m, Data p, Eq p)
=> (p -> p -> a -> m b)	This action gets passed the old parameter and the new parameter
-> Cell m (p, a) (Maybe b)

Like onChange', but with a dynamic input.

throwWhen0 :: Monad m => Cell (ExceptT () m) Double Double Source #

sineChangeE :: CellExcept () Double IO Void Source #

sineWait :: Double -> CellExcept () String IO Void Source #

printSineWait :: LiveProgram IO Source #

data ForeverE e s Source #

Constructors

ForeverE
Fields lastException :: e initState :: s currentState :: s

Instances

Instances details

(Data e, Data s) => Data (ForeverE e s) Source #

Instance details

Defined in LiveCoding.Forever

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeverE e s -> c (ForeverE e s) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeverE e s) #

toConstr :: ForeverE e s -> Constr #

dataTypeOf :: ForeverE e s -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeverE e s)) #

dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (ForeverE e s)) #

gmapT :: (forall b. Data b => b -> b) -> ForeverE e s -> ForeverE e s #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeverE e s -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeverE e s -> r #

gmapQ :: (forall d. Data d => d -> u) -> ForeverE e s -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeverE e s -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeverE e s -> m (ForeverE e s) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeverE e s -> m (ForeverE e s) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeverE e s -> m (ForeverE e s) #

sinesWaitAndTry :: MonadFix m => CellExcept () String m () Source #

sinesForever' :: MonadFix m => CellExcept () String m Void Source #

foreverE :: (Monad m, Data e) => e -> Cell (ReaderT e (ExceptT e m)) a b -> Cell m a b Source #

foreverC :: (Data e, Monad m) => Cell (ExceptT e m) a b -> Cell m a b Source #

sinesForever :: MonadFix m => Cell m () String Source #

printSinesForever :: LiveProgram IO Source #

newtype Q q x Source #

Constructors

Q
Fields unQ :: x -> q

statePrint :: Debugger IO Source #

stateShow :: Data s => s -> String Source #

isUnit :: Data s => s -> Bool Source #

compositionShow :: (Data s1, Data s2) => Composition s1 s2 -> String Source #

parallelShow :: (Data s1, Data s2) => Parallel s1 s2 -> String Source #

foreverEShow :: (Data e, Data s) => ForeverE e s -> String Source #

feedbackShow :: (Data state, Data s) => Feedback state s -> String Source #

exceptShow :: (Data s, Data e) => ExceptState s e -> String Source #

choiceShow :: (Data stateL, Data stateR) => Choice stateL stateR -> String Source #

gcast3 :: forall f t t' a b c. (Typeable t, Typeable t') => f (t a b c) -> Maybe (f (t' a b c)) Source #

ext3 :: (Data a, Data b, Data c, Data d, Typeable t, Typeable f) => f a -> f (t b c d) -> f a Source #

ext3Q :: (Data a, Data b, Data c, Data d, Typeable t, Typeable q) => (a -> q) -> (t b c d -> q) -> a -> q Source #

runStateL :: (Data stateT, Monad m) => LiveProgram (StateT stateT m) -> stateT -> LiveProgram m Source #

Remove a stateful effect from the monad stack by supplying the initial state. This state then becomes part of the internal live program state, and is subject to migration as any other state. Live programs are automatically migrated to and from applications of runStateL.

isRegistered :: Destructor m -> Bool Source #

type HandlingStateT m = StateT (HandlingState m) m Source #

In this monad, handles can be registered, and their destructors automatically executed. It is basically a monad in which handles are automatically garbage collected.

data HandlingState m Source #

Hold a map of registered handle keys and destructors

Constructors

HandlingState
Fields nHandles :: Key destructors :: Destructors m

Instances

Instances details

Typeable m => Data (HandlingState m) Source #
Instance details Defined in LiveCoding.HandlingState Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HandlingState m -> c (HandlingState m) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HandlingState m) # toConstr :: HandlingState m -> Constr # dataTypeOf :: HandlingState m -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HandlingState m)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HandlingState m)) # gmapT :: (forall b. Data b => b -> b) -> HandlingState m -> HandlingState m # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HandlingState m -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HandlingState m -> r # gmapQ :: (forall d. Data d => d -> u) -> HandlingState m -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HandlingState m -> u # gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> HandlingState m -> m0 (HandlingState m) # gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> HandlingState m -> m0 (HandlingState m) # gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> HandlingState m -> m0 (HandlingState m) #
(Typeable m, Launchable m) => Launchable (HandlingStateT m) Source #
Instance details Defined in LiveCoding.RuntimeIO.Launch Methods runIO :: LiveProgram (HandlingStateT m) -> LiveProgram IO Source #

data Handling h Source #

Constructors

Handling
Fields key :: Key handle :: h

runHandlingStateT :: Monad m => HandlingStateT m a -> m a Source #

Handle the HandlingStateT effect _without_ garbage collection. Apply this to your main loop after calling foreground. Since there is no garbage collection, don't use this function for live coding.

runHandlingStateC :: forall m a b. (Monad m, Typeable m) => Cell (HandlingStateT m) a b -> Cell m a b Source #

Apply this to your main live cell before passing it to the runtime.

On the first tick, it initialises the HandlingState at "no handles".

On every step, it does:

Unregister all handles
Register currently present handles
Destroy all still unregistered handles (i.e. those that were removed in the last tick)

runHandlingState :: (Monad m, Typeable m) => LiveProgram (HandlingStateT m) -> LiveProgram m Source #

Like runHandlingStateC, but for whole live programs.

data Migration Source #

Constructors

Migration
Fields runMigration :: forall a b. (Data a, Data b) => a -> b -> Maybe a

Instances

Instances details

Monoid Migration Source #
Instance details Defined in LiveCoding.Migrate.Migration Methods mempty :: Migration # mappend :: Migration -> Migration -> Migration # mconcat :: [Migration] -> Migration #
Semigroup Migration Source #	If both migrations would succeed, the result from the first is used.
Instance details Defined in LiveCoding.Migrate.Migration Methods (<>) :: Migration -> Migration -> Migration # sconcat :: NonEmpty Migration -> Migration # stimes :: Integral b => b -> Migration -> Migration #

runSafeMigration :: (Data a, Data b) => Migration -> a -> b -> a Source #

Run a migration and insert the new initial state in case of failure.

castMigration :: Migration Source #

Try to migrate by casting the first type into the second

newtypeMigration :: Migration Source #

Migrate a value into a newtype wrapping

userMigration :: (Typeable c, Typeable d) => (c -> d) -> Migration Source #

If you have a specific type that you would like to be migrated to a specific other type, you can create a migration for this. For example: userMigration (toInteger :: Int -> Integer)

migrationTo2 :: Typeable t => (forall a b c. (Typeable a, Typeable b, Typeable c) => t b c -> a -> Maybe (t b c)) -> Migration Source #

constMigrationFrom2 :: Typeable t => (forall a b c. (Typeable a, Typeable b, Typeable c) => t b c -> Maybe a) -> Migration Source #

migrationTo1 :: Typeable t => (forall a b. (Typeable a, Typeable b) => t b -> a -> Maybe (t b)) -> Migration Source #

maybeMigrateToDebugging :: (Typeable state', Typeable state) => Debugging dbgState state -> state' -> Maybe (Debugging dbgState state) Source #

migrationToDebugging :: Migration Source #

Tries to cast the current state into the joint state of debugger and program.

maybeMigrateFromDebugging :: (Typeable state', Typeable state) => Debugging dbgState state -> Maybe state' Source #

migrationFromDebugging :: Migration Source #

Try to extract a state from the current joint state of debugger and program.

migrationDebugging :: Migration Source #

Combines migrationToDebugging and migrationFromDebugging.

newtype GenericR' m Source #

Constructors

GR
Fields unGR :: GenericR m

migrate :: (Data a, Data b) => a -> b -> a Source #

The standard migration solution, recursing into the data structure and applying standardMigration.

migrateWith :: (Data a, Data b) => Migration -> a -> b -> a Source #

Still recurse into the data structure, but apply your own given migration. Often you will want to call migrateWith (standardMigration <> yourMigration).

standardMigration :: Migration Source #

Covers standard cases such as matching types, to and from debuggers, to newtypes.

treeMigration :: Migration -> Migration Source #

The standard migration working horse. Tries to apply the given migration, and if this fails, tries to recurse into the data structure.

matchingAlgebraicDataTypes :: (Data a, Data b) => a -> b -> Bool Source #

sameConstructorMigration :: Migration -> Migration Source #

Assuming that both are algebraic data types, possibly the constructor names match. In that case, we will try and recursively migrate as much data as possible onto the new constructor.

constructorMigration :: Migration -> Migration Source #

Still assuming that both are algebraic data types, but the constructor names don't match. In that case, we will try and recursively fill all the fields new constructor. If this doesn't work, fail.

tryOneField :: Data a => StateT [GenericR' Maybe] Maybe a Source #

getChildrenSetters :: Data a => Migration -> a -> [GenericT'] Source #

getChildrenMaybe :: Data a => a -> [GenericR' Maybe] Source #

setChildren :: Data a => [GenericT'] -> a -> a Source #

hotCodeSwap :: LiveProgram m -> LiveProgram m -> LiveProgram m Source #

hotCodeSwapCell :: Cell m a b -> Cell m a b -> Cell m a b Source #

data NoMigration a Source #

Isomorphic to Maybe a but has a different Data instance. The Data instance for NoMigration a doesn't require a Data instance for a.

If a data type is wrapped in NoMigration then it can be used as the state of a Cell without requiring it to have a Data instance. The consequence is that if the type has changed in between a livereload, then the previous saved value will be discarded, and no migration attempt will happen.

Constructors

Initialized a
Uninitialized

Instances

Instances details

Foldable NoMigration Source #
Instance details Defined in LiveCoding.Migrate.NoMigration Methods fold :: Monoid m => NoMigration m -> m # foldMap :: Monoid m => (a -> m) -> NoMigration a -> m # foldMap' :: Monoid m => (a -> m) -> NoMigration a -> m # foldr :: (a -> b -> b) -> b -> NoMigration a -> b # foldr' :: (a -> b -> b) -> b -> NoMigration a -> b # foldl :: (b -> a -> b) -> b -> NoMigration a -> b # foldl' :: (b -> a -> b) -> b -> NoMigration a -> b # foldr1 :: (a -> a -> a) -> NoMigration a -> a # foldl1 :: (a -> a -> a) -> NoMigration a -> a # toList :: NoMigration a -> [a] # null :: NoMigration a -> Bool # length :: NoMigration a -> Int # elem :: Eq a => a -> NoMigration a -> Bool # maximum :: Ord a => NoMigration a -> a # minimum :: Ord a => NoMigration a -> a # sum :: Num a => NoMigration a -> a # product :: Num a => NoMigration a -> a #
Traversable NoMigration Source #
Instance details Defined in LiveCoding.Migrate.NoMigration Methods traverse :: Applicative f => (a -> f b) -> NoMigration a -> f (NoMigration b) # sequenceA :: Applicative f => NoMigration (f a) -> f (NoMigration a) # mapM :: Monad m => (a -> m b) -> NoMigration a -> m (NoMigration b) # sequence :: Monad m => NoMigration (m a) -> m (NoMigration a) #
Functor NoMigration Source #
Instance details Defined in LiveCoding.Migrate.NoMigration Methods fmap :: (a -> b) -> NoMigration a -> NoMigration b # (<$) :: a -> NoMigration b -> NoMigration a #
Typeable a => Data (NoMigration a) Source #	The Data instance for `NoMigration a` doesn't require a `Data` instance for `a`.
Instance details Defined in LiveCoding.Migrate.NoMigration Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NoMigration a -> c (NoMigration a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NoMigration a) # toConstr :: NoMigration a -> Constr # dataTypeOf :: NoMigration a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NoMigration a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NoMigration a)) # gmapT :: (forall b. Data b => b -> b) -> NoMigration a -> NoMigration a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NoMigration a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NoMigration a -> r # gmapQ :: (forall d. Data d => d -> u) -> NoMigration a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NoMigration a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NoMigration a -> m (NoMigration a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NoMigration a -> m (NoMigration a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NoMigration a -> m (NoMigration a) #
Show a => Show (NoMigration a) Source #
Instance details Defined in LiveCoding.Migrate.NoMigration Methods showsPrec :: Int -> NoMigration a -> ShowS # show :: NoMigration a -> String # showList :: [NoMigration a] -> ShowS #
Eq a => Eq (NoMigration a) Source #
Instance details Defined in LiveCoding.Migrate.NoMigration Methods (==) :: NoMigration a -> NoMigration a -> Bool # (/=) :: NoMigration a -> NoMigration a -> Bool #

fromNoMigration :: a -> NoMigration a -> a Source #

dataTypeNoMigration :: DataType Source #

initializedConstr :: Constr Source #

uninitializedConstr :: Constr Source #

arrChangesM :: (Monad m, Typeable a, Typeable b, Eq a) => (a -> m b) -> Cell m a b Source #

Caching version of arrM.

Only runs the computation in m when the input value changes. Meanwhile it keeps outputing the last outputted value. Also runs the computation on the first tick. Does not require Data instance. On `:livereload` will run action again on first tick.

cellNoMigration :: (Typeable s, Functor m) => s -> (s -> a -> m (b, s)) -> Cell m a b Source #

data ParametrisedHandle p m h Source #

Generalisation of Handle carrying an additional parameter which may change at runtime.

Like in a Handle, the h value of a ParametrisedHandle is preserved through live coding reloads. Additionally, the parameter p value can be adjusted, and triggers a destruction and reinitialisation whenever it changes.

Constructors

ParametrisedHandle
Fields createParametrised :: p -> m h changeParametrised :: p -> p -> h -> m h destroyParametrised :: p -> h -> m ()

Instances

Instances details

MFunctor (ParametrisedHandle p :: (TYPE LiftedRep -> Type) -> TYPE LiftedRep -> Type) Source #
Instance details Defined in LiveCoding.Handle Methods hoist :: forall m n (b :: k). Monad m => (forall a. m a -> n a) -> ParametrisedHandle p m b -> ParametrisedHandle p n b #

data Handle m h Source #

Container for unserialisable values, such as IORefs, threads, MVars, pointers, and device handles.

In a Handle, you can store a mechanism to create and destroy a value that survives reloads occuring during live coding even if does not have a Data instance. Using the function handling, you can create a cell that will automatically initialise your value, and register it in the HandlingStateT monad transformer, which takes care of automatically destroying it (if necessary) when it does not occur anymore in a later revision of your live program.

Have a look at Examples for some ready-to-use implementations.

In short, Handle is an opaque, automatically constructing and garbage collecting container for arbitrary values in the live coding environment.

Constructors

Handle
Fields create :: m h destroy :: h -> m ()

Instances

Instances details

MFunctor Handle Source #
Instance details Defined in LiveCoding.Handle Methods hoist :: forall m n (b :: k). Monad m => (forall a. m a -> n a) -> Handle m b -> Handle n b #

combineHandles :: Applicative m => Handle m h1 -> Handle m h2 -> Handle m (h1, h2) Source #

Combine two handles to one.

Handles are not quite Monoids because of the extra type parameter, but it is possible to combine them. In the combined handle, the first handle is created first and destroyed last.

Note: Handle is not an Applicative because it is not a Functor (because the destructor is contravariant in h).

handling :: (Typeable h, Monad m) => Handle m h -> Cell (HandlingStateT m) arbitrary h Source #

Hide a handle in a cell, taking care of initialisation and destruction.

Upon the first tick (or directly after migration), the create method of the Handle is called, and the result stored. This result is then not changed anymore until the cell is removed again. Once it is removed, the destructor will be called on the next tick.

Migrations will by default not inspect the interior of a handling cell. This means that handles are only migrated if they have exactly the same type.

defaultChange :: (Eq p, Monad m) => (p -> m h) -> (p -> h -> m ()) -> p -> p -> h -> m h Source #

Given the methods createParametrised and destroyParametrised, build a fitting method for changeParametrised which

combineParametrisedHandles :: Applicative m => ParametrisedHandle p1 m h1 -> ParametrisedHandle p2 m h2 -> ParametrisedHandle (p1, p2) m (h1, h2) Source #

Like combineHandles, but for ParametrisedHandles.

handlingParametrised :: (Typeable h, Typeable p, Monad m, Eq p) => ParametrisedHandle p m h -> Cell (HandlingStateT m) p h Source #

Hide a ParametrisedHandle in a cell, taking care of initialisation and destruction.

Upon the first tick, directly after migration, and after each parameter change, the create method of the Handle is called, and the result stored. This result is then not changed anymore until the cell is removed again, or the parameter changes. A parameter change triggers the destructor immediately, but if the cell is removed, the destructor will be called on the next tick.

Migrations will by default not inspect the interior of a handling cell. This means that parametrised handles are only migrated if they have exactly the same type.

toParametrised :: Monad m => Handle m h -> ParametrisedHandle () m h Source #

Every Handle is trivially a ParametrisedHandle when the parameter is the trivial type.

ioRefHandle :: a -> Handle IO (IORef a) Source #

Create an IORef, with no special cleanup action.

emptyMVarHandle :: Handle IO (MVar a) Source #

Create an uninitialised MVar, with no special cleanup action.

newMVarHandle :: a -> Handle IO (MVar a) Source #

Create an MVar initialised to some value a, with no special cleanup action.

threadHandle :: IO () -> Handle IO ThreadId Source #

Launch a thread executing the given action and kill it when the handle is removed.

nonBlocking Source #

Arguments

:: Typeable b
=> Bool	Pass `True` to abort the computation when new data arrives. `False` discards new data.
-> Cell IO a b
-> Cell (HandlingStateT IO) (Maybe a) (Maybe b)

Wrap a cell in a non-blocking way. Every incoming sample of nonBlocking cell results in an immediate output, either Just b if the value was computed since the last poll, or Nothing if no new value was computed yet. The resulting cell can be polled by sending Nothing. The boolean flag controls whether the current computation is aborted and restarted when new data arrives.

data LaunchedProgram (m :: * -> *) Source #

A launched LiveProgram and the thread in which it is running.

Constructors

LaunchedProgram
Fields programVar :: MVar (LiveProgram IO) threadId :: ThreadId

class Monad m => Launchable m where Source #

Monads in which live programs can be launched in IO, for example when you have special effects that have to be handled on every reload.

The only thing necessary is to transform the LiveProgram into one in the IO monad, and the rest is taken care of in the framework.

Methods

runIO :: LiveProgram m -> LiveProgram IO Source #

Instances

Instances details

Launchable IO Source #
Instance details Defined in LiveCoding.RuntimeIO.Launch Methods runIO :: LiveProgram IO -> LiveProgram IO Source #
(Typeable m, Launchable m) => Launchable (HandlingStateT m) Source #
Instance details Defined in LiveCoding.RuntimeIO.Launch Methods runIO :: LiveProgram (HandlingStateT m) -> LiveProgram IO Source #
(Data e, Finite e, Launchable m) => Launchable (ExceptT e m) Source #	Upon an exception, the program is restarted. To handle or log the exception, see LiveCoding.LiveProgram.Except.
Instance details Defined in LiveCoding.RuntimeIO.Launch Methods runIO :: LiveProgram (ExceptT e m) -> LiveProgram IO Source #

liveMain :: Launchable m => LiveProgram m -> IO () Source #

The standard top level main for a live program.

Typically, you will define a top level LiveProgram in some monad like HandlingStateT IO, and then add these two lines of boiler plate:

main :: IO ()
main = liveMain liveProgram

launch :: Launchable m => LiveProgram m -> IO (LaunchedProgram m) Source #

Launch a LiveProgram in a separate thread.

The MVar can be used to update the program while automatically migrating it. The ThreadId represents the thread where the program runs in. You're advised not to kill it directly, but to run stop instead.

update :: Launchable m => LaunchedProgram m -> LiveProgram m -> IO () Source #

Migrate (using hotCodeSwap) the LiveProgram to a new version.

stop :: Launchable m => LaunchedProgram m -> IO () Source #

Stops a thread where a LiveProgram is being executed.

Before the thread is killed, an empty program (in the monad m) is first inserted and stepped. This can be used to call cleanup actions encoded in the monad, such as HandlingStateT.

launchWithDebugger :: (Monad m, Launchable m) => LiveProgram m -> Debugger m -> IO (LaunchedProgram m) Source #

Launch a LiveProgram, but first attach a debugger to it.

background :: MVar (LiveProgram IO) -> IO () Source #

This is the background task executed by launch.

stepProgram :: Monad m => LiveProgram m -> m (LiveProgram m) Source #

Advance a LiveProgram by a single step.

stepLaunchedProgram :: (Monad m, Launchable m) => LaunchedProgram m -> IO () Source #

Advance a launched LiveProgram by a single step and store the result.

foreground :: Monad m => LiveProgram m -> m () Source #