How to automatically lift bracket-style expressions into a monad.

The constraints are common ones found throughout this module, and as such incorporated into this class to avoid repetition in all the type signatures.

It is highly recommended that you do not try and layer extra transformers on top of this; the intent of this class is just to make writing all the underlying continuations in a nicer fashion without explicit nesting, rather than as the basis of lower-level code.

Safely run the provided continuation.

A result of type '()' is required to ensure no resources are leaked.

Note that you cannot write something like:

copyBoth :: FilePath -> FilePath -> FilePath -> IO ()
copyBoth inF1 inF2 outF = runWith $ do
  bs1 <- withBinaryFileContents inF1
  bs2 <- withBinaryFileContents inF2
  writeBinaryFile outF bs1
  appendBinaryFile outF bs2

as the RunWithable instance cannot be inferred. As such, you will need to specify a type somewhere.

Since: 0.2.1.0

A helper function to run a computation within a lifted resource management expression.

within w f = w >>= liftAction . f

Since: 0.2.1.0

A helper function for the common case of lifting an IO computation into a Withable.

liftActionIO = liftAction . liftIO.

Since: 0.2.1.0

A lifted variant of withFile.

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

A lifted variant of withBinaryFile.

Write to the specified file.

Append to the specified file.

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).

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

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

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.

Since: 0.1.1.0

Create and use a temporary directory.

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

withTempDirectory "src" "sdist." >>= \tmpDir -> ...

The tmpDir will be a new subdirectory of the given directory, e.g. src/sdist.342.

Since: 0.1.1.0

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.

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.