Documentation

Deeply stream the contents of the given directory.

This works the same as sourceDirectory, but will not return directories at all. This function also takes an extra parameter to indicate whether symlinks will be followed.

Since: conduit-1.3.0

Flatten out a stream by yielding the values contained in an incoming MonoFoldable as individually yielded values.

Since: conduit-1.3.0

A monadic strict left fold.

Since: conduit-1.3.0

Apply a monadic transformation to all values in a stream.

If you do not need the transformed values, and instead just want the monadic side-effects of running the action, see mapM_.

Since: conduit-1.3.0

Combine two Conduits together into a new Conduit (aka fuse).

Output from the upstream (left) conduit will be fed into the downstream (right) conduit. Processing will terminate when downstream (right) returns. Leftover data returned from the right Conduit will be discarded.

Equivalent to fuse and =$=, however the latter is deprecated and will be removed in a future version.

Note that, while this operator looks like categorical composition (from Control.Category), there are a few reasons it's different:

• The position of the type parameters to ConduitT do not match. We would need to change ConduitT i o m r to ConduitT r m i o, which would preclude a Monad or MonadTrans instance.
• The result value from upstream and downstream are allowed to differ between upstream and downstream. In other words, we would need the type signature here to look like ConduitT a b m r -> ConduitT b c m r -> ConduitT a c m r.
• Due to leftovers, we do not have a left identity in Conduit. This can be achieved with the underlying Pipe datatype, but this is not generally recommended. See https://stackoverflow.com/a/15263700.

Since: conduit-1.2.8

Run a pipeline which acquires resources with ResourceT, and then run the ResourceT transformer. This is equivalent to runResourceT . runConduit.

Since: conduit-1.2.8

Combine two paths with a path separator. If the second path starts with a path separator or a drive letter, then it returns the second. The intention is that readFile (dir </> file) will access the same file as setCurrentDirectory dir; readFile file.

Posix:   "/directory" </> "file.ext" == "/directory/file.ext"
Windows: "/directory" </> "file.ext" == "/directory\\file.ext"
         "directory" </> "/file.ext" == "/file.ext"
Valid x => (takeDirectory x </> takeFileName x) `equalFilePath` x

Combined:

Posix:   "/" </> "test" == "/test"
Posix:   "home" </> "bob" == "home/bob"
Posix:   "x:" </> "foo" == "x:/foo"
Windows: "C:\\foo" </> "bar" == "C:\\foo\\bar"
Windows: "home" </> "bob" == "home\\bob"

Not combined:

Posix:   "home" </> "/bob" == "/bob"
Windows: "home" </> "C:\\bob" == "C:\\bob"

Not combined (tricky):

On Windows, if a filepath starts with a single slash, it is relative to the root of the current drive. In [1], this is (confusingly) referred to as an absolute path. The current behavior of </> is to never combine these forms.

Windows: "home" </> "/bob" == "/bob"
Windows: "home" </> "\\bob" == "\\bob"
Windows: "C:\\home" </> "\\bob" == "\\bob"

On Windows, from [1]: "If a file name begins with only a disk designator but not the backslash after the colon, it is interpreted as a relative path to the current directory on the drive with the specified letter." The current behavior of </> is to never combine these forms.

Windows: "D:\\foo" </> "C:bar" == "C:bar"
Windows: "C:\\foo" </> "C:bar" == "C:bar"

Drop the filename. Unlike takeDirectory, this function will leave a trailing path separator on the directory.

dropFileName "/directory/file.ext" == "/directory/"
dropFileName x == fst (splitFileName x)
isPrefixOf (takeDrive x) (dropFileName x)

Contract a filename, based on a relative path. Note that the resulting path will never introduce .. paths, as the presence of symlinks means ../b may not reach a/b if it starts from a/c. For a worked example see this blog post.

The corresponding makeAbsolute function can be found in System.Directory.

         makeRelative "/directory" "/directory/file.ext" == "file.ext"
         Valid x => makeRelative (takeDirectory x) x `equalFilePath` takeFileName x
         makeRelative x x == "."
         Valid x y => equalFilePath x y || (isRelative x && makeRelative y x == x) || equalFilePath (y </> makeRelative y x) x
