packages feed

dmcc 1.0.0.1 → 1.1.0.0

raw patch · 8 files changed

+50/−51 lines, 8 filesdep ~aesondep ~basedep ~classy-preludePVP ok

version bump matches the API change (PVP)

Dependency ranges changed: aeson, base, classy-prelude, containers, lens, network, stm

API changes (from Hackage documentation)

- DMCC: Plain :: ConnectionType
- DMCC: TLS :: Maybe FilePath -> ConnectionType
- DMCC: [caDir] :: ConnectionType -> Maybe FilePath
- DMCC: data ConnectionType
- DMCC.Agent: instance GHC.Exception.Exception DMCC.Agent.AgentError
- DMCC.Session: Plain :: ConnectionType
- DMCC.Session: TLS :: Maybe FilePath -> ConnectionType
- DMCC.Session: [caDir] :: ConnectionType -> Maybe FilePath
- DMCC.Session: data ConnectionType
- DMCC.Session: instance GHC.Exception.Exception DMCC.Session.DMCCError
+ DMCC.Agent: instance GHC.Exception.Type.Exception DMCC.Agent.AgentError
+ DMCC.Prelude: ($!!) :: NFData a => (a -> b) -> a -> b
+ DMCC.Prelude: ($!) :: () => (a -> b) -> a -> b
+ DMCC.Prelude: ($) :: () => (a -> b) -> a -> b
+ DMCC.Prelude: ($>) :: Functor f => f a -> b -> f b
+ DMCC.Prelude: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
+ DMCC.Prelude: (&&) :: Bool -> Bool -> Bool
+ DMCC.Prelude: (*) :: Num a => a -> a -> a
+ DMCC.Prelude: (**) :: Floating a => a -> a -> a
+ DMCC.Prelude: (***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
+ DMCC.Prelude: (*>) :: Applicative f => f a -> f b -> f b
+ DMCC.Prelude: (+) :: Num a => a -> a -> a
+ DMCC.Prelude: (++) :: Monoid m => m -> m -> m
+ DMCC.Prelude: (-) :: Num a => a -> a -> a
+ DMCC.Prelude: (.) :: Category cat => cat b c -> cat a b -> cat a c
+ DMCC.Prelude: (/) :: Fractional a => a -> a -> a
+ DMCC.Prelude: (/=) :: Eq a => a -> a -> Bool
+ DMCC.Prelude: (<$) :: Functor f => a -> f b -> f a
+ DMCC.Prelude: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ DMCC.Prelude: (<&&>) :: Applicative a => a Bool -> a Bool -> a Bool
+ DMCC.Prelude: (<&>) :: Functor f => f a -> (a -> b) -> f b
+ DMCC.Prelude: (<) :: Ord a => a -> a -> Bool
+ DMCC.Prelude: (<*) :: Applicative f => f a -> f b -> f a
+ DMCC.Prelude: (<**>) :: Applicative f => f a -> f (a -> b) -> f b
+ DMCC.Prelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ DMCC.Prelude: (<.>) :: FilePath -> String -> FilePath
+ DMCC.Prelude: (</>) :: FilePath -> FilePath -> FilePath
+ DMCC.Prelude: (<=) :: Ord a => a -> a -> Bool
+ DMCC.Prelude: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
+ DMCC.Prelude: (<>) :: Semigroup a => a -> a -> a
+ DMCC.Prelude: (<|) :: SemiSequence seq => Element seq -> NonNull seq -> NonNull seq
+ DMCC.Prelude: (<|>) :: Alternative f => f a -> f a -> f a
+ DMCC.Prelude: (<||>) :: Applicative a => a Bool -> a Bool -> a Bool
+ DMCC.Prelude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
+ DMCC.Prelude: (==) :: Eq a => a -> a -> Bool
+ DMCC.Prelude: (>) :: Ord a => a -> a -> Bool
+ DMCC.Prelude: (>=) :: Ord a => a -> a -> Bool
+ DMCC.Prelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
+ DMCC.Prelude: (>>) :: Monad m => m a -> m b -> m b
+ DMCC.Prelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
+ DMCC.Prelude: (\\) :: SetContainer a => a -> a -> a
+ DMCC.Prelude: (^) :: (Num a, Integral b) => a -> b -> a
+ DMCC.Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ DMCC.Prelude: (||) :: Bool -> Bool -> Bool
+ DMCC.Prelude: --
+ DMCC.Prelude: -- Since 0.2.0
+ DMCC.Prelude: -- container, much like <a>PrimState</a> from primitive.
+ DMCC.Prelude: -- e.g., the <a>IsMap</a> instance of associated lists.
+ DMCC.Prelude: -- reference.
+ DMCC.Prelude: -- | The type of the index of a sequence.
+ DMCC.Prelude: AppendMode :: IOMode
+ DMCC.Prelude: BlockBuffering :: Maybe Int -> BufferMode
+ DMCC.Prelude: Concurrently :: m a -> Concurrently a
+ DMCC.Prelude: Down :: a -> Down a
+ DMCC.Prelude: EQ :: Ordering
+ DMCC.Prelude: False :: Bool
+ DMCC.Prelude: GT :: Ordering
+ DMCC.Prelude: Identity :: a -> Identity a
+ DMCC.Prelude: Just :: a -> Maybe a
+ DMCC.Prelude: LT :: Ordering
+ DMCC.Prelude: Left :: a -> Either a b
+ DMCC.Prelude: LineBuffering :: BufferMode
+ DMCC.Prelude: ModifiedJulianDay :: Integer -> Day
+ DMCC.Prelude: MutVar :: MutVar# s a -> MutVar s a
+ DMCC.Prelude: NoBuffering :: BufferMode
+ DMCC.Prelude: Nothing :: Maybe a
+ DMCC.Prelude: ReadMode :: IOMode
+ DMCC.Prelude: ReadWriteMode :: IOMode
+ DMCC.Prelude: ReaderT :: (r -> m a) -> ReaderT r
+ DMCC.Prelude: Right :: b -> Either a b
+ DMCC.Prelude: StringException :: String -> CallStack -> StringException
+ DMCC.Prelude: True :: Bool
+ DMCC.Prelude: UTCTime :: Day -> DiffTime -> UTCTime
+ DMCC.Prelude: UnliftIO :: (forall a. () => m a -> IO a) -> UnliftIO
+ DMCC.Prelude: WriteMode :: IOMode
+ DMCC.Prelude: [AsyncExceptionWrapper] :: forall e. Exception e => e -> AsyncExceptionWrapper
+ DMCC.Prelude: [Handler] :: forall (m :: Type -> Type) a e. Exception e => (e -> m a) -> Handler m a
+ DMCC.Prelude: [SomeAsyncException] :: forall e. Exception e => e -> SomeAsyncException
+ DMCC.Prelude: [SomeException] :: forall e. Exception e => e -> SomeException
+ DMCC.Prelude: [SyncExceptionWrapper] :: forall e. Exception e => e -> SyncExceptionWrapper
+ DMCC.Prelude: [runConcurrently] :: Concurrently a -> m a
+ DMCC.Prelude: [runIdentity] :: Identity a -> a
+ DMCC.Prelude: [runReaderT] :: ReaderT r -> r -> m a
+ DMCC.Prelude: [toModifiedJulianDay] :: Day -> Integer
+ DMCC.Prelude: [unliftIO] :: UnliftIO -> forall a. () => m a -> IO a
+ DMCC.Prelude: [utctDayTime] :: UTCTime -> DiffTime
+ DMCC.Prelude: [utctDay] :: UTCTime -> Day
+ DMCC.Prelude: abs :: Num a => a -> a
+ DMCC.Prelude: acos :: Floating a => a -> a
+ DMCC.Prelude: acosh :: Floating a => a -> a
+ DMCC.Prelude: adjustMap :: IsMap map => (MapValue map -> MapValue map) -> ContainerKey map -> map -> map
+ DMCC.Prelude: adjustWithKey :: IsMap map => (ContainerKey map -> MapValue map -> MapValue map) -> ContainerKey map -> map -> map
+ DMCC.Prelude: all :: MonoFoldable mono => (Element mono -> Bool) -> mono -> Bool
+ DMCC.Prelude: alreadyExistsErrorType :: IOErrorType
+ DMCC.Prelude: alreadyInUseErrorType :: IOErrorType
+ DMCC.Prelude: alterMap :: IsMap map => (Maybe (MapValue map) -> Maybe (MapValue map)) -> ContainerKey map -> map -> map
+ DMCC.Prelude: and :: (MonoFoldable mono, Element mono ~ Bool) => mono -> Bool
+ DMCC.Prelude: annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
+ DMCC.Prelude: any :: MonoFoldable mono => (Element mono -> Bool) -> mono -> Bool
+ DMCC.Prelude: ap :: Monad m => m (a -> b) -> m a -> m b
+ DMCC.Prelude: applyDList :: () => DList a -> [a] -> [a]
+ DMCC.Prelude: asBDeque :: () => BDeque s a -> BDeque s a
+ DMCC.Prelude: asBRef :: () => BRef s a -> BRef s a
+ DMCC.Prelude: asByteString :: ByteString -> ByteString
+ DMCC.Prelude: asDLList :: () => DLList s a -> DLList s a
+ DMCC.Prelude: asDList :: () => DList a -> DList a
+ DMCC.Prelude: asHashMap :: () => HashMap k v -> HashMap k v
+ DMCC.Prelude: asHashSet :: () => HashSet a -> HashSet a
+ DMCC.Prelude: asIORef :: () => IORef a -> IORef a
+ DMCC.Prelude: asIntMap :: () => IntMap v -> IntMap v
+ DMCC.Prelude: asIntSet :: IntSet -> IntSet
+ DMCC.Prelude: asLByteString :: LByteString -> LByteString
+ DMCC.Prelude: asLText :: LText -> LText
+ DMCC.Prelude: asList :: () => [a] -> [a]
+ DMCC.Prelude: asMap :: () => Map k v -> Map k v
+ DMCC.Prelude: asMaybe :: () => Maybe a -> Maybe a
+ DMCC.Prelude: asMutVar :: () => MutVar s a -> MutVar s a
+ DMCC.Prelude: asPRef :: () => PRef s a -> PRef s a
+ DMCC.Prelude: asSDeque :: () => SDeque s a -> SDeque s a
+ DMCC.Prelude: asSRef :: () => SRef s a -> SRef s a
+ DMCC.Prelude: asSTRef :: () => STRef s a -> STRef s a
+ DMCC.Prelude: asSVector :: () => SVector a -> SVector a
+ DMCC.Prelude: asSet :: () => Set a -> Set a
+ DMCC.Prelude: asString :: [Char] -> [Char]
+ DMCC.Prelude: asText :: Text -> Text
+ DMCC.Prelude: asTypeOf :: () => a -> a -> a
+ DMCC.Prelude: asUDeque :: () => UDeque s a -> UDeque s a
+ DMCC.Prelude: asURef :: () => URef s a -> URef s a
+ DMCC.Prelude: asUVector :: () => UVector a -> UVector a
+ DMCC.Prelude: asVector :: () => Vector a -> Vector a
+ DMCC.Prelude: asin :: Floating a => a -> a
+ DMCC.Prelude: asinh :: Floating a => a -> a
+ DMCC.Prelude: ask :: MonadReader r m => m r
+ DMCC.Prelude: askRunInIO :: MonadUnliftIO m => m (m a -> IO a)
+ DMCC.Prelude: askUnliftIO :: MonadUnliftIO m => m (UnliftIO m)
+ DMCC.Prelude: asks :: MonadReader r m => (r -> a) -> m a
+ DMCC.Prelude: assert :: () => Bool -> a -> a
+ DMCC.Prelude: asum :: (Foldable t, Alternative f) => t (f a) -> f a
+ DMCC.Prelude: async :: MonadUnliftIO m => m a -> m (Async a)
+ DMCC.Prelude: asyncBound :: MonadUnliftIO m => m a -> m (Async a)
+ DMCC.Prelude: asyncOn :: MonadUnliftIO m => Int -> m a -> m (Async a)
+ DMCC.Prelude: asyncOnWithUnmask :: MonadUnliftIO m => Int -> ((forall b. () => m b -> m b) -> m a) -> m (Async a)
+ DMCC.Prelude: asyncWithUnmask :: MonadUnliftIO m => ((forall b. () => m b -> m b) -> m a) -> m (Async a)
+ DMCC.Prelude: atan :: Floating a => a -> a
+ DMCC.Prelude: atan2 :: RealFloat a => a -> a -> a
+ DMCC.Prelude: atanh :: Floating a => a -> a
+ DMCC.Prelude: atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
+ DMCC.Prelude: atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
+ DMCC.Prelude: atomicModifyMutVar :: PrimMonad m => MutVar (PrimState m) a -> (a -> (a, b)) -> m b
+ DMCC.Prelude: atomicModifyMutVar' :: PrimMonad m => MutVar (PrimState m) a -> (a -> (a, b)) -> m b
+ DMCC.Prelude: atomicModifyRef :: (MutableAtomicRef c, PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> (RefElement c, a)) -> m a
+ DMCC.Prelude: atomicModifyRef' :: (MutableAtomicRef c, PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> (RefElement c, a)) -> m a
+ DMCC.Prelude: atomicWriteIORef :: MonadIO m => IORef a -> a -> m ()
+ DMCC.Prelude: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
+ DMCC.Prelude: bool :: () => a -> a -> Bool -> a
+ DMCC.Prelude: bracket :: MonadUnliftIO m => m a -> (a -> m b) -> (a -> m c) -> m c
+ DMCC.Prelude: bracketOnError :: MonadUnliftIO m => m a -> (a -> m b) -> (a -> m c) -> m c
+ DMCC.Prelude: bracketOnError_ :: MonadUnliftIO m => m a -> m b -> m c -> m c
+ DMCC.Prelude: bracket_ :: MonadUnliftIO m => m a -> m b -> m c -> m c
+ DMCC.Prelude: break :: IsSequence seq => (Element seq -> Bool) -> seq -> (seq, seq)
+ DMCC.Prelude: breakLine :: Textual t => t -> (t, t)
+ DMCC.Prelude: breakWord :: Textual t => t -> (t, t)
+ DMCC.Prelude: builderToLazy :: Builder builder lazy => builder -> lazy
+ DMCC.Prelude: cancel :: MonadIO m => Async a -> m ()
+ DMCC.Prelude: cancelWith :: (Exception e, MonadIO m) => Async a -> e -> m ()
+ DMCC.Prelude: catMaybes :: (IsSequence (f (Maybe t)), Functor f, Element (f (Maybe t)) ~ Maybe t) => f (Maybe t) -> f t
+ DMCC.Prelude: catch :: (MonadUnliftIO m, Exception e) => m a -> (e -> m a) -> m a
+ DMCC.Prelude: catchAny :: MonadUnliftIO m => m a -> (SomeException -> m a) -> m a
+ DMCC.Prelude: catchAnyDeep :: (NFData a, MonadUnliftIO m) => m a -> (SomeException -> m a) -> m a
+ DMCC.Prelude: catchDeep :: (MonadUnliftIO m, Exception e, NFData a) => m a -> (e -> m a) -> m a
+ DMCC.Prelude: catchIO :: MonadUnliftIO m => m a -> (IOException -> m a) -> m a
+ DMCC.Prelude: catchJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a
+ DMCC.Prelude: catches :: MonadUnliftIO m => m a -> [Handler m a] -> m a
+ DMCC.Prelude: catchesDeep :: (MonadUnliftIO m, NFData a) => m a -> [Handler m a] -> m a
+ DMCC.Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ DMCC.Prelude: charToLower :: Char -> Char
+ DMCC.Prelude: charToUpper :: Char -> Char
+ DMCC.Prelude: checkSTM :: Bool -> STM ()
+ DMCC.Prelude: class Applicative f => Alternative (f :: Type -> Type)
+ DMCC.Prelude: class Functor f => Applicative (f :: Type -> Type)
+ DMCC.Prelude: class BiPolyMap (map :: Type -> Type -> Type) where {
+ DMCC.Prelude: class Bifunctor (p :: Type -> Type -> Type)
+ DMCC.Prelude: class Bounded a
+ DMCC.Prelude: class Monoid builder => Builder builder lazy | builder -> lazy, lazy -> builder
+ DMCC.Prelude: class Enum a
+ DMCC.Prelude: class Eq a
+ DMCC.Prelude: class (Typeable e, Show e) => Exception e
+ DMCC.Prelude: class Fractional a => Floating a
+ DMCC.Prelude: class Foldable (t :: Type -> Type)
+ DMCC.Prelude: class Num a => Fractional a
+ DMCC.Prelude: class Functor (f :: Type -> Type)
+ DMCC.Prelude: class Generic a
+ DMCC.Prelude: class MonoFoldable mono => GrowingAppend mono
+ DMCC.Prelude: class SetContainer set => HasKeysSet set where {
+ DMCC.Prelude: class Hashable a
+ DMCC.Prelude: class (Real a, Enum a) => Integral a
+ DMCC.Prelude: class (MonoTraversable map, SetContainer map) => IsMap map where {
+ DMCC.Prelude: class (Monoid seq, MonoTraversable seq, SemiSequence seq, MonoPointed seq) => IsSequence seq
+ DMCC.Prelude: class (SetContainer set, Element set ~ ContainerKey set) => IsSet set
+ DMCC.Prelude: class IsString a
+ DMCC.Prelude: class (IsSequence lazy, IsSequence strict) => LazySequence lazy strict | lazy -> strict, strict -> lazy
+ DMCC.Prelude: class Applicative m => Monad (m :: Type -> Type)
+ DMCC.Prelude: class (Applicative b, Applicative m, Monad b, Monad m) => MonadBase (b :: Type -> Type) (m :: Type -> Type) | m -> b
+ DMCC.Prelude: class MonadBase b m => MonadBaseControl (b :: Type -> Type) (m :: Type -> Type) | m -> b
+ DMCC.Prelude: class MonadThrow m => MonadCatch (m :: Type -> Type)
+ DMCC.Prelude: class Monad m => MonadIO (m :: Type -> Type)
+ DMCC.Prelude: class MonadCatch m => MonadMask (m :: Type -> Type)
+ DMCC.Prelude: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
+ DMCC.Prelude: class Monad m => MonadReader r (m :: Type -> Type) | m -> r
+ DMCC.Prelude: class Monad m => MonadThrow (m :: Type -> Type)
+ DMCC.Prelude: class MonadIO m => MonadUnliftIO (m :: Type -> Type)
+ DMCC.Prelude: class MonoFunctor mono => MonoComonad mono
+ DMCC.Prelude: class MonoFoldable mono
+ DMCC.Prelude: class MonoFunctor mono
+ DMCC.Prelude: class MonoPointed mono
+ DMCC.Prelude: class (MonoFunctor mono, MonoFoldable mono) => MonoTraversable mono
+ DMCC.Prelude: class MonoFunctor mono => MonoZip mono
+ DMCC.Prelude: class Semigroup a => Monoid a
+ DMCC.Prelude: class MutableRef c => MutableAtomicRef c
+ DMCC.Prelude: class MutableContainer c => MutableCollection c where {
+ DMCC.Prelude: class MutableContainer c where {
+ DMCC.Prelude: class MutableCollection c => MutablePopBack c
+ DMCC.Prelude: class MutableCollection c => MutablePopFront c
+ DMCC.Prelude: class MutableCollection c => MutablePushBack c
+ DMCC.Prelude: class MutableCollection c => MutablePushFront c
+ DMCC.Prelude: class MutableContainer c => MutableRef c where {
+ DMCC.Prelude: class NFData a
+ DMCC.Prelude: class Num a
+ DMCC.Prelude: class Eq a => Ord a
+ DMCC.Prelude: class PolyMap (map :: Type -> Type)
+ DMCC.Prelude: class Prim a
+ DMCC.Prelude: class Monad m => PrimMonad (m :: Type -> Type) where {
+ DMCC.Prelude: class Read a
+ DMCC.Prelude: class (Num a, Ord a) => Real a
+ DMCC.Prelude: class (RealFrac a, Floating a) => RealFloat a
+ DMCC.Prelude: class (Real a, Fractional a) => RealFrac a
+ DMCC.Prelude: class (Integral Index seq, GrowingAppend seq) => SemiSequence seq where {
+ DMCC.Prelude: class Semigroup a
+ DMCC.Prelude: class (Monoid set, Semigroup set, MonoFoldable set, Eq ContainerKey set, GrowingAppend set) => SetContainer set where {
+ DMCC.Prelude: class Show a
+ DMCC.Prelude: class Storable a
+ DMCC.Prelude: class (IsSequence t, IsString t, Element t ~ Char) => Textual t
+ DMCC.Prelude: class ToBuilder value builder
+ DMCC.Prelude: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
+ DMCC.Prelude: class Typeable (a :: k)
+ DMCC.Prelude: class (Vector Vector a, MVector MVector a) => Unbox a
+ DMCC.Prelude: class (Textual textual, IsSequence binary) => Utf8 textual binary | textual -> binary, binary -> textual
+ DMCC.Prelude: cloneTChan :: () => TChan a -> STM (TChan a)
+ DMCC.Prelude: closeTBMChan :: () => TBMChan a -> STM ()
+ DMCC.Prelude: closeTBMQueue :: () => TBMQueue a -> STM ()
+ DMCC.Prelude: closeTMChan :: () => TMChan a -> STM ()
+ DMCC.Prelude: closeTMQueue :: () => TMQueue a -> STM ()
+ DMCC.Prelude: compare :: Ord a => a -> a -> Ordering
+ DMCC.Prelude: compareLength :: (MonoFoldable mono, Integral i) => mono -> i -> Ordering
+ DMCC.Prelude: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
+ DMCC.Prelude: concat :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono
+ DMCC.Prelude: concatMap :: (MonoFoldable mono, Monoid m) => (Element mono -> m) -> mono -> m
+ DMCC.Prelude: concurrently :: MonadUnliftIO m => m a -> m b -> m (a, b)
+ DMCC.Prelude: concurrently_ :: MonadUnliftIO m => m a -> m b -> m ()
+ DMCC.Prelude: cons :: SemiSequence seq => Element seq -> seq -> seq
+ DMCC.Prelude: const :: () => a -> b -> a
+ DMCC.Prelude: cos :: Floating a => a -> a
+ DMCC.Prelude: cosh :: Floating a => a -> a
+ DMCC.Prelude: curry :: () => ((a, b) -> c) -> a -> b -> c
+ DMCC.Prelude: data Async a
+ DMCC.Prelude: data AsyncExceptionWrapper
+ DMCC.Prelude: data BRef s a
+ DMCC.Prelude: data Bool
+ DMCC.Prelude: data BufferMode
+ DMCC.Prelude: data ByteString
+ DMCC.Prelude: data Chan a
+ DMCC.Prelude: data Char
+ DMCC.Prelude: data DLList s a
+ DMCC.Prelude: data DList a
+ DMCC.Prelude: data Deque (v :: Type -> Type -> Type) s a
+ DMCC.Prelude: data Double
+ DMCC.Prelude: data Either a b
+ DMCC.Prelude: data Float
+ DMCC.Prelude: data Handle
+ DMCC.Prelude: data Handler (m :: Type -> Type) a
+ DMCC.Prelude: data HashMap k v
+ DMCC.Prelude: data HashSet a
+ DMCC.Prelude: data IO a
+ DMCC.Prelude: data IOErrorType
+ DMCC.Prelude: data IOException
+ DMCC.Prelude: data IOMode
+ DMCC.Prelude: data IORef a
+ DMCC.Prelude: data Int
+ DMCC.Prelude: data Int32
+ DMCC.Prelude: data Int64
+ DMCC.Prelude: data IntMap a
+ DMCC.Prelude: data IntSet
+ DMCC.Prelude: data Integer
+ DMCC.Prelude: data MVar a
+ DMCC.Prelude: data Map k a
+ DMCC.Prelude: data Maybe a
+ DMCC.Prelude: data Memoized a
+ DMCC.Prelude: data MutVar s a
+ DMCC.Prelude: data NonNull mono
+ DMCC.Prelude: data Ordering
+ DMCC.Prelude: data PRef s a
+ DMCC.Prelude: data RealWorld :: Type
+ DMCC.Prelude: data SRef s a
+ DMCC.Prelude: data STM a
+ DMCC.Prelude: data STRef s a
+ DMCC.Prelude: data SeekMode
+ DMCC.Prelude: data Seq a
+ DMCC.Prelude: data Set a
+ DMCC.Prelude: data SomeAsyncException
+ DMCC.Prelude: data SomeException
+ DMCC.Prelude: data StringException
+ DMCC.Prelude: data SyncExceptionWrapper
+ DMCC.Prelude: data TBChan a
+ DMCC.Prelude: data TBMChan a
+ DMCC.Prelude: data TBMQueue a
+ DMCC.Prelude: data TBQueue a
+ DMCC.Prelude: data TChan a
+ DMCC.Prelude: data TMChan a
+ DMCC.Prelude: data TMQueue a
+ DMCC.Prelude: data TMVar a
+ DMCC.Prelude: data TQueue a
+ DMCC.Prelude: data TVar a
+ DMCC.Prelude: data Text
+ DMCC.Prelude: data URef s a
+ DMCC.Prelude: data UTCTime
+ DMCC.Prelude: data Vector a
+ DMCC.Prelude: data Word
+ DMCC.Prelude: data Word32
+ DMCC.Prelude: data Word64
+ DMCC.Prelude: data Word8
+ DMCC.Prelude: data WrappedMonoid m
+ DMCC.Prelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ DMCC.Prelude: decodeUtf8 :: Utf8 textual binary => binary -> textual
+ DMCC.Prelude: deepseq :: NFData a => a -> b -> b
+ DMCC.Prelude: defaultCons :: IsSequence seq => Element seq -> seq -> seq
+ DMCC.Prelude: defaultFind :: MonoFoldable seq => (Element seq -> Bool) -> seq -> Maybe (Element seq)
+ DMCC.Prelude: defaultIntersperse :: IsSequence seq => Element seq -> seq -> seq
+ DMCC.Prelude: defaultReverse :: IsSequence seq => seq -> seq
+ DMCC.Prelude: defaultSnoc :: IsSequence seq => seq -> Element seq -> seq
+ DMCC.Prelude: defaultSortBy :: IsSequence seq => (Element seq -> Element seq -> Ordering) -> seq -> seq
+ DMCC.Prelude: defaultSplitWhen :: IsSequence seq => (Element seq -> Bool) -> seq -> [seq]
+ DMCC.Prelude: defaultTimeLocale :: TimeLocale
+ DMCC.Prelude: delete :: (IsSequence seq, Eq (Element seq)) => Element seq -> seq -> seq
+ DMCC.Prelude: deleteBy :: (IsSequence seq, Eq (Element seq)) => (Element seq -> Element seq -> Bool) -> Element seq -> seq -> seq
+ DMCC.Prelude: deleteMap :: IsMap map => ContainerKey map -> map -> map
+ DMCC.Prelude: deleteSet :: IsSet set => Element set -> set -> set
+ DMCC.Prelude: difference :: SetContainer set => set -> set -> set
+ DMCC.Prelude: differenceMap :: PolyMap map => map value1 -> map value2 -> map value1
+ DMCC.Prelude: displayException :: Exception e => e -> String
+ DMCC.Prelude: div :: Integral a => a -> a -> a
+ DMCC.Prelude: divMod :: Integral a => a -> a -> (a, a)
+ DMCC.Prelude: doesNotExistErrorType :: IOErrorType
+ DMCC.Prelude: drop :: IsSequence seq => Index seq -> seq -> seq
+ DMCC.Prelude: dropEnd :: IsSequence seq => Index seq -> seq -> seq
+ DMCC.Prelude: dropPrefix :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> seq
+ DMCC.Prelude: dropSuffix :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> seq
+ DMCC.Prelude: dropWhile :: IsSequence seq => (Element seq -> Bool) -> seq -> seq
+ DMCC.Prelude: dupChan :: MonadIO m => Chan a -> m (Chan a)
+ DMCC.Prelude: dupTChan :: () => TChan a -> STM (TChan a)
+ DMCC.Prelude: dupTMChan :: () => TMChan a -> STM (TMChan a)
+ DMCC.Prelude: either :: () => (a -> c) -> (b -> c) -> Either a b -> c
+ DMCC.Prelude: elem :: (MonoFoldable mono, Eq (Element mono)) => Element mono -> mono -> Bool
+ DMCC.Prelude: empty :: Alternative f => f a
+ DMCC.Prelude: encodeFloat :: RealFloat a => Integer -> Int -> a
+ DMCC.Prelude: encodeUtf8 :: Utf8 textual binary => textual -> binary
+ DMCC.Prelude: ensurePrefix :: (Eq (Element seq), IsSequence seq) => seq -> seq -> seq
+ DMCC.Prelude: ensureSuffix :: (Eq (Element seq), IsSequence seq) => seq -> seq -> seq
+ DMCC.Prelude: enumFrom :: Enum a => a -> [a]
+ DMCC.Prelude: enumFromThen :: Enum a => a -> a -> [a]
+ DMCC.Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ DMCC.Prelude: enumFromTo :: Enum a => a -> a -> [a]
+ DMCC.Prelude: eofErrorType :: IOErrorType
+ DMCC.Prelude: equating :: Eq a => (b -> a) -> b -> b -> Bool
+ DMCC.Prelude: error :: HasCallStack => [Char] -> a
+ DMCC.Prelude: estimateFreeSlotsTBChan :: () => TBChan a -> STM Int
+ DMCC.Prelude: estimateFreeSlotsTBMChan :: () => TBMChan a -> STM Int
+ DMCC.Prelude: estimateFreeSlotsTBMQueue :: () => TBMQueue a -> STM Int
+ DMCC.Prelude: evaluate :: MonadIO m => a -> m a
+ DMCC.Prelude: evaluateDeep :: (MonadIO m, NFData a) => a -> m a
+ DMCC.Prelude: even :: Integral a => a -> Bool
+ DMCC.Prelude: exp :: Floating a => a -> a
+ DMCC.Prelude: exponent :: RealFloat a => a -> Int
+ DMCC.Prelude: fail :: Monad m => String -> m a
+ DMCC.Prelude: filter :: IsSequence seq => (Element seq -> Bool) -> seq -> seq
+ DMCC.Prelude: filterM :: (IsSequence seq, Monad m) => (Element seq -> m Bool) -> seq -> m seq
+ DMCC.Prelude: filterMap :: IsMap map => (MapValue map -> Bool) -> map -> map
+ DMCC.Prelude: finally :: MonadUnliftIO m => m a -> m b -> m a
+ DMCC.Prelude: find :: SemiSequence seq => (Element seq -> Bool) -> seq -> Maybe (Element seq)
+ DMCC.Prelude: findWithDefault :: IsMap map => MapValue map -> ContainerKey map -> map -> MapValue map
+ DMCC.Prelude: first :: Bifunctor p => (a -> b) -> p a c -> p b c
+ DMCC.Prelude: flip :: () => (a -> b -> c) -> b -> a -> c
+ DMCC.Prelude: floatDigits :: RealFloat a => a -> Int
+ DMCC.Prelude: floatRadix :: RealFloat a => a -> Integer
+ DMCC.Prelude: floatRange :: RealFloat a => a -> (Int, Int)
+ DMCC.Prelude: floor :: (RealFrac a, Integral b) => a -> b
+ DMCC.Prelude: flushBuilder :: Builder builder lazy => builder
+ DMCC.Prelude: fmap :: Functor f => (a -> b) -> f a -> f b
+ DMCC.Prelude: fold :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono
+ DMCC.Prelude: foldM :: (MonoFoldable mono, Monad m) => (a -> Element mono -> m a) -> a -> mono -> m a
+ DMCC.Prelude: foldMap :: (MonoFoldable mono, Monoid m) => (Element mono -> m) -> mono -> m
+ DMCC.Prelude: foldMap1Ex :: (MonoFoldable mono, Semigroup m) => (Element mono -> m) -> mono -> m
+ DMCC.Prelude: foldl' :: MonoFoldable mono => (a -> Element mono -> a) -> a -> mono -> a
+ DMCC.Prelude: foldl1Ex' :: MonoFoldable mono => (Element mono -> Element mono -> Element mono) -> mono -> Element mono
+ DMCC.Prelude: foldlM :: (MonoFoldable mono, Monad m) => (a -> Element mono -> m a) -> a -> mono -> m a
+ DMCC.Prelude: foldr :: MonoFoldable mono => (Element mono -> b -> b) -> b -> mono -> b
+ DMCC.Prelude: foldr1Ex :: MonoFoldable mono => (Element mono -> Element mono -> Element mono) -> mono -> Element mono
+ DMCC.Prelude: for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
+ DMCC.Prelude: forConcurrently :: (MonadUnliftIO m, Traversable t) => t a -> (a -> m b) -> m (t b)
+ DMCC.Prelude: forConcurrently_ :: (MonadUnliftIO m, Foldable f) => f a -> (a -> m b) -> m ()
+ DMCC.Prelude: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
+ DMCC.Prelude: forM_ :: (MonoFoldable mono, Applicative m) => mono -> (Element mono -> m ()) -> m ()
+ DMCC.Prelude: for_ :: (MonoFoldable mono, Applicative f) => mono -> (Element mono -> f b) -> f ()
+ DMCC.Prelude: force :: NFData a => a -> a
+ DMCC.Prelude: forever :: Applicative f => f a -> f b
+ DMCC.Prelude: formatTime :: FormatTime t => TimeLocale -> String -> t -> String
+ DMCC.Prelude: freeSlotsTBChan :: () => TBChan a -> STM Int
+ DMCC.Prelude: freeSlotsTBMChan :: () => TBMChan a -> STM Int
+ DMCC.Prelude: freeSlotsTBMQueue :: () => TBMQueue a -> STM Int
+ DMCC.Prelude: fromByteVector :: SVector Word8 -> ByteString
+ DMCC.Prelude: fromChunks :: LazySequence lazy strict => [strict] -> lazy
+ DMCC.Prelude: fromEither :: (Exception e, MonadIO m) => Either e a -> m a
+ DMCC.Prelude: fromEitherIO :: (Exception e, MonadIO m) => IO (Either e a) -> m a
+ DMCC.Prelude: fromEitherM :: (Exception e, MonadIO m) => m (Either e a) -> m a
+ DMCC.Prelude: fromEnum :: Enum a => a -> Int
+ DMCC.Prelude: fromException :: Exception e => SomeException -> Maybe e
+ DMCC.Prelude: fromGregorian :: Integer -> Int -> Int -> Day
+ DMCC.Prelude: fromInteger :: Num a => Integer -> a
+ DMCC.Prelude: fromIntegral :: (Integral a, Num b) => a -> b
+ DMCC.Prelude: fromList :: IsSequence seq => [Element seq] -> seq
+ DMCC.Prelude: fromMaybe :: () => a -> Maybe a -> a
+ DMCC.Prelude: fromNonEmpty :: IsSequence seq => NonEmpty (Element seq) -> NonNull seq
+ DMCC.Prelude: fromNullable :: MonoFoldable mono => mono -> Maybe (NonNull mono)
+ DMCC.Prelude: fromRational :: Fractional a => Rational -> a
+ DMCC.Prelude: fromStrict :: LazySequence lazy strict => strict -> lazy
+ DMCC.Prelude: fromString :: IsString a => String -> a
+ DMCC.Prelude: fst :: () => (a, b) -> a
+ DMCC.Prelude: fullErrorType :: IOErrorType
+ DMCC.Prelude: getArgs :: MonadIO m => m [Text]
+ DMCC.Prelude: getChanContents :: MonadIO m => Chan a -> m [a]
+ DMCC.Prelude: getChar :: MonadIO m => m Char
+ DMCC.Prelude: getContents :: MonadIO m => m LText
+ DMCC.Prelude: getCurrentTime :: IO UTCTime
+ DMCC.Prelude: getLine :: MonadIO m => m Text
+ DMCC.Prelude: getMonotonicTime :: MonadIO m => m Double
+ DMCC.Prelude: group :: (IsSequence seq, Eq (Element seq)) => seq -> [seq]
+ DMCC.Prelude: groupAll :: (IsSequence seq, Eq (Element seq)) => seq -> [seq]
+ DMCC.Prelude: groupAllOn :: (IsSequence seq, Eq b) => (Element seq -> b) -> seq -> [seq]
+ DMCC.Prelude: groupBy :: IsSequence seq => (Element seq -> Element seq -> Bool) -> seq -> [seq]
+ DMCC.Prelude: guard :: Alternative f => Bool -> f ()
+ DMCC.Prelude: hClose :: MonadIO m => Handle -> m ()
+ DMCC.Prelude: hFileSize :: MonadIO m => Handle -> m Integer
+ DMCC.Prelude: hFlush :: MonadIO m => Handle -> m ()
+ DMCC.Prelude: hGetBuffering :: MonadIO m => Handle -> m BufferMode
+ DMCC.Prelude: hGetChunk :: MonadIO m => Handle -> m ByteString
+ DMCC.Prelude: hGetContents :: MonadIO m => Handle -> m ByteString
+ DMCC.Prelude: hGetEcho :: MonadIO m => Handle -> m Bool
+ DMCC.Prelude: hIsClosed :: MonadIO m => Handle -> m Bool
+ DMCC.Prelude: hIsEOF :: MonadIO m => Handle -> m Bool
+ DMCC.Prelude: hIsOpen :: MonadIO m => Handle -> m Bool
+ DMCC.Prelude: hIsReadable :: MonadIO m => Handle -> m Bool
+ DMCC.Prelude: hIsSeekable :: MonadIO m => Handle -> m Bool
+ DMCC.Prelude: hIsTerminalDevice :: MonadIO m => Handle -> m Bool
+ DMCC.Prelude: hIsWritable :: MonadIO m => Handle -> m Bool
+ DMCC.Prelude: hPut :: MonadIO m => Handle -> ByteString -> m ()
+ DMCC.Prelude: hReady :: MonadIO m => Handle -> m Bool
+ DMCC.Prelude: hSay :: MonadIO m => Handle -> Text -> m ()
+ DMCC.Prelude: hSayShow :: (MonadIO m, Show a) => Handle -> a -> m ()
+ DMCC.Prelude: hSayString :: MonadIO m => Handle -> String -> m ()
+ DMCC.Prelude: hSeek :: MonadIO m => Handle -> SeekMode -> Integer -> m ()
+ DMCC.Prelude: hSetBuffering :: MonadIO m => Handle -> BufferMode -> m ()
+ DMCC.Prelude: hSetEcho :: MonadIO m => Handle -> Bool -> m ()
+ DMCC.Prelude: hSetFileSize :: MonadIO m => Handle -> Integer -> m ()
+ DMCC.Prelude: hTell :: MonadIO m => Handle -> m Integer
+ DMCC.Prelude: hWaitForInput :: MonadIO m => Handle -> Int -> m Bool
+ DMCC.Prelude: handle :: (MonadUnliftIO m, Exception e) => (e -> m a) -> m a -> m a
+ DMCC.Prelude: handleAny :: MonadUnliftIO m => (SomeException -> m a) -> m a -> m a
+ DMCC.Prelude: handleAnyDeep :: (MonadUnliftIO m, NFData a) => (SomeException -> m a) -> m a -> m a
+ DMCC.Prelude: handleDeep :: (MonadUnliftIO m, Exception e, NFData a) => (e -> m a) -> m a -> m a
+ DMCC.Prelude: handleIO :: MonadUnliftIO m => (IOException -> m a) -> m a -> m a
+ DMCC.Prelude: handleJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a
+ DMCC.Prelude: hash :: Hashable a => a -> Int
+ DMCC.Prelude: hashNub :: (Hashable a, Eq a) => [a] -> [a]
+ DMCC.Prelude: hashWithSalt :: Hashable a => Int -> a -> Int
+ DMCC.Prelude: head :: MonoFoldable mono => NonNull mono -> Element mono
+ DMCC.Prelude: headEx :: MonoFoldable mono => mono -> Element mono
+ DMCC.Prelude: headMay :: MonoFoldable mono => mono -> Maybe (Element mono)
+ DMCC.Prelude: id :: Category cat => cat a a
+ DMCC.Prelude: illegalOperationErrorType :: IOErrorType
+ DMCC.Prelude: impureNonNull :: MonoFoldable mono => mono -> NonNull mono
+ DMCC.Prelude: impureThrow :: Exception e => e -> a
+ DMCC.Prelude: index :: IsSequence seq => seq -> Index seq -> Maybe (Element seq)
+ DMCC.Prelude: indexEx :: IsSequence seq => seq -> Index seq -> Element seq
+ DMCC.Prelude: infix 4 <=
+ DMCC.Prelude: infixl 0 `on`
+ DMCC.Prelude: infixl 1 <&>
+ DMCC.Prelude: infixl 3 <|>
+ DMCC.Prelude: infixl 4 <**>
+ DMCC.Prelude: infixl 6 -
+ DMCC.Prelude: infixl 7 *
+ DMCC.Prelude: infixl 9 \\
+ DMCC.Prelude: infixr 0 $!!
+ DMCC.Prelude: infixr 1 =<<
+ DMCC.Prelude: infixr 2 <||>
+ DMCC.Prelude: infixr 3 <&&>
+ DMCC.Prelude: infixr 5 ++
+ DMCC.Prelude: infixr 6 <>
+ DMCC.Prelude: infixr 7 <.>
+ DMCC.Prelude: infixr 8 ^
+ DMCC.Prelude: infixr 9 .
+ DMCC.Prelude: init :: IsSequence seq => NonNull seq -> seq
+ DMCC.Prelude: initDef :: IsSequence seq => seq -> seq
+ DMCC.Prelude: initEx :: IsSequence seq => seq -> seq
+ DMCC.Prelude: initMay :: IsSequence seq => seq -> Maybe seq
+ DMCC.Prelude: insertLookupWithKey :: IsMap map => (ContainerKey map -> MapValue map -> MapValue map -> MapValue map) -> ContainerKey map -> MapValue map -> map -> (Maybe (MapValue map), map)
+ DMCC.Prelude: insertMap :: IsMap map => ContainerKey map -> MapValue map -> map -> map
+ DMCC.Prelude: insertSet :: IsSet set => Element set -> set -> set
+ DMCC.Prelude: insertWith :: IsMap map => (MapValue map -> MapValue map -> MapValue map) -> ContainerKey map -> MapValue map -> map -> map
+ DMCC.Prelude: insertWithKey :: IsMap map => (ContainerKey map -> MapValue map -> MapValue map -> MapValue map) -> ContainerKey map -> MapValue map -> map -> map
+ DMCC.Prelude: interact :: MonadIO m => (LText -> LText) -> m ()
+ DMCC.Prelude: intercalate :: (MonoFoldable mono, Monoid (Element mono)) => Element mono -> mono -> Element mono
+ DMCC.Prelude: intersect :: SetContainer a => a -> a -> a
+ DMCC.Prelude: intersection :: SetContainer set => set -> set -> set
+ DMCC.Prelude: intersectionMap :: PolyMap map => map value1 -> map value2 -> map value1
+ DMCC.Prelude: intersectionWithMap :: PolyMap map => (value1 -> value2 -> value3) -> map value1 -> map value2 -> map value3
+ DMCC.Prelude: intersperse :: SemiSequence seq => Element seq -> seq -> seq
+ DMCC.Prelude: ioError :: () => IOError -> IO a
+ DMCC.Prelude: ioeGetErrorString :: IOError -> String
+ DMCC.Prelude: ioeGetErrorType :: IOError -> IOErrorType
+ DMCC.Prelude: ioeGetFileName :: IOError -> Maybe FilePath
+ DMCC.Prelude: ioeGetHandle :: IOError -> Maybe Handle
+ DMCC.Prelude: ioeGetLocation :: IOError -> String
+ DMCC.Prelude: ioeSetErrorString :: IOError -> String -> IOError
+ DMCC.Prelude: ioeSetErrorType :: IOError -> IOErrorType -> IOError
+ DMCC.Prelude: ioeSetFileName :: IOError -> FilePath -> IOError
+ DMCC.Prelude: ioeSetHandle :: IOError -> Handle -> IOError
+ DMCC.Prelude: ioeSetLocation :: IOError -> String -> IOError
+ DMCC.Prelude: isAlreadyExistsError :: IOError -> Bool
+ DMCC.Prelude: isAlreadyExistsErrorType :: IOErrorType -> Bool
+ DMCC.Prelude: isAlreadyInUseError :: IOError -> Bool
+ DMCC.Prelude: isAlreadyInUseErrorType :: IOErrorType -> Bool
+ DMCC.Prelude: isAsyncException :: Exception e => e -> Bool
+ DMCC.Prelude: isClosedTBMChan :: () => TBMChan a -> STM Bool
+ DMCC.Prelude: isClosedTBMQueue :: () => TBMQueue a -> STM Bool
+ DMCC.Prelude: isClosedTMChan :: () => TMChan a -> STM Bool
+ DMCC.Prelude: isClosedTMQueue :: () => TMQueue a -> STM Bool
+ DMCC.Prelude: isDenormalized :: RealFloat a => a -> Bool
+ DMCC.Prelude: isDoesNotExistError :: IOError -> Bool
+ DMCC.Prelude: isDoesNotExistErrorType :: IOErrorType -> Bool
+ DMCC.Prelude: isEOFError :: IOError -> Bool
+ DMCC.Prelude: isEOFErrorType :: IOErrorType -> Bool
+ DMCC.Prelude: isEmptyMVar :: MonadIO m => MVar a -> m Bool
+ DMCC.Prelude: isEmptyTBChan :: () => TBChan a -> STM Bool
+ DMCC.Prelude: isEmptyTBMChan :: () => TBMChan a -> STM Bool
+ DMCC.Prelude: isEmptyTBMQueue :: () => TBMQueue a -> STM Bool
+ DMCC.Prelude: isEmptyTBQueue :: () => TBQueue a -> STM Bool
+ DMCC.Prelude: isEmptyTChan :: () => TChan a -> STM Bool
+ DMCC.Prelude: isEmptyTMChan :: () => TMChan a -> STM Bool
+ DMCC.Prelude: isEmptyTMQueue :: () => TMQueue a -> STM Bool
+ DMCC.Prelude: isEmptyTMVar :: () => TMVar a -> STM Bool
+ DMCC.Prelude: isEmptyTQueue :: () => TQueue a -> STM Bool
+ DMCC.Prelude: isFullError :: IOError -> Bool
+ DMCC.Prelude: isFullErrorType :: IOErrorType -> Bool
+ DMCC.Prelude: isFullTBChan :: () => TBChan a -> STM Bool
+ DMCC.Prelude: isFullTBMChan :: () => TBMChan a -> STM Bool
+ DMCC.Prelude: isFullTBMQueue :: () => TBMQueue a -> STM Bool
+ DMCC.Prelude: isFullTBQueue :: () => TBQueue a -> STM Bool
+ DMCC.Prelude: isIEEE :: RealFloat a => a -> Bool
+ DMCC.Prelude: isIllegalOperation :: IOError -> Bool
+ DMCC.Prelude: isIllegalOperationErrorType :: IOErrorType -> Bool
+ DMCC.Prelude: isInfinite :: RealFloat a => a -> Bool
+ DMCC.Prelude: isInfixOf :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Bool
+ DMCC.Prelude: isJust :: () => Maybe a -> Bool
+ DMCC.Prelude: isNaN :: RealFloat a => a -> Bool
+ DMCC.Prelude: isNegativeZero :: RealFloat a => a -> Bool
+ DMCC.Prelude: isNothing :: () => Maybe a -> Bool
+ DMCC.Prelude: isPermissionError :: IOError -> Bool
+ DMCC.Prelude: isPermissionErrorType :: IOErrorType -> Bool
+ DMCC.Prelude: isPrefixOf :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Bool
+ DMCC.Prelude: isSuffixOf :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Bool
+ DMCC.Prelude: isSyncException :: Exception e => e -> Bool
+ DMCC.Prelude: isUserError :: IOError -> Bool
+ DMCC.Prelude: isUserErrorType :: IOErrorType -> Bool
+ DMCC.Prelude: join :: Monad m => m (m a) -> m a
+ DMCC.Prelude: keys :: SetContainer set => set -> [ContainerKey set]
+ DMCC.Prelude: keysSet :: HasKeysSet set => set -> KeySet set
+ DMCC.Prelude: last :: MonoFoldable mono => NonNull mono -> Element mono
+ DMCC.Prelude: lastEx :: MonoFoldable mono => mono -> Element mono
+ DMCC.Prelude: lastMay :: MonoFoldable mono => mono -> Maybe (Element mono)
+ DMCC.Prelude: lefts :: () => [Either a b] -> [a]
+ DMCC.Prelude: length :: MonoFoldable mono => mono -> Int
+ DMCC.Prelude: length64 :: MonoFoldable mono => mono -> Int64
+ DMCC.Prelude: lengthIndex :: IsSequence seq => seq -> Index seq
+ DMCC.Prelude: lift :: (MonadTrans t, Monad m) => m a -> t m a
+ DMCC.Prelude: liftA :: Applicative f => (a -> b) -> f a -> f b
+ DMCC.Prelude: liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
+ DMCC.Prelude: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+ DMCC.Prelude: liftIO :: MonadIO m => IO a -> m a
+ DMCC.Prelude: liftM :: Monad m => (a1 -> r) -> m a1 -> m r
+ DMCC.Prelude: liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
+ DMCC.Prelude: liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
+ DMCC.Prelude: liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
+ DMCC.Prelude: liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
+ DMCC.Prelude: lines :: Textual t => t -> [t]
+ DMCC.Prelude: link :: MonadIO m => Async a -> m ()
+ DMCC.Prelude: link2 :: MonadIO m => Async a -> Async b -> m ()
+ DMCC.Prelude: link2Async :: MonadIO m => Async a -> Async b -> m ()
+ DMCC.Prelude: linkAsync :: MonadIO m => Async a -> m ()
+ DMCC.Prelude: listToMaybe :: () => [a] -> Maybe a
+ DMCC.Prelude: log :: Floating a => a -> a
+ DMCC.Prelude: logBase :: Floating a => a -> a -> a
+ DMCC.Prelude: lookup :: IsMap map => ContainerKey map -> map -> Maybe (MapValue map)
+ DMCC.Prelude: many :: Alternative f => f a -> f [a]
+ DMCC.Prelude: map :: Functor f => (a -> b) -> f a -> f b
+ DMCC.Prelude: mapConcurrently :: (MonadUnliftIO m, Traversable t) => (a -> m b) -> t a -> m (t b)
+ DMCC.Prelude: mapConcurrently_ :: (MonadUnliftIO m, Foldable f) => (a -> m b) -> f a -> m ()
+ DMCC.Prelude: mapFromList :: IsMap map => [(ContainerKey map, MapValue map)] -> map
+ DMCC.Prelude: mapKeysWith :: (BiPolyMap map, BPMKeyConstraint map k1, BPMKeyConstraint map k2) => (v -> v -> v) -> (k1 -> k2) -> map k1 v -> map k2 v
+ DMCC.Prelude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
+ DMCC.Prelude: mapM_ :: (MonoFoldable mono, Applicative m) => (Element mono -> m ()) -> mono -> m ()
+ DMCC.Prelude: mapMaybe :: () => (a -> Maybe b) -> [a] -> [b]
+ DMCC.Prelude: mapNonNull :: (Functor f, MonoFoldable (f b)) => (a -> b) -> NonNull (f a) -> NonNull (f b)
+ DMCC.Prelude: mapToList :: IsMap map => map -> [(ContainerKey map, MapValue map)]
+ DMCC.Prelude: mapWithKey :: IsMap map => (ContainerKey map -> MapValue map -> MapValue map) -> map -> map
+ DMCC.Prelude: mappend :: Monoid a => a -> a -> a
+ DMCC.Prelude: mask :: MonadUnliftIO m => ((forall a. () => m a -> m a) -> m b) -> m b
+ DMCC.Prelude: mask_ :: MonadUnliftIO m => m a -> m a
+ DMCC.Prelude: max :: Ord a => a -> a -> a
+ DMCC.Prelude: maxBound :: Bounded a => a
+ DMCC.Prelude: maximum :: (MonoFoldable mono, Ord (Element mono)) => NonNull mono -> Element mono
+ DMCC.Prelude: maximumBy :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> NonNull mono -> Element mono
+ DMCC.Prelude: maximumByEx :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> mono -> Element mono
+ DMCC.Prelude: maximumByMay :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> mono -> Maybe (Element mono)
+ DMCC.Prelude: maximumEx :: (MonoFoldable mono, Ord (Element mono)) => mono -> Element mono
+ DMCC.Prelude: maximumMay :: (MonoFoldable mono, Ord (Element mono)) => mono -> Maybe (Element mono)
+ DMCC.Prelude: maybe :: () => b -> (a -> b) -> Maybe a -> b
+ DMCC.Prelude: maybeToList :: () => Maybe a -> [a]
+ DMCC.Prelude: mconcat :: Monoid a => [a] -> a
+ DMCC.Prelude: member :: SetContainer set => ContainerKey set -> set -> Bool
+ DMCC.Prelude: memoizeMVar :: MonadUnliftIO m => m a -> m (Memoized a)
+ DMCC.Prelude: memoizeRef :: MonadUnliftIO m => m a -> m (Memoized a)
+ DMCC.Prelude: mempty :: Monoid a => a
+ DMCC.Prelude: min :: Ord a => a -> a -> a
+ DMCC.Prelude: minBound :: Bounded a => a
+ DMCC.Prelude: minimum :: (MonoFoldable mono, Ord (Element mono)) => NonNull mono -> Element mono
+ DMCC.Prelude: minimumBy :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> NonNull mono -> Element mono
+ DMCC.Prelude: minimumByEx :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> mono -> Element mono
+ DMCC.Prelude: minimumByMay :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> mono -> Maybe (Element mono)
+ DMCC.Prelude: minimumEx :: (MonoFoldable mono, Ord (Element mono)) => mono -> Element mono
+ DMCC.Prelude: minimumMay :: (MonoFoldable mono, Ord (Element mono)) => mono -> Maybe (Element mono)
+ DMCC.Prelude: mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError
+ DMCC.Prelude: mkWeakIORef :: MonadUnliftIO m => IORef a -> m () -> m (Weak (IORef a))
+ DMCC.Prelude: mkWeakMVar :: MonadUnliftIO m => MVar a -> m () -> m (Weak (MVar a))
+ DMCC.Prelude: mod :: Integral a => a -> a -> a
+ DMCC.Prelude: modifyIOError :: () => (IOError -> IOError) -> IO a -> IO a
+ DMCC.Prelude: modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m ()
+ DMCC.Prelude: modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m ()
+ DMCC.Prelude: modifyMVar :: MonadUnliftIO m => MVar a -> (a -> m (a, b)) -> m b
+ DMCC.Prelude: modifyMVarMasked :: MonadUnliftIO m => MVar a -> (a -> m (a, b)) -> m b
+ DMCC.Prelude: modifyMVarMasked_ :: MonadUnliftIO m => MVar a -> (a -> m a) -> m ()
+ DMCC.Prelude: modifyMVar_ :: MonadUnliftIO m => MVar a -> (a -> m a) -> m ()
+ DMCC.Prelude: modifyMutVar :: PrimMonad m => MutVar (PrimState m) a -> (a -> a) -> m ()
+ DMCC.Prelude: modifyMutVar' :: PrimMonad m => MutVar (PrimState m) a -> (a -> a) -> m ()
+ DMCC.Prelude: modifyRef :: (MutableRef c, PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> RefElement c) -> m ()
+ DMCC.Prelude: modifyRef' :: (MutableRef c, PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> RefElement c) -> m ()
+ DMCC.Prelude: modifyTVar :: () => TVar a -> (a -> a) -> STM ()
+ DMCC.Prelude: modifyTVar' :: () => TVar a -> (a -> a) -> STM ()
+ DMCC.Prelude: mplus :: MonadPlus m => m a -> m a -> m a
+ DMCC.Prelude: mzero :: MonadPlus m => m a
+ DMCC.Prelude: nReplicate :: IsSequence seq => Index seq -> Element seq -> NonNull seq
+ DMCC.Prelude: ncons :: SemiSequence seq => Element seq -> seq -> NonNull seq
+ DMCC.Prelude: negate :: Num a => a -> a
+ DMCC.Prelude: newBroadcastTChan :: () => STM (TChan a)
+ DMCC.Prelude: newBroadcastTMChan :: () => STM (TMChan a)
+ DMCC.Prelude: newBroadcastTMChanIO :: () => IO (TMChan a)
+ DMCC.Prelude: newChan :: MonadIO m => m (Chan a)
+ DMCC.Prelude: newColl :: (MutableCollection c, PrimMonad m, PrimState m ~ MCState c) => m c
+ DMCC.Prelude: newEmptyMVar :: MonadIO m => m (MVar a)
+ DMCC.Prelude: newEmptyTMVar :: () => STM (TMVar a)
+ DMCC.Prelude: newIORef :: MonadIO m => a -> m (IORef a)
+ DMCC.Prelude: newMVar :: MonadIO m => a -> m (MVar a)
+ DMCC.Prelude: newMutVar :: PrimMonad m => a -> m (MutVar (PrimState m) a)
+ DMCC.Prelude: newRef :: (MutableRef c, PrimMonad m, PrimState m ~ MCState c) => RefElement c -> m c
+ DMCC.Prelude: newTBChan :: () => Int -> STM (TBChan a)
+ DMCC.Prelude: newTBChanIO :: () => Int -> IO (TBChan a)
+ DMCC.Prelude: newTBMChan :: () => Int -> STM (TBMChan a)
+ DMCC.Prelude: newTBMChanIO :: () => Int -> IO (TBMChan a)
+ DMCC.Prelude: newTBMQueue :: () => Int -> STM (TBMQueue a)
+ DMCC.Prelude: newTBMQueueIO :: () => Int -> IO (TBMQueue a)
+ DMCC.Prelude: newTBQueue :: () => Natural -> STM (TBQueue a)
+ DMCC.Prelude: newTChan :: () => STM (TChan a)
+ DMCC.Prelude: newTMChan :: () => STM (TMChan a)
+ DMCC.Prelude: newTMChanIO :: () => IO (TMChan a)
+ DMCC.Prelude: newTMQueue :: () => STM (TMQueue a)
+ DMCC.Prelude: newTMQueueIO :: () => IO (TMQueue a)
+ DMCC.Prelude: newTMVar :: () => a -> STM (TMVar a)
+ DMCC.Prelude: newTQueue :: () => STM (TQueue a)
+ DMCC.Prelude: newTVar :: () => a -> STM (TVar a)
+ DMCC.Prelude: newtype Concurrently (m :: Type -> Type) a
+ DMCC.Prelude: newtype Day
+ DMCC.Prelude: newtype Down a
+ DMCC.Prelude: newtype Identity a
+ DMCC.Prelude: newtype ReaderT r (m :: k -> Type) (a :: k) :: forall k. () => Type -> k -> Type -> k -> Type
+ DMCC.Prelude: newtype UnliftIO (m :: Type -> Type)
+ DMCC.Prelude: nfilter :: IsSequence seq => (Element seq -> Bool) -> NonNull seq -> seq
+ DMCC.Prelude: nfilterM :: (Monad m, IsSequence seq) => (Element seq -> m Bool) -> NonNull seq -> m seq
+ DMCC.Prelude: nonNull :: MonoFoldable mono => mono -> NonNull mono
+ DMCC.Prelude: not :: Bool -> Bool
+ DMCC.Prelude: notElem :: (MonoFoldable mono, Eq (Element mono)) => Element mono -> mono -> Bool
+ DMCC.Prelude: notMember :: SetContainer set => ContainerKey set -> set -> Bool
+ DMCC.Prelude: null :: MonoFoldable mono => mono -> Bool
+ DMCC.Prelude: nuncons :: IsSequence seq => NonNull seq -> (Element seq, Maybe (NonNull seq))
+ DMCC.Prelude: oall :: MonoFoldable mono => (Element mono -> Bool) -> mono -> Bool
+ DMCC.Prelude: oand :: (Element mono ~ Bool, MonoFoldable mono) => mono -> Bool
+ DMCC.Prelude: oany :: MonoFoldable mono => (Element mono -> Bool) -> mono -> Bool
+ DMCC.Prelude: ocompareLength :: (MonoFoldable mono, Integral i) => mono -> i -> Ordering
+ DMCC.Prelude: oconcat :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono
+ DMCC.Prelude: oconcatMap :: (MonoFoldable mono, Monoid m) => (Element mono -> m) -> mono -> m
+ DMCC.Prelude: odd :: Integral a => a -> Bool
+ DMCC.Prelude: oelem :: MonoFoldable mono => Element mono -> mono -> Bool
+ DMCC.Prelude: oextend :: MonoComonad mono => (mono -> Element mono) -> mono -> mono
+ DMCC.Prelude: oextract :: MonoComonad mono => mono -> Element mono
+ DMCC.Prelude: ofold :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono
+ DMCC.Prelude: ofold1 :: (MonoFoldable mono, Semigroup (Element mono)) => NonNull mono -> Element mono
+ DMCC.Prelude: ofoldM :: (MonoFoldable mono, Monad m) => (a -> Element mono -> m a) -> a -> mono -> m a
+ DMCC.Prelude: ofoldMUnwrap :: (Monad m, MonoFoldable mono) => (x -> Element mono -> m x) -> m x -> (x -> m b) -> mono -> m b
+ DMCC.Prelude: ofoldMap :: (MonoFoldable mono, Monoid m) => (Element mono -> m) -> mono -> m
+ DMCC.Prelude: ofoldMap1 :: (MonoFoldable mono, Semigroup m) => (Element mono -> m) -> NonNull mono -> m
+ DMCC.Prelude: ofoldMap1Ex :: (MonoFoldable mono, Semigroup m) => (Element mono -> m) -> mono -> m
+ DMCC.Prelude: ofoldl' :: MonoFoldable mono => (a -> Element mono -> a) -> a -> mono -> a
+ DMCC.Prelude: ofoldl1' :: MonoFoldable mono => (Element mono -> Element mono -> Element mono) -> NonNull mono -> Element mono
+ DMCC.Prelude: ofoldl1Ex' :: MonoFoldable mono => (Element mono -> Element mono -> Element mono) -> mono -> Element mono
+ DMCC.Prelude: ofoldlM :: (MonoFoldable mono, Monad m) => (a -> Element mono -> m a) -> a -> mono -> m a
+ DMCC.Prelude: ofoldlUnwrap :: MonoFoldable mono => (x -> Element mono -> x) -> x -> (x -> b) -> mono -> b
+ DMCC.Prelude: ofoldr :: MonoFoldable mono => (Element mono -> b -> b) -> b -> mono -> b
+ DMCC.Prelude: ofoldr1 :: MonoFoldable mono => (Element mono -> Element mono -> Element mono) -> NonNull mono -> Element mono
+ DMCC.Prelude: ofoldr1Ex :: MonoFoldable mono => (Element mono -> Element mono -> Element mono) -> mono -> Element mono
+ DMCC.Prelude: ofor :: (MonoTraversable mono, Applicative f) => mono -> (Element mono -> f (Element mono)) -> f mono
+ DMCC.Prelude: oforM :: (MonoTraversable mono, Applicative f) => mono -> (Element mono -> f (Element mono)) -> f mono
+ DMCC.Prelude: oforM_ :: (MonoFoldable mono, Applicative m) => mono -> (Element mono -> m ()) -> m ()
+ DMCC.Prelude: ofor_ :: (MonoFoldable mono, Applicative f) => mono -> (Element mono -> f b) -> f ()
+ DMCC.Prelude: ointercalate :: (MonoFoldable mono, Monoid (Element mono)) => Element mono -> mono -> Element mono
+ DMCC.Prelude: olength :: MonoFoldable mono => mono -> Int
+ DMCC.Prelude: olength64 :: MonoFoldable mono => mono -> Int64
+ DMCC.Prelude: omap :: MonoFunctor mono => (Element mono -> Element mono) -> mono -> mono
+ DMCC.Prelude: omapKeysWith :: IsMap map => (MapValue map -> MapValue map -> MapValue map) -> (ContainerKey map -> ContainerKey map) -> map -> map
+ DMCC.Prelude: omapM :: (MonoTraversable mono, Applicative m) => (Element mono -> m (Element mono)) -> mono -> m mono
+ DMCC.Prelude: omapM_ :: (MonoFoldable mono, Applicative m) => (Element mono -> m ()) -> mono -> m ()
+ DMCC.Prelude: on :: () => (b -> b -> c) -> (a -> b) -> a -> a -> c
+ DMCC.Prelude: onException :: MonadUnliftIO m => m a -> m b -> m a
+ DMCC.Prelude: onotElem :: MonoFoldable mono => Element mono -> mono -> Bool
+ DMCC.Prelude: onull :: MonoFoldable mono => mono -> Bool
+ DMCC.Prelude: oor :: (Element mono ~ Bool, MonoFoldable mono) => mono -> Bool
+ DMCC.Prelude: opoint :: MonoPointed mono => Element mono -> mono
+ DMCC.Prelude: oproduct :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono
+ DMCC.Prelude: optional :: Alternative f => f a -> f (Maybe a)
+ DMCC.Prelude: or :: (MonoFoldable mono, Element mono ~ Bool) => mono -> Bool
+ DMCC.Prelude: orElseSTM :: () => STM a -> STM a -> STM a
+ DMCC.Prelude: ordNub :: Ord a => [a] -> [a]
+ DMCC.Prelude: ordNubBy :: Ord b => (a -> b) -> (a -> a -> Bool) -> [a] -> [a]
+ DMCC.Prelude: osequence_ :: (Applicative m, MonoFoldable mono, Element mono ~ m ()) => mono -> m ()
+ DMCC.Prelude: osum :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono
+ DMCC.Prelude: otherwise :: Bool
+ DMCC.Prelude: otoList :: MonoFoldable mono => mono -> [Element mono]
+ DMCC.Prelude: otraverse :: (MonoTraversable mono, Applicative f) => (Element mono -> f (Element mono)) -> mono -> f mono
+ DMCC.Prelude: otraverse_ :: (MonoFoldable mono, Applicative f) => (Element mono -> f b) -> mono -> f ()
+ DMCC.Prelude: ounzip :: MonoZip mono => [(Element mono, Element mono)] -> (mono, mono)
+ DMCC.Prelude: ozip :: MonoZip mono => mono -> mono -> [(Element mono, Element mono)]
+ DMCC.Prelude: ozipWith :: MonoZip mono => (Element mono -> Element mono -> Element mono) -> mono -> mono -> mono
+ DMCC.Prelude: pack :: IsSequence seq => [Element seq] -> seq
+ DMCC.Prelude: parseTime :: ParseTime t => TimeLocale -> String -> String -> Maybe t
+ DMCC.Prelude: parseTimeM :: (Monad m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
+ DMCC.Prelude: partition :: IsSequence seq => (Element seq -> Bool) -> seq -> (seq, seq)
+ DMCC.Prelude: partitionEithers :: () => [Either a b] -> ([a], [b])
+ DMCC.Prelude: peekTBChan :: () => TBChan a -> STM a
+ DMCC.Prelude: peekTBMChan :: () => TBMChan a -> STM (Maybe a)
+ DMCC.Prelude: peekTBMQueue :: () => TBMQueue a -> STM (Maybe a)
+ DMCC.Prelude: peekTBQueue :: () => TBQueue a -> STM a
+ DMCC.Prelude: peekTChan :: () => TChan a -> STM a
+ DMCC.Prelude: peekTMChan :: () => TMChan a -> STM (Maybe a)
+ DMCC.Prelude: peekTMQueue :: () => TMQueue a -> STM (Maybe a)
+ DMCC.Prelude: peekTQueue :: () => TQueue a -> STM a
+ DMCC.Prelude: permissionErrorType :: IOErrorType
+ DMCC.Prelude: permutations :: IsSequence seq => seq -> [seq]
+ DMCC.Prelude: pi :: Floating a => a
+ DMCC.Prelude: point :: MonoPointed mono => Element mono -> mono
+ DMCC.Prelude: poll :: MonadIO m => Async a -> m (Maybe (Either SomeException a))
+ DMCC.Prelude: pollAsync :: MonadIO m => Async a -> m (Maybe (Either SomeException a))
+ DMCC.Prelude: pollSTM :: () => Async a -> STM (Maybe (Either SomeException a))
+ DMCC.Prelude: popBack :: (MutablePopBack c, PrimMonad m, PrimState m ~ MCState c) => c -> m (Maybe (CollElement c))
+ DMCC.Prelude: popFront :: (MutablePopFront c, PrimMonad m, PrimState m ~ MCState c) => c -> m (Maybe (CollElement c))
+ DMCC.Prelude: pred :: Enum a => a -> a
+ DMCC.Prelude: primToIO :: (PrimBase m, PrimState m ~ RealWorld) => m a -> IO a
+ DMCC.Prelude: primToPrim :: (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) => m1 a -> m2 a
+ DMCC.Prelude: primToST :: PrimBase m => m a -> ST (PrimState m) a
+ DMCC.Prelude: print :: (Show a, MonadIO m) => a -> m ()
+ DMCC.Prelude: product :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono
+ DMCC.Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ DMCC.Prelude: pure :: Applicative f => a -> f a
+ DMCC.Prelude: pureTry :: () => a -> Either SomeException a
+ DMCC.Prelude: pureTryDeep :: NFData a => a -> Either SomeException a
+ DMCC.Prelude: pushBack :: (MutablePushBack c, PrimMonad m, PrimState m ~ MCState c) => c -> CollElement c -> m ()
+ DMCC.Prelude: pushFront :: (MutablePushFront c, PrimMonad m, PrimState m ~ MCState c) => c -> CollElement c -> m ()
+ DMCC.Prelude: putChar :: MonadIO m => Char -> m ()
+ DMCC.Prelude: putMVar :: MonadIO m => MVar a -> a -> m ()
+ DMCC.Prelude: putStr :: MonadIO m => Text -> m ()
+ DMCC.Prelude: putStrLn :: MonadIO m => Text -> m ()
+ DMCC.Prelude: putTMVar :: () => TMVar a -> a -> STM ()
+ DMCC.Prelude: quot :: Integral a => a -> a -> a
+ DMCC.Prelude: quotRem :: Integral a => a -> a -> (a, a)
+ DMCC.Prelude: race :: MonadUnliftIO m => m a -> m b -> m (Either a b)
+ DMCC.Prelude: race_ :: MonadUnliftIO m => m a -> m b -> m ()
+ DMCC.Prelude: readChan :: MonadIO m => Chan a -> m a
+ DMCC.Prelude: readFile :: MonadIO m => FilePath -> m ByteString
+ DMCC.Prelude: readFileUtf8 :: MonadIO m => FilePath -> m Text
+ DMCC.Prelude: readIORef :: MonadIO m => IORef a -> m a
+ DMCC.Prelude: readMVar :: MonadIO m => MVar a -> m a
+ DMCC.Prelude: readMay :: (Element c ~ Char, MonoFoldable c, Read a) => c -> Maybe a
+ DMCC.Prelude: readMutVar :: PrimMonad m => MutVar (PrimState m) a -> m a
+ DMCC.Prelude: readRef :: (MutableRef c, PrimMonad m, PrimState m ~ MCState c) => c -> m (RefElement c)
+ DMCC.Prelude: readTBChan :: () => TBChan a -> STM a
+ DMCC.Prelude: readTBMChan :: () => TBMChan a -> STM (Maybe a)
+ DMCC.Prelude: readTBMQueue :: () => TBMQueue a -> STM (Maybe a)
+ DMCC.Prelude: readTBQueue :: () => TBQueue a -> STM a
+ DMCC.Prelude: readTChan :: () => TChan a -> STM a
+ DMCC.Prelude: readTMChan :: () => TMChan a -> STM (Maybe a)
+ DMCC.Prelude: readTMQueue :: () => TMQueue a -> STM (Maybe a)
+ DMCC.Prelude: readTMVar :: () => TMVar a -> STM a
+ DMCC.Prelude: readTQueue :: () => TQueue a -> STM a
+ DMCC.Prelude: readTVar :: () => TVar a -> STM a
+ DMCC.Prelude: realToFrac :: (Real a, Fractional b) => a -> b
+ DMCC.Prelude: recip :: Fractional a => a -> a
+ DMCC.Prelude: rem :: Integral a => a -> a -> a
+ DMCC.Prelude: repack :: (MonoFoldable a, IsSequence b, Element a ~ Element b) => a -> b
+ DMCC.Prelude: repeat :: () => a -> [a]
+ DMCC.Prelude: replaceElem :: (MonoFunctor mono, Eq (Element mono)) => Element mono -> Element mono -> mono -> mono
+ DMCC.Prelude: replaceElemLazyText :: Char -> Char -> Text -> Text
+ DMCC.Prelude: replaceElemStrictText :: Char -> Char -> Text -> Text
+ DMCC.Prelude: replaceSeq :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> seq -> seq
+ DMCC.Prelude: replaceSeqLazyText :: Text -> Text -> Text -> Text
+ DMCC.Prelude: replaceSeqStrictText :: Text -> Text -> Text -> Text
+ DMCC.Prelude: replicate :: IsSequence seq => Index seq -> Element seq -> seq
+ DMCC.Prelude: replicateConcurrently :: MonadUnliftIO m => Int -> m a -> m [a]
+ DMCC.Prelude: replicateConcurrently_ :: MonadUnliftIO m => Int -> m a -> m ()
+ DMCC.Prelude: replicateM :: (IsSequence seq, Monad m) => Index seq -> m (Element seq) -> m seq
+ DMCC.Prelude: replicateM_ :: Applicative m => Int -> m a -> m ()
+ DMCC.Prelude: retrySTM :: () => STM a
+ DMCC.Prelude: return :: Monad m => a -> m a
+ DMCC.Prelude: reverse :: SemiSequence seq => seq -> seq
+ DMCC.Prelude: rights :: () => [Either a b] -> [b]
+ DMCC.Prelude: rnf :: NFData a => a -> ()
+ DMCC.Prelude: round :: (RealFrac a, Integral b) => a -> b
+ DMCC.Prelude: runMemoized :: MonadIO m => Memoized a -> m a
+ DMCC.Prelude: say :: MonadIO m => Text -> m ()
+ DMCC.Prelude: sayErr :: MonadIO m => Text -> m ()
+ DMCC.Prelude: sayErrShow :: (MonadIO m, Show a) => a -> m ()
+ DMCC.Prelude: sayErrString :: MonadIO m => String -> m ()
+ DMCC.Prelude: sayShow :: (MonadIO m, Show a) => a -> m ()
+ DMCC.Prelude: sayString :: MonadIO m => String -> m ()
+ DMCC.Prelude: scaleFloat :: RealFloat a => Int -> a -> a
+ DMCC.Prelude: sconcat :: Semigroup a => NonEmpty a -> a
+ DMCC.Prelude: second :: Bifunctor p => (b -> c) -> p a b -> p a c
+ DMCC.Prelude: seq :: () => a -> b -> b
+ DMCC.Prelude: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
+ DMCC.Prelude: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
+ DMCC.Prelude: sequence_ :: (Applicative m, MonoFoldable mono, Element mono ~ m ()) => mono -> m ()
+ DMCC.Prelude: setFromList :: IsSet set => [Element set] -> set
+ DMCC.Prelude: setToList :: IsSet set => set -> [Element set]
+ DMCC.Prelude: show :: Show a => a -> String
+ DMCC.Prelude: showList :: Show a => [a] -> ShowS
+ DMCC.Prelude: showsPrec :: Show a => Int -> a -> ShowS
+ DMCC.Prelude: significand :: RealFloat a => a -> a
+ DMCC.Prelude: signum :: Num a => a -> a
+ DMCC.Prelude: sin :: Floating a => a -> a
+ DMCC.Prelude: singleton :: MonoPointed seq => Element seq -> seq
+ DMCC.Prelude: singletonMap :: IsMap map => ContainerKey map -> MapValue map -> map
+ DMCC.Prelude: singletonSet :: IsSet set => Element set -> set
+ DMCC.Prelude: sinh :: Floating a => a -> a
+ DMCC.Prelude: snd :: () => (a, b) -> b
+ DMCC.Prelude: snoc :: SemiSequence seq => seq -> Element seq -> seq
+ DMCC.Prelude: some :: Alternative f => f a -> f [a]
+ DMCC.Prelude: sort :: (SemiSequence seq, Ord (Element seq)) => seq -> seq
+ DMCC.Prelude: sortBy :: SemiSequence seq => (Element seq -> Element seq -> Ordering) -> seq -> seq
+ DMCC.Prelude: sortOn :: (Ord o, SemiSequence seq) => (Element seq -> o) -> seq -> seq
+ DMCC.Prelude: sortWith :: (Ord a, IsSequence c) => (Element c -> a) -> c -> c
+ DMCC.Prelude: span :: IsSequence seq => (Element seq -> Bool) -> seq -> (seq, seq)
+ DMCC.Prelude: splitAt :: IsSequence seq => Index seq -> seq -> (seq, seq)
+ DMCC.Prelude: splitElem :: (IsSequence seq, Eq (Element seq)) => Element seq -> seq -> [seq]
+ DMCC.Prelude: splitElemStrictBS :: Word8 -> ByteString -> [ByteString]
+ DMCC.Prelude: splitFirst :: IsSequence seq => NonNull seq -> (Element seq, seq)
+ DMCC.Prelude: splitSeq :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> [seq]
+ DMCC.Prelude: splitSeqLazyBS :: Word8 -> ByteString -> [ByteString]
+ DMCC.Prelude: splitSeqLazyText :: Text -> Text -> [Text]
+ DMCC.Prelude: splitSeqStrictText :: Text -> Text -> [Text]
+ DMCC.Prelude: splitWhen :: IsSequence seq => (Element seq -> Bool) -> seq -> [seq]
+ DMCC.Prelude: sqrt :: Floating a => a -> a
+ DMCC.Prelude: stderr :: Handle
+ DMCC.Prelude: stdin :: Handle
+ DMCC.Prelude: stdout :: Handle
+ DMCC.Prelude: stimes :: (Semigroup a, Integral b) => b -> a -> a
+ DMCC.Prelude: stringException :: HasCallStack -> String -> StringException
+ DMCC.Prelude: stripPrefix :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Maybe seq
+ DMCC.Prelude: stripPrefixLazyBS :: ByteString -> ByteString -> Maybe ByteString
+ DMCC.Prelude: stripPrefixStrictBS :: ByteString -> ByteString -> Maybe ByteString
+ DMCC.Prelude: stripSuffix :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Maybe seq
+ DMCC.Prelude: stripSuffixLazyBS :: ByteString -> ByteString -> Maybe ByteString
+ DMCC.Prelude: stripSuffixStrictBS :: ByteString -> ByteString -> Maybe ByteString
+ DMCC.Prelude: subsequences :: IsSequence seq => seq -> [seq]
+ DMCC.Prelude: subtract :: Num a => a -> a -> a
+ DMCC.Prelude: succ :: Enum a => a -> a
+ DMCC.Prelude: sum :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono
+ DMCC.Prelude: swap :: () => (a, b) -> (b, a)
+ DMCC.Prelude: swapMVar :: MonadIO m => MVar a -> a -> m a
+ DMCC.Prelude: swapTMVar :: () => TMVar a -> a -> STM a
+ DMCC.Prelude: swapTVar :: () => TVar a -> a -> STM a
+ DMCC.Prelude: tail :: IsSequence seq => NonNull seq -> seq
+ DMCC.Prelude: tailDef :: IsSequence seq => seq -> seq
+ DMCC.Prelude: tailEx :: IsSequence seq => seq -> seq
+ DMCC.Prelude: tailMay :: IsSequence seq => seq -> Maybe seq
+ DMCC.Prelude: take :: IsSequence seq => Index seq -> seq -> seq
+ DMCC.Prelude: takeMVar :: MonadIO m => MVar a -> m a
+ DMCC.Prelude: takeTMVar :: () => TMVar a -> STM a
+ DMCC.Prelude: takeWhile :: IsSequence seq => (Element seq -> Bool) -> seq -> seq
+ DMCC.Prelude: tan :: Floating a => a -> a
+ DMCC.Prelude: tanh :: Floating a => a -> a
+ DMCC.Prelude: terror :: HasCallStack => Text -> a
+ DMCC.Prelude: textToBuilder :: ToBuilder Text builder => Text -> builder
+ DMCC.Prelude: throwIO :: (MonadIO m, Exception e) => e -> m a
+ DMCC.Prelude: throwString :: (MonadIO m, HasCallStack) => String -> m a
+ DMCC.Prelude: throwTo :: (Exception e, MonadIO m) => ThreadId -> e -> m ()
+ DMCC.Prelude: timeout :: MonadUnliftIO m => Int -> m a -> m (Maybe a)
+ DMCC.Prelude: tlshow :: Show a => a -> LText
+ DMCC.Prelude: toAsyncException :: Exception e => e -> SomeException
+ DMCC.Prelude: toBuilder :: ToBuilder value builder => value -> builder
+ DMCC.Prelude: toByteVector :: ByteString -> SVector Word8
+ DMCC.Prelude: toCaseFold :: Textual t => t -> t
+ DMCC.Prelude: toChunks :: LazySequence lazy strict => lazy -> [strict]
+ DMCC.Prelude: toEnum :: Enum a => Int -> a
+ DMCC.Prelude: toException :: Exception e => e -> SomeException
+ DMCC.Prelude: toGregorian :: Day -> (Integer, Int, Int)
+ DMCC.Prelude: toIO :: MonadUnliftIO m => m a -> m (IO a)
+ DMCC.Prelude: toInteger :: Integral a => a -> Integer
+ DMCC.Prelude: toList :: MonoFoldable mono => mono -> [Element mono]
+ DMCC.Prelude: toLower :: Textual t => t -> t
+ DMCC.Prelude: toMinList :: () => NonEmpty a -> NonNull [a]
+ DMCC.Prelude: toRational :: Real a => a -> Rational
+ DMCC.Prelude: toStrict :: LazySequence lazy strict => lazy -> strict
+ DMCC.Prelude: toSyncException :: Exception e => e -> SomeException
+ DMCC.Prelude: toUpper :: Textual t => t -> t
+ DMCC.Prelude: trace :: () => String -> a -> a
+ DMCC.Prelude: traceId :: String -> String
+ DMCC.Prelude: traceM :: Monad m => String -> m ()
+ DMCC.Prelude: traceShow :: Show a => a -> b -> b
+ DMCC.Prelude: traceShowId :: Show a => a -> a
+ DMCC.Prelude: traceShowM :: (Show a, Monad m) => a -> m ()
+ DMCC.Prelude: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
+ DMCC.Prelude: traverse_ :: (MonoFoldable mono, Applicative f) => (Element mono -> f b) -> mono -> f ()
+ DMCC.Prelude: truncate :: (RealFrac a, Integral b) => a -> b
+ DMCC.Prelude: try :: (MonadUnliftIO m, Exception e) => m a -> m (Either e a)
+ DMCC.Prelude: tryAny :: MonadUnliftIO m => m a -> m (Either SomeException a)
+ DMCC.Prelude: tryAnyDeep :: (MonadUnliftIO m, NFData a) => m a -> m (Either SomeException a)
+ DMCC.Prelude: tryDeep :: (MonadUnliftIO m, Exception e, NFData a) => m a -> m (Either e a)
+ DMCC.Prelude: tryIO :: MonadUnliftIO m => m a -> m (Either IOException a)
+ DMCC.Prelude: tryIOError :: () => IO a -> IO (Either IOError a)
+ DMCC.Prelude: tryJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a)
+ DMCC.Prelude: tryPeekTBChan :: () => TBChan a -> STM (Maybe a)
+ DMCC.Prelude: tryPeekTBMChan :: () => TBMChan a -> STM (Maybe (Maybe a))
+ DMCC.Prelude: tryPeekTBMQueue :: () => TBMQueue a -> STM (Maybe (Maybe a))
+ DMCC.Prelude: tryPeekTBQueue :: () => TBQueue a -> STM (Maybe a)
+ DMCC.Prelude: tryPeekTChan :: () => TChan a -> STM (Maybe a)
+ DMCC.Prelude: tryPeekTMChan :: () => TMChan a -> STM (Maybe (Maybe a))
+ DMCC.Prelude: tryPeekTMQueue :: () => TMQueue a -> STM (Maybe (Maybe a))
+ DMCC.Prelude: tryPeekTQueue :: () => TQueue a -> STM (Maybe a)
+ DMCC.Prelude: tryPutMVar :: MonadIO m => MVar a -> a -> m Bool
+ DMCC.Prelude: tryPutTMVar :: () => TMVar a -> a -> STM Bool
+ DMCC.Prelude: tryReadMVar :: MonadIO m => MVar a -> m (Maybe a)
+ DMCC.Prelude: tryReadTBChan :: () => TBChan a -> STM (Maybe a)
+ DMCC.Prelude: tryReadTBMChan :: () => TBMChan a -> STM (Maybe (Maybe a))
+ DMCC.Prelude: tryReadTBMQueue :: () => TBMQueue a -> STM (Maybe (Maybe a))
+ DMCC.Prelude: tryReadTBQueue :: () => TBQueue a -> STM (Maybe a)
+ DMCC.Prelude: tryReadTChan :: () => TChan a -> STM (Maybe a)
+ DMCC.Prelude: tryReadTMChan :: () => TMChan a -> STM (Maybe (Maybe a))
+ DMCC.Prelude: tryReadTMQueue :: () => TMQueue a -> STM (Maybe (Maybe a))
+ DMCC.Prelude: tryReadTMVar :: () => TMVar a -> STM (Maybe a)
+ DMCC.Prelude: tryReadTQueue :: () => TQueue a -> STM (Maybe a)
+ DMCC.Prelude: tryTakeMVar :: MonadIO m => MVar a -> m (Maybe a)
+ DMCC.Prelude: tryTakeTMVar :: () => TMVar a -> STM (Maybe a)
+ DMCC.Prelude: tryWriteTBChan :: () => TBChan a -> a -> STM Bool
+ DMCC.Prelude: tryWriteTBMChan :: () => TBMChan a -> a -> STM (Maybe Bool)
+ DMCC.Prelude: tryWriteTBMQueue :: () => TBMQueue a -> a -> STM (Maybe Bool)
+ DMCC.Prelude: tshow :: Show a => a -> Text
+ DMCC.Prelude: type BDeque = Deque MVector
+ DMCC.Prelude: type BlazeBuilder = Builder
+ DMCC.Prelude: type ByteStringBuilder = Builder
+ DMCC.Prelude: type FilePath = String
+ DMCC.Prelude: type IOBRef = BRef PrimState IO
+ DMCC.Prelude: type IOError = IOException
+ DMCC.Prelude: type IOPRef = PRef PrimState IO
+ DMCC.Prelude: type IOSRef = SRef PrimState IO
+ DMCC.Prelude: type IOURef = URef PrimState IO
+ DMCC.Prelude: type LByteString = ByteString
+ DMCC.Prelude: type LText = Text
+ DMCC.Prelude: type MutableDeque c = (MutableQueue c, MutablePushFront c, MutablePopBack c)
+ DMCC.Prelude: type MutableQueue c = (MutablePopFront c, MutablePushBack c)
+ DMCC.Prelude: type MutableStack c = (MutablePopFront c, MutablePushFront c)
+ DMCC.Prelude: type Rational = Ratio Integer
+ DMCC.Prelude: type Reader r = ReaderT r Identity
+ DMCC.Prelude: type SDeque = Deque MVector
+ DMCC.Prelude: type SVector = Vector
+ DMCC.Prelude: type String = [Char]
+ DMCC.Prelude: type TextBuilder = Builder
+ DMCC.Prelude: type UDeque = Deque MVector
+ DMCC.Prelude: type UVector = Vector
+ DMCC.Prelude: type family Index seq :: Type;
+ DMCC.Prelude: unGetTBChan :: () => TBChan a -> a -> STM ()
+ DMCC.Prelude: unGetTBMChan :: () => TBMChan a -> a -> STM ()
+ DMCC.Prelude: unGetTBMQueue :: () => TBMQueue a -> a -> STM ()
+ DMCC.Prelude: unGetTBQueue :: () => TBQueue a -> a -> STM ()
+ DMCC.Prelude: unGetTChan :: () => TChan a -> a -> STM ()
+ DMCC.Prelude: unGetTMChan :: () => TMChan a -> a -> STM ()
+ DMCC.Prelude: unGetTMQueue :: () => TMQueue a -> a -> STM ()
+ DMCC.Prelude: unGetTQueue :: () => TQueue a -> a -> STM ()
+ DMCC.Prelude: uncons :: IsSequence seq => seq -> Maybe (Element seq, seq)
+ DMCC.Prelude: uncurry :: () => (a -> b -> c) -> (a, b) -> c
+ DMCC.Prelude: undefined :: HasCallStack => a
+ DMCC.Prelude: uninterruptibleCancel :: MonadIO m => Async a -> m ()
+ DMCC.Prelude: uninterruptibleMask :: MonadUnliftIO m => ((forall a. () => m a -> m a) -> m b) -> m b
+ DMCC.Prelude: uninterruptibleMask_ :: MonadUnliftIO m => m a -> m a
+ DMCC.Prelude: union :: SetContainer set => set -> set -> set
+ DMCC.Prelude: unionWith :: IsMap map => (MapValue map -> MapValue map -> MapValue map) -> map -> map -> map
+ DMCC.Prelude: unionWithKey :: IsMap map => (ContainerKey map -> MapValue map -> MapValue map -> MapValue map) -> map -> map -> map
+ DMCC.Prelude: unions :: (SetContainer set, MonoFoldable mono, Element mono ~ set) => mono -> set
+ DMCC.Prelude: unionsWith :: IsMap map => (MapValue map -> MapValue map -> MapValue map) -> [map] -> map
+ DMCC.Prelude: unless :: Applicative f => Bool -> f () -> f ()
+ DMCC.Prelude: unlessM :: Monad m => m Bool -> m () -> m ()
+ DMCC.Prelude: unlines :: (Textual t, Element seq ~ t, MonoFoldable seq) => seq -> t
+ DMCC.Prelude: unpack :: MonoFoldable mono => mono -> [Element mono]
+ DMCC.Prelude: unsafeDrop :: IsSequence seq => Index seq -> seq -> seq
+ DMCC.Prelude: unsafeHead :: MonoFoldable mono => mono -> Element mono
+ DMCC.Prelude: unsafeIndex :: IsSequence seq => seq -> Index seq -> Element seq
+ DMCC.Prelude: unsafeInit :: IsSequence seq => seq -> seq
+ DMCC.Prelude: unsafeLast :: MonoFoldable mono => mono -> Element mono
+ DMCC.Prelude: unsafeSplitAt :: IsSequence seq => Index seq -> seq -> (seq, seq)
+ DMCC.Prelude: unsafeTail :: IsSequence seq => seq -> seq
+ DMCC.Prelude: unsafeTake :: IsSequence seq => Index seq -> seq -> seq
+ DMCC.Prelude: unsnoc :: IsSequence seq => seq -> Maybe (seq, Element seq)
+ DMCC.Prelude: until :: () => (a -> Bool) -> (a -> a) -> a -> a
+ DMCC.Prelude: unwords :: (Textual t, Element seq ~ t, MonoFoldable seq) => seq -> t
+ DMCC.Prelude: unzip :: Zip f => f (a, b) -> (f a, f b)
+ DMCC.Prelude: unzip3 :: Zip3 f => f (a, b, c) -> (f a, f b, f c)
+ DMCC.Prelude: unzip4 :: Zip4 f => f (a, b, c, d) -> (f a, f b, f c, f d)
+ DMCC.Prelude: unzip5 :: Zip5 f => f (a, b, c, d, e) -> (f a, f b, f c, f d, f e)
+ DMCC.Prelude: unzip6 :: Zip6 f => f (a, b, c, d, e, g) -> (f a, f b, f c, f d, f e, f g)
+ DMCC.Prelude: unzip7 :: Zip7 f => f (a, b, c, d, e, g, h) -> (f a, f b, f c, f d, f e, f g, f h)
+ DMCC.Prelude: updateLookupWithKey :: IsMap map => (ContainerKey map -> MapValue map -> Maybe (MapValue map)) -> ContainerKey map -> map -> (Maybe (MapValue map), map)
+ DMCC.Prelude: updateMap :: IsMap map => (MapValue map -> Maybe (MapValue map)) -> ContainerKey map -> map -> map
+ DMCC.Prelude: updateWithKey :: IsMap map => (ContainerKey map -> MapValue map -> Maybe (MapValue map)) -> ContainerKey map -> map -> map
+ DMCC.Prelude: userError :: String -> IOError
+ DMCC.Prelude: userErrorType :: IOErrorType
+ DMCC.Prelude: vectorSort :: (Vector v e, Ord e) => v e -> v e
+ DMCC.Prelude: vectorSortBy :: Vector v e => (e -> e -> Ordering) -> v e -> v e
+ DMCC.Prelude: void :: Functor f => f a -> f ()
+ DMCC.Prelude: wait :: MonadIO m => Async a -> m a
+ DMCC.Prelude: waitAny :: MonadIO m => [Async a] -> m (Async a, a)
+ DMCC.Prelude: waitAnyCancel :: MonadIO m => [Async a] -> m (Async a, a)
+ DMCC.Prelude: waitAnyCatch :: MonadIO m => [Async a] -> m (Async a, Either SomeException a)
+ DMCC.Prelude: waitAnyCatchCancel :: MonadIO m => [Async a] -> m (Async a, Either SomeException a)
+ DMCC.Prelude: waitAnyCatchSTM :: () => [Async a] -> STM (Async a, Either SomeException a)
+ DMCC.Prelude: waitAnySTM :: () => [Async a] -> STM (Async a, a)
+ DMCC.Prelude: waitAsync :: MonadIO m => Async a -> m a
+ DMCC.Prelude: waitBoth :: MonadIO m => Async a -> Async b -> m (a, b)
+ DMCC.Prelude: waitBothSTM :: () => Async a -> Async b -> STM (a, b)
+ DMCC.Prelude: waitCatch :: MonadIO m => Async a -> m (Either SomeException a)
+ DMCC.Prelude: waitCatchAsync :: MonadIO m => Async a -> m (Either SomeException a)
+ DMCC.Prelude: waitCatchSTM :: () => Async a -> STM (Either SomeException a)
+ DMCC.Prelude: waitEither :: MonadIO m => Async a -> Async b -> m (Either a b)
+ DMCC.Prelude: waitEitherCancel :: MonadIO m => Async a -> Async b -> m (Either a b)
+ DMCC.Prelude: waitEitherCatch :: MonadIO m => Async a -> Async b -> m (Either (Either SomeException a) (Either SomeException b))
+ DMCC.Prelude: waitEitherCatchCancel :: MonadIO m => Async a -> Async b -> m (Either (Either SomeException a) (Either SomeException b))
+ DMCC.Prelude: waitEitherCatchSTM :: () => Async a -> Async b -> STM (Either (Either SomeException a) (Either SomeException b))
+ DMCC.Prelude: waitEitherSTM :: () => Async a -> Async b -> STM (Either a b)
+ DMCC.Prelude: waitEitherSTM_ :: () => Async a -> Async b -> STM ()
+ DMCC.Prelude: waitEither_ :: MonadIO m => Async a -> Async b -> m ()
+ DMCC.Prelude: waitSTM :: () => Async a -> STM a
+ DMCC.Prelude: when :: Applicative f => Bool -> f () -> f ()
+ DMCC.Prelude: whenM :: Monad m => m Bool -> m () -> m ()
+ DMCC.Prelude: withAsync :: MonadUnliftIO m => m a -> (Async a -> m b) -> m b
+ DMCC.Prelude: withAsyncBound :: MonadUnliftIO m => m a -> (Async a -> m b) -> m b
+ DMCC.Prelude: withAsyncOn :: MonadUnliftIO m => Int -> m a -> (Async a -> m b) -> m b
+ DMCC.Prelude: withAsyncOnWithUnmask :: MonadUnliftIO m => Int -> ((forall c. () => m c -> m c) -> m a) -> (Async a -> m b) -> m b
+ DMCC.Prelude: withAsyncWithUnmask :: MonadUnliftIO m => ((forall c. () => m c -> m c) -> m a) -> (Async a -> m b) -> m b
+ DMCC.Prelude: withBinaryFile :: MonadUnliftIO m => FilePath -> IOMode -> (Handle -> m a) -> m a
+ DMCC.Prelude: withException :: (MonadUnliftIO m, Exception e) => m a -> (e -> m b) -> m a
+ DMCC.Prelude: withFile :: MonadUnliftIO m => FilePath -> IOMode -> (Handle -> m a) -> m a
+ DMCC.Prelude: withMVar :: MonadUnliftIO m => MVar a -> (a -> m b) -> m b
+ DMCC.Prelude: withMVarMasked :: MonadUnliftIO m => MVar a -> (a -> m b) -> m b
+ DMCC.Prelude: withRunInIO :: MonadUnliftIO m => ((forall a. () => m a -> IO a) -> IO b) -> m b
+ DMCC.Prelude: withSystemTempDirectory :: MonadUnliftIO m => String -> (FilePath -> m a) -> m a
+ DMCC.Prelude: withSystemTempFile :: MonadUnliftIO m => String -> (FilePath -> Handle -> m a) -> m a
+ DMCC.Prelude: withTempDirectory :: MonadUnliftIO m => FilePath -> String -> (FilePath -> m a) -> m a
+ DMCC.Prelude: withTempFile :: MonadUnliftIO m => FilePath -> String -> (FilePath -> Handle -> m a) -> m a
+ DMCC.Prelude: withUnliftIO :: MonadUnliftIO m => (UnliftIO m -> IO a) -> m a
+ DMCC.Prelude: words :: Textual t => t -> [t]
+ DMCC.Prelude: wrappedWithRunInIO :: MonadUnliftIO n => (n b -> m b) -> (forall a. () => m a -> n a) -> ((forall a. () => m a -> IO a) -> IO b) -> m b
+ DMCC.Prelude: writeChan :: MonadIO m => Chan a -> a -> m ()
+ DMCC.Prelude: writeFile :: MonadIO m => FilePath -> ByteString -> m ()
+ DMCC.Prelude: writeFileUtf8 :: MonadIO m => FilePath -> Text -> m ()
+ DMCC.Prelude: writeIORef :: MonadIO m => IORef a -> a -> m ()
+ DMCC.Prelude: writeList2Chan :: MonadIO m => Chan a -> [a] -> m ()
+ DMCC.Prelude: writeMutVar :: PrimMonad m => MutVar (PrimState m) a -> a -> m ()
+ DMCC.Prelude: writeRef :: (MutableRef c, PrimMonad m, PrimState m ~ MCState c) => c -> RefElement c -> m ()
+ DMCC.Prelude: writeTBChan :: () => TBChan a -> a -> STM ()
+ DMCC.Prelude: writeTBMChan :: () => TBMChan a -> a -> STM ()
+ DMCC.Prelude: writeTBMQueue :: () => TBMQueue a -> a -> STM ()
+ DMCC.Prelude: writeTBQueue :: () => TBQueue a -> a -> STM ()
+ DMCC.Prelude: writeTChan :: () => TChan a -> a -> STM ()
+ DMCC.Prelude: writeTMChan :: () => TMChan a -> a -> STM ()
+ DMCC.Prelude: writeTMQueue :: () => TMQueue a -> a -> STM ()
+ DMCC.Prelude: writeTQueue :: () => TQueue a -> a -> STM ()
+ DMCC.Prelude: writeTVar :: () => TVar a -> a -> STM ()
+ DMCC.Prelude: yieldThread :: MonadIO m => m ()
+ DMCC.Prelude: zip :: Zip f => f a -> f b -> f (a, b)
+ DMCC.Prelude: zip3 :: Zip3 f => f a -> f b -> f c -> f (a, b, c)
+ DMCC.Prelude: zip4 :: Zip4 f => f a -> f b -> f c -> f d -> f (a, b, c, d)
+ DMCC.Prelude: zip5 :: Zip5 f => f a -> f b -> f c -> f d -> f e -> f (a, b, c, d, e)
+ DMCC.Prelude: zip6 :: Zip6 f => f a -> f b -> f c -> f d -> f e -> f g -> f (a, b, c, d, e, g)
+ DMCC.Prelude: zip7 :: Zip7 f => f a -> f b -> f c -> f d -> f e -> f g -> f h -> f (a, b, c, d, e, g, h)
+ DMCC.Prelude: zipWith :: Zip f => (a -> b -> c) -> f a -> f b -> f c
+ DMCC.Prelude: zipWith3 :: Zip3 f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+ DMCC.Prelude: zipWith4 :: Zip4 f => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e
+ DMCC.Prelude: zipWith5 :: Zip5 f => (a -> b -> c -> d -> e -> g) -> f a -> f b -> f c -> f d -> f e -> f g
+ DMCC.Prelude: zipWith6 :: Zip6 f => (a -> b -> c -> d -> e -> g -> h) -> f a -> f b -> f c -> f d -> f e -> f g -> f h
+ DMCC.Prelude: zipWith7 :: Zip7 f => (a -> b -> c -> d -> e -> g -> h -> i) -> f a -> f b -> f c -> f d -> f e -> f g -> f h -> f i
+ DMCC.Prelude: }
+ DMCC.Session: instance GHC.Exception.Type.Exception DMCC.Session.DMCCError
- DMCC: startSession :: (MonadUnliftIO m, MonadLoggerIO m, MonadBaseControl IO m, MonadCatch m) => (String, PortNumber) -> ConnectionType -> Text -> Text -> Maybe String -> SessionOptions -> m Session
+ DMCC: startSession :: (MonadUnliftIO m, MonadLoggerIO m, MonadBaseControl IO m, MonadCatch m) => (String, PortNumber) -> Maybe FilePath -> Text -> Text -> Maybe String -> SessionOptions -> m Session
- DMCC.Session: startSession :: (MonadUnliftIO m, MonadLoggerIO m, MonadBaseControl IO m, MonadCatch m) => (String, PortNumber) -> ConnectionType -> Text -> Text -> Maybe String -> SessionOptions -> m Session
+ DMCC.Session: startSession :: (MonadUnliftIO m, MonadLoggerIO m, MonadBaseControl IO m, MonadCatch m) => (String, PortNumber) -> Maybe FilePath -> Text -> Text -> Maybe String -> SessionOptions -> m Session
- DMCC.Types: DeviceId :: (CI Text) -> DeviceId
+ DMCC.Types: DeviceId :: CI Text -> DeviceId

Files

CHANGELOG.md view
@@ -1,5 +1,15 @@ # Changelog +## [1.1.0.0] - 2018-11-04++### Changed++- GHC 8.6.x support++### Removed++- Plain unencrypted (non-TLS) connections to AES server are no longer supported+ ## [1.0.0.1] - 2018-05-10  ### Changed@@ -8,5 +18,6 @@  ## [1.0.0.0] - 2018-05-10 +[1.1.0.0]: https://github.com/f-me/dmcc/compare/1.0.0.1...1.1.0.0 [1.0.0.1]: https://github.com/f-me/dmcc/compare/1.0.0.0...1.0.0.1 [1.0.0.0]: https://github.com/f-me/dmcc/tree/1.0.0.0
README.md view
@@ -45,18 +45,23 @@ is to provide a clean agent-centric interface to DMCC API suitable for usage from client applications running in a browser. -The server is invoked as `dmcc-ws dmcc-ws.cfg`. See example-configuration file at `dmcc-ws/example.cfg`.+Run the server as +```+dmcc-ws dmcc-ws.cfg+```++See example configuration file at `dmcc-ws/example.cfg`.+ With `dmcc-ws` running, you may start controlling an agent with-extension `XXX`, connect to WebSocket URL `http://host:port/XXX`. The-server accepts client commands in JSON:+extension `XXX` by connecting to WebSocket URL `http://host:port/XXX`.+The server accepts client commands in JSON:  ```json {"action":"MakeCall", "number":"989150603267"} ``` -Consult `DMCC.Action` documentation in Haddock docs for DMCC library+Consult [`DMCC.Action`][dmcc-actions] documentation in Haddock docs for DMCC library for supported commands.  The server reports telephony events along with updated agent snapshot:@@ -104,3 +109,5 @@ [dmcc-api]: https://www.devconnectprogram.com/site/global/products_resources/avaya_aura_application_enablement_services/interfaces/dmcc/overview/index.gsp  [ecma-354]: http://www.ecma-international.org/publications/standards/Ecma-354.htm++[dmcc-actions]: https://hackage.haskell.org/package/dmcc/docs/DMCC-Agent.html#t:Action
dmcc-ws/Main.hs view
@@ -41,7 +41,6 @@   { listenPort :: Int   , aesAddr    :: String   , aesPort    :: Int-  , aesTLS     :: Bool   , caDir      :: Maybe FilePath   , apiUser    :: Text   , apiPass    :: Text@@ -88,7 +87,6 @@       <$> Cfg.require c "listen-port"       <*> Cfg.require c "aes-addr"       <*> Cfg.require c "aes-port"-      <*> Cfg.lookupDefault True c "aes-use-tls"       <*> Cfg.lookup  c "aes-cacert-directory"       <*> Cfg.require c "api-user"       <*> Cfg.require c "api-pass"@@ -105,8 +103,7 @@   CS.logInfo $ "Starting session using " <> fromString (show cfg)    let runSession = startSession-        (aesAddr, fromIntegral aesPort)-        (if aesTLS then TLS caDir else Plain)+        (aesAddr, fromIntegral aesPort) caDir         apiUser apiPass         whUrl         defaultSessionOptions { statePollingDelay       = stateDelay
dmcc-ws/example.cfg view
@@ -1,20 +1,19 @@-listen-port = 8333- aes-addr = "192.168.20.14" aes-port = 4722-aes-use-tls = true  # Path to a directory which contains the PEM encoded CA root # certificates used to verify server certificate. See # http://www.openssl.org/docs/ssl/SSL_CTX_load_verify_locations.html # for details of the file naming scheme-#-# aes-cacert-directory = "/etc/ssl/csta-certs/"+aes-cacert-directory = "/etc/ssl/csta-certs/"  api-user = "avaya" api-pass = "avayapassword"  switch-name = "ADACs8300"++# Expose WebSocket interface on this port+listen-port = 8333  # Log low-level CSTA library requests/responses log-library = false
dmcc.cabal view
@@ -1,6 +1,6 @@-cabal-version: >=1.10+cabal-version: 1.12 name: dmcc-version: 1.0.0.1+version: 1.1.0.0 license: BSD3 license-file: LICENSE maintainer: dima@dzhus.org@@ -14,8 +14,8 @@ build-type: Simple extra-source-files:     CHANGELOG.md-    dmcc-ws/example.cfg     README.md+    dmcc-ws/example.cfg  source-repository head     type: git@@ -42,22 +42,22 @@     ghc-options: -Wall -Wcompat -Wno-missing-home-modules     build-depends:         HsOpenSSL <0.12,-        aeson <1.3,-        base <4.12,+        aeson <1.5,+        base <4.13,         binary <0.9,         bytestring <0.11,         case-insensitive <1.3,-        classy-prelude <1.5,-        containers <0.6,+        classy-prelude <1.6,+        containers <0.7,         http-client <0.6,         io-streams <1.6,-        lens <4.17,+        lens <4.18,         monad-control <1.1,         monad-logger <0.4,-        network <2.7,+        network <2.9,         openssl-streams <1.3,         safe-exceptions <0.2,-        stm <2.5,+        stm <2.6,         text <1.3,         time <1.9,         transformers-base <0.5,@@ -75,17 +75,17 @@                         NamedFieldPuns NoImplicitPrelude     ghc-options: -Wall -Wcompat -Wno-missing-home-modules -threaded     build-depends:-        aeson <1.3,-        base <4.12,+        aeson <1.5,+        base <4.13,         bytestring <0.11,-        classy-prelude <1.5,+        classy-prelude <1.6,         configurator <0.4,-        containers <0.6,+        containers <0.7,         dmcc -any,         monad-control <1.1,         monad-logger <0.4,         random <1.2,-        stm <2.5,+        stm <2.6,         text <1.3,         unix <2.8,         unliftio <0.3,
src/DMCC.hs view
@@ -7,7 +7,6 @@  module DMCC   ( Session-  , ConnectionType (..)   , startSession   , stopSession   , defaultSessionOptions
src/DMCC/Agent.hs view
@@ -394,7 +394,7 @@       sendRequestSync (dmccHandle as) (Just aid) $       Rq.GenerateDigits digits device callId (protocolVersion as)     SetState newState -> do-      cs <- atomically $ readTVar snapshot+      cs <- readTVarIO snapshot       when (fst (_state cs) /= Just Busy) $         simpleRequest Rq.SetAgentState newState   where@@ -607,7 +607,7 @@ -- | Attach an event handler to an agent. Exceptions are not handled. handleEvents :: (MonadLoggerIO m, MonadThrow m) => AgentHandle -> (AgentEvent -> m ()) -> m ThreadId handleEvents (AgentHandle (aid, as)) handler = do-  ags <- atomically $ readTVar $ agents as+  ags <- readTVarIO $ agents as   case Map.lookup aid ags of     Nothing -> throwIO $ UnknownAgent aid     Just Agent{..} -> do
src/DMCC/Session.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE BangPatterns #-}+{-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DoAndIfThenElse #-}@@ -12,7 +13,6 @@  module DMCC.Session   ( Session (..)-  , ConnectionType (..)   , startSession   , stopSession   , defaultSessionOptions@@ -43,10 +43,8 @@                                    , ReadTooShortException                                    , write                                    )-import           System.IO.Streams.Handle import qualified System.IO.Streams.SSL as SSLStreams -import           Network import qualified Network.HTTP.Client as HTTP import           Network.Socket hiding (connect) import           OpenSSL@@ -62,10 +60,6 @@ import {-# SOURCE #-} DMCC.Agent  -data ConnectionType = Plain-                    | TLS { caDir :: Maybe FilePath }-- -- | Third element is a connection close action. type ConnectionData = (InputStream ByteString, OutputStream ByteString, IO ()) @@ -132,8 +126,8 @@ startSession :: (MonadUnliftIO m, MonadLoggerIO m, MonadBaseControl IO m, MonadCatch m)              => (String, PortNumber)              -- ^ Host and port of AES server.-             -> ConnectionType-             -- ^ Use TLS.+             -> Maybe FilePath+             -- ^ AES CA certificates directory for TLS.              -> Text              -- ^ DMCC API user.              -> Text@@ -142,7 +136,7 @@              -- ^ Web hook URL.              -> SessionOptions              -> m Session-startSession (host, port) ct user pass whUrl sopts = do+startSession (host, port) caDir user pass whUrl sopts = do   syncResponses <- newTVarIO IntMap.empty   agentRequests <- newTVarIO IntMap.empty   invoke <- newTVarIO 0@@ -168,15 +162,7 @@              else throwIO e         connect1 attempts =           handleNetwork (connectExHandler attempts) $-          liftIO $ case ct of-            Plain -> do-              h <- connectTo host (PortNumber $ fromIntegral port)-              hSetBuffering h NoBuffering-              is <- handleToInputStream h-              os <- handleToOutputStream h-              let cl = hClose h-              pure (is, os, cl)-            TLS caDir -> withOpenSSL $ do+          liftIO $ withOpenSSL $ do               sslCtx <- SSL.context               SSL.contextSetDefaultCiphers sslCtx               SSL.contextSetVerificationMode sslCtx $