Metadata revisions for interruptible-0.1.1.1

Package maintainers and Hackage trustees are allowed to edit certain bits of package metadata after a release, without uploading a new tarball. Note that the tarball itself is never changed, just the metadata that is stored separately. For more information about metadata revisions, please refer to the Hackage Metadata Revisions FAQ.

No. Time User Changes
-r2 Sat Jul 9 14:51:03 UTC 2016 marcosdumay
  • Changed description from

    Given an inner monad @M@ and a transformer @T@, if T is an interruptible transformer,
    it becomes possible to intercalate functions over its context with functions over the
    inner monad. That is, code like this:
    
    @
    runT (f 1 >>= g)
    where
    f :: Int -> T M a
    g :: a -> T M b
    @
    
    Can be broken up like this:
    
    @
    do
    let c0 = inTCtx 1
    c1 <- resume f c0
    _ <- resume g c2
    @
    
    That makes it possible to intercalate the execution of different contexts, and
    treat contexts like data, for iterating or returning them.
    
    As shown on the example, interruptible transformers are resumed with the @resume@ function.
    State may be managed by specialized functions usually named as @inTransfomerCtx@ and
    @peelTransformerCtx@ that enclose a value in an initial context and retrieve the
    value from a context.
    
    Interruptible transformers can be stacked. On this case, they must be resumed with a
    composition of @resume@ calls, and their contexts must be created and peeled on the inverse
    order that they appear on the stack. Like:
    
    @
    do
    let c0 = inT2Ctx . inT1Ctx $ 1
    c1 <- (resume . resume) f c0
    _ <- (resume . resume) g c1
    where
    f :: Monad m => Int -> T1 T2 M a
    g :: Monad m => a -> T1 T2 M b
    @
    
    For convenience, the @Interruptible@ module exports the @resume2@ to @resume5@
    functions as composotions of resume. They can be composed further as in
    @resume7 = resume3 . resume4@ if necessary.
    
    This package also contains the appliable instantiations of Interruptible for the mtl transformers,
    the @intercalateWith@ function, that intercalates calls of a function through a list
    of contexts and parameters, and the @SafeIO@ module that lifts IOException treatment from the
    base monad into the current resumed context.
    to
    Given an inner monad @M@ and a transformer @T@, if T is an interruptible transformer,
    it becomes possible to intercalate functions over its context with functions over the
    inner monad. That is, code like this:
    
    > runT (f 1 >>= g)
    > where
    >     f :: Int -> T M a
    >     g :: a -> T M b
    
    Can be broken up like this:
    
    > do
    > let c0 = inTCtx 1
    > c1 <- resume f c0
    > _ <- resume g c2
    
    That makes it possible to intercalate the execution of different contexts, and
    treat contexts like data, for iterating or returning them.
    
    As shown on the example, interruptible transformers are resumed with the @resume@ function.
    State may be managed by specialized functions usually named as @inTransfomerCtx@ and
    @peelTransformerCtx@ that enclose a value in an initial context and retrieve the
    value from a context.
    
    Interruptible transformers can be stacked. On this case, they must be resumed with a
    composition of @resume@ calls, and their contexts must be created and peeled on the inverse
    order that they appear on the stack. Like:
    
    > do
    > let c0 = inT2Ctx . inT1Ctx $ 1
    > c1 <- (resume . resume) f c0
    > _ <- (resume . resume) g c1
    > where
    >     f :: Monad m => Int -> T1 T2 M a
    >     g :: Monad m => a -> T1 T2 M b
    
    For convenience, the @Interruptible@ module exports the @resume2@ to @resume5@
    functions as composotions of resume. They can be composed further as in
    @resume7 = resume3 . resume4@ if necessary.
    
    This package also contains the appliable instantiations of Interruptible for the mtl transformers,
    the @intercalateWith@ function, that intercalates calls of a function through a list
    of contexts and parameters, and the @SafeIO@ module that lifts IOException treatment from the
    base monad into the current resumed context.

-r1 Sat Jul 9 00:28:14 UTC 2016 marcosdumay
  • Changed description from

    Given an inner monad @M@ and a transformer @T@, if T is an interruptible transformer,
    it becomes possible to intercalate functions over its context with functions over the
    inner monad. That is, code like this:
    
    @
    runT (f 1 >>= g)
    where
    f :: Int -> T M a
    g :: a -> T M b
    @
    
    Can be broken up like this:
    
    @
    do
    let c0 = inTCtx 1
    c1 <- resume f ct1
    _ <- resume g ct2
    @
    
    That makes it possible to intercalate the execution of different contexts, and
    treat contexts like data, for iterating or returning them.
    
    As shown on the example, interruptible transformers are resumed with the @resume@ function.
    State may be managed by specialized functions usually named as @inTransfomerCtx@ and
    @peelTransformerCtx@ that enclose a value in an initial context and retrieve the
    value from a context.
    
    Interruptible transformers can be stacked. On this case, they must be resumed with a
    composition of @resume@ calls, and their contexts must be created and peeled on the inverse
    order that they appear on the stack. Like:
    
    @
    do
    let c0 = inT2Ctx . inT1Ctx $ 1
    c1 <- (resume . resume) f ct1
    _ <- (resume . resume) g ct2
    where
    f :: Monad m => Int -> T1 T2 M a
    g :: Monad m => a -> T1 T2 M b
    @
    
    For convenience, the @Interruptible@ module exports the @resume2@ to @resume5@
    functions as composotions of resume. They can be composed further as in
    @resume7 = resume3 . resume4@ if necessary.
    
    This package also contains the appliable instantiations of Interruptible for the mtl transformers,
    the @intercalateWith@ function, that intercalates calls of a function through a list
    of contexts and parameters, and the @SafeIO@ module that lifts IOException treatment from the
    base monad into the current resumed context.
    to
    Given an inner monad @M@ and a transformer @T@, if T is an interruptible transformer,
    it becomes possible to intercalate functions over its context with functions over the
    inner monad. That is, code like this:
    
    @
    runT (f 1 >>= g)
    where
    f :: Int -> T M a
    g :: a -> T M b
    @
    
    Can be broken up like this:
    
    @
    do
    let c0 = inTCtx 1
    c1 <- resume f c0
    _ <- resume g c2
    @
    
    That makes it possible to intercalate the execution of different contexts, and
    treat contexts like data, for iterating or returning them.
    
    As shown on the example, interruptible transformers are resumed with the @resume@ function.
    State may be managed by specialized functions usually named as @inTransfomerCtx@ and
    @peelTransformerCtx@ that enclose a value in an initial context and retrieve the
    value from a context.
    
    Interruptible transformers can be stacked. On this case, they must be resumed with a
    composition of @resume@ calls, and their contexts must be created and peeled on the inverse
    order that they appear on the stack. Like:
    
    @
    do
    let c0 = inT2Ctx . inT1Ctx $ 1
    c1 <- (resume . resume) f c0
    _ <- (resume . resume) g c1
    where
    f :: Monad m => Int -> T1 T2 M a
    g :: Monad m => a -> T1 T2 M b
    @
    
    For convenience, the @Interruptible@ module exports the @resume2@ to @resume5@
    functions as composotions of resume. They can be composed further as in
    @resume7 = resume3 . resume4@ if necessary.
    
    This package also contains the appliable instantiations of Interruptible for the mtl transformers,
    the @intercalateWith@ function, that intercalates calls of a function through a list
    of contexts and parameters, and the @SafeIO@ module that lifts IOException treatment from the
    base monad into the current resumed context.

-r0 Wed Jun 8 20:48:18 UTC 2016 marcosdumay