Windows: makeRelative "C:\\Home" "c:\\home\\bob" == "bob"
Windows: makeRelative "C:\\Home" "c:/home/bob" == "bob"
Windows: makeRelative "C:\\Home" "D:\\Home\\Bob" == "D:\\Home\\Bob"
Windows: makeRelative "C:\\Home" "C:Home\\Bob" == "C:Home\\Bob"
Windows: makeRelative "/Home" "/home/bob" == "bob"
Windows: makeRelative "/" "//" == "//"
Posix:   makeRelative "/Home" "/home/bob" == "/home/bob"
Posix:   makeRelative "/home/" "/home/bob/foo/bar" == "bob/foo/bar"
Posix:   makeRelative "/fred" "bob" == "bob"
Posix:   makeRelative "/file/test" "/file/test/fred" == "fred"
Posix:   makeRelative "/file/test" "/file/test/fred/" == "fred/"
Posix:   makeRelative "some/path" "some/path/a/b/c" == "a/b/c"

Split a filename into directory and file. </> is the inverse. The first component will often end with a trailing slash.

splitFileName "/directory/file.ext" == ("/directory/","file.ext")
Valid x => uncurry (</>) (splitFileName x) == x || fst (splitFileName x) == "./"
Valid x => isValid (fst (splitFileName x))
splitFileName "file/bob.txt" == ("file/", "bob.txt")
splitFileName "file/" == ("file/", "")
splitFileName "bob" == ("./", "bob")
Posix:   splitFileName "/" == ("/","")
Windows: splitFileName "c:" == ("c:","")
Windows: splitFileName "\\\\?\\A:\\fred" == ("\\\\?\\A:\\","fred")
Windows: splitFileName "\\\\?\\A:" == ("\\\\?\\A:","")

Returns the number of Haskell threads that can run truly simultaneously (on separate physical processors) at any given time. To change this value, use setNumCapabilities.

Since: base-4.4.0.0

List index (subscript) operator, starting from 0. Returns Nothing if the index is out of bounds

This is the total variant of the partial !! operator.

WARNING: This function takes linear time in the index.

Examples

>>> ['a', 'b', 'c'] !? 0
Just 'a'

>>> ['a', 'b', 'c'] !? 2
Just 'c'

>>> ['a', 'b', 'c'] !? 3
Nothing

>>> ['a', 'b', 'c'] !? (-1)
Nothing

Alias for unTagged

Similar to a, but argument is not included in trace message.

Expands to $(tr "/a b c d...") False

Similar to tg with message prefix with the argument.

TH version of trace and traceEvent The message is formatted according to TraceMessageFormat. The generated expression has type forall r (a :: TYPE r) b a. Rewrap a b => a -> a. id is generated if effective trace level is lower than trace level threshold. Example:

foo x = $(tr "get/x") x

Output:

Module::foo get; x : 132

TH version of traceMarker where module and function are used as a marker. Trace level is used.

TH version of traceIO and traceEventIO The message is formatted according to TraceMessageFormat. Example:

foo x = $(trIo "get/x") >> pure x

Output:

Module::foo get; x : 132

TH version of traceMarkerIO where module and function are used as a marker. Trace level is not used.

TH version of traceWith and traceEventWith The message is formatted according to TraceMessageFormat. The generated expression has type forall r (a :: TYPE r) b a. (Show a, Rewrap a b) => a -> a. id is generated if effective trace level is lower than trace level threshold. Example:

foo x = $(tw "get/x") (x + 1)

Output:

Module::foo get; x : 132 => 133

Like tw but return value is wrapped with ShowTrace.

Shortcut for undefined

Lifted copyFile.

Since: unliftio-0.2.6.0

Lifted createDirectory.

Since: unliftio-0.2.6.0

Lifted createDirectoryIfMissing.

Since: unliftio-0.2.6.0

Lifted createFileLink. directory package version should be >= 1.3.1. @since 0.2.16.0

Lifted doesDirectoryExist.

Since: unliftio-0.2.6.0

Lifted doesFileExist.

Since: unliftio-0.2.6.0

