streaming-with-0.2.1.0: with/bracket-style idioms for use with streaming

CopyrightIvan Lazar Miljenovic
LicenseMIT
MaintainerIvan.Miljenovic@gmail.com
Safe HaskellNone
LanguageHaskell2010

Streaming.With

Contents

Description

 

Synopsis

File-handling

withFile :: (MonadMask m, MonadIO m) => FilePath -> IOMode -> (Handle -> m r) -> m r Source #

A lifted variant of withFile.

You almost definitely don't want to use this; instead, use withBinaryFile in conjunction with Data.ByteString.Streaming.

withBinaryFile :: (MonadMask m, MonadIO m) => FilePath -> IOMode -> (Handle -> m r) -> m r Source #

A lifted variant of withBinaryFile.

Common file-handling cases

writeBinaryFile :: (MonadMask m, MonadIO m) => FilePath -> ByteString m r -> m r Source #

Write to the specified file.

appendBinaryFile :: (MonadMask m, MonadIO m) => FilePath -> ByteString m r -> m r Source #

Append to the specified file.

withBinaryFileContents :: (MonadMask m, MonadIO m, MonadIO n) => FilePath -> (ByteString n () -> m r) -> m r Source #

Apply a function to the contents of the file.

Note that a different monadic stack is allowed for the ByteString input, as long as it later gets resolved to the required output type (e.g. remove transformer).

Temporary files

withSystemTempFile Source #

Arguments

:: (MonadIO m, MonadMask m) 
=> String

File name template. See openTempFile

-> ((FilePath, Handle) -> m r) 
-> m r 

/This is withSystemTempFile from the temporary package with the continuation re-structured to only take one argument./

Create and use a temporary file in the system standard temporary directory.

Behaves exactly the same as withTempFile, except that the parent temporary directory will be that returned by getCanonicalTemporaryDirectory.

Since: 0.1.1.0

withTempFile Source #

Arguments

:: (MonadIO m, MonadMask m) 
=> FilePath

Temp dir to create the file in

-> String

File name template. See openTempFile.

-> ((FilePath, Handle) -> m r) 
-> m r 

/This is withTempFile from the temporary package with the continuation re-structured to only take one argument./

Use a temporary filename that doesn't already exist.

Creates a new temporary file inside the given directory, making use of the template. The temp file is deleted after use. For example:

withTempFile "src" "sdist." $ \(tmpFile, hFile) -> ...

The tmpFile will be file in the given directory, e.g. src/sdist.342.

Since: 0.1.1.0

Re-exports

These functions are re-exported from the temporary package as-is as their structure already matches those found here.

Since: 0.1.1.0

withSystemTempDirectory #

Arguments

:: (MonadIO m, MonadMask m) 
=> String

Directory name template

-> (FilePath -> m a)

Callback that can use the directory

-> m a 

Create and use a temporary directory in the system standard temporary directory.

Behaves exactly the same as withTempDirectory, except that the parent temporary directory will be that returned by getCanonicalTemporaryDirectory.

withTempDirectory #

Arguments

:: (MonadMask m, MonadIO m) 
=> FilePath

Parent directory to create the directory in

-> String

Directory name template

-> (FilePath -> m a)

Callback that can use the directory

-> m a 

Create and use a temporary directory inside the given directory.

The directory is deleted after use.

Re-exports

These may assist in writing your own bracket-style functions.

Note that not everything is re-exported: for example, Handle isn't re-exported for use with withFile as it's unlikely that you will write another wrapper around it, and furthermore it wouldn't be a common enough extension to warrant it.

class MonadCatch m => MonadMask (m :: * -> *) #

A class for monads which provide for the ability to account for all possible exit points from a computation, and to mask asynchronous exceptions. Continuation-based monads, and stacks such as ErrorT e IO which provide for multiple failure modes, are invalid instances of this class.

Note that this package does provide a MonadMask instance for CatchT. This instance is only valid if the base monad provides no ability to provide multiple exit. For example, IO or Either would be invalid base monads, but Reader or State would be acceptable.

Instances should ensure that, in the following code:

f `finally` g

The action g is called regardless of what occurs within f, including async exceptions.

Minimal complete definition

mask, uninterruptibleMask

Instances

MonadMask IO 

Methods

mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b #

uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b #

(~) * e SomeException => MonadMask (Either e)

Since: 0.8.3

Methods

mask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b #

uninterruptibleMask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b #

MonadMask m => MonadMask (StateT s m) 

Methods

mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

MonadMask m => MonadMask (StateT s m) 

Methods

mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

(MonadMask m, Monoid w) => MonadMask (WriterT w m) 

Methods

mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

(MonadMask m, Monoid w) => MonadMask (WriterT w m) 

Methods

mask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

MonadMask m => MonadMask (IdentityT * m) 

Methods

mask :: ((forall a. IdentityT * m a -> IdentityT * m a) -> IdentityT * m b) -> IdentityT * m b #

uninterruptibleMask :: ((forall a. IdentityT * m a -> IdentityT * m a) -> IdentityT * m b) -> IdentityT * m b #

MonadMask m => MonadMask (ReaderT * r m) 

Methods

mask :: ((forall a. ReaderT * r m a -> ReaderT * r m a) -> ReaderT * r m b) -> ReaderT * r m b #

uninterruptibleMask :: ((forall a. ReaderT * r m a -> ReaderT * r m a) -> ReaderT * r m b) -> ReaderT * r m b #

(MonadMask m, Monoid w) => MonadMask (RWST r w s m) 

Methods

mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b #

uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b #

(MonadMask m, Monoid w) => MonadMask (RWST r w s m) 

Methods

mask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b #

uninterruptibleMask :: ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b #

bracket :: MonadMask m => m a -> (a -> m b) -> (a -> m c) -> m c #

Generalized abstracted pattern of safe resource acquisition and release in the face of exceptions. The first action "acquires" some value, which is "released" by the second action at the end. The third action "uses" the value and its result is the result of the bracket.

If an exception occurs during the use, the release still happens before the exception is rethrown.