Lifted getSymbolicLinkTarget.

Since: unliftio-0.2.21.0

Lifted listDirectory.

Since: unliftio-0.2.6.0

Lifted makeAbsolute.

Since: unliftio-0.2.6.0

Lifted pathIsSymbolicLink.

Since: unliftio-0.2.6.0

Lifted removeFile.

Since: unliftio-0.2.6.0

Allocate and clean up a resource safely.

For more information on motivation and usage of this function, see base's bracket. This function has two differences from the one in base. The first, and more obvious, is that it works on any MonadUnliftIO instance, not just IO.

The more subtle difference is that this function will use uninterruptible masking for its cleanup handler. This is a subtle distinction, but at a high level, means that resource cleanup has more guarantees to complete. This comes at the cost that an incorrectly written cleanup function cannot be interrupted.

For more information, please see https://github.com/fpco/safe-exceptions/issues/3.

Since: unliftio-0.1.0.0

Same as bracket, but does not pass the acquired resource to cleanup and use functions.

For more information, see base's bracket_.

Since: unliftio-0.1.0.0

Catch a synchronous (but not asynchronous) exception and recover from it.

This is parameterized on the exception type. To catch all synchronous exceptions, use catchAny.

Since: unliftio-0.1.0.0

Lifted version of hClose

Since: unliftio-0.2.1.0

Lifted version of hIsOpen

Since: unliftio-0.2.1.0

Unlifted version of withBinaryFile.

Since: unliftio-0.1.0.0

Lifted newQSem.

Since: unliftio-0.2.14

Lifted signalQSem.

Since: unliftio-0.2.14

Lifted waitQSem.

Since: unliftio-0.2.14

Compress a stream of data into the zlib format.

This uses the default compression parameters. In particular it uses the default compression level which favours a higher compression ratio over compression speed, though it does not use the maximum compression level.

Use compressWith to adjust the compression level or other compression parameters.

Like compress but with the ability to specify various compression parameters. Typical usage:

compressWith defaultCompressParams { ... }

In particular you can set the compression level:

compressWith defaultCompressParams { compressLevel = BestCompression }

Decompress a stream of data in the zlib format, throw DecompressError on failure.

Note that the decompression is performed lazily. Errors in the data stream may not be detected until the end of the stream is demanded (since it is only at the end that the final checksum can be checked). If this is important to you, you must make sure to consume the whole decompressed stream before doing any IO action that depends on it.

Like decompress but with the ability to specify various decompression parameters. Typical usage:

decompressWith defaultCompressParams { ... }

The default set of parameters for compression. This is typically used with compressWith or compressWith with specific parameters overridden.

The default set of parameters for decompression. This is typically used with decompressWith or decompressWith with specific parameters overridden.

QSem is a quantity semaphore in which the resource is acquired and released in units of one. It provides guaranteed FIFO ordering for satisfying blocked waitQSem calls.

The pattern

bracket_ waitQSem signalQSem (...)

is safe; it never loses a unit of the resource.

Core datatype of the conduit package. This type represents a general component which can consume a stream of input values i, produce a stream of output values o, perform actions in the m monad, and produce a final result r. The type synonyms provided here are simply wrappers around this type.

Since 1.3.0

The Resource transformer. This transformer keeps track of all registered actions, and calls them upon exit (via runResourceT). Actions may be registered via register, or resources may be allocated atomically via allocate. allocate corresponds closely to bracket.

Releasing may be performed before exit via the release function. This is a highly recommended optimization, as it will ensure that scarce resources are freed early. Note that calling release will deregister the action, so that a release action will only ever be called once.

Since 0.3.0

A Tagged s b value is a value b with an attached phantom type s. This can be used in place of the more traditional but less safe idiom of passing in an undefined value with the type, because unlike an (s -> b), a Tagged s b can't try to use the argument s as a real value.

Moreover, you don't have to rely on the compiler to inline away the extra argument, because the newtype is "free"

Tagged has kind k -> * -> * if the compiler supports PolyKinds, therefore there is an extra k showing in the instance haddocks that may cause confusion.

Wrap value which has opaque Show instance.

Name of environment variable name.