An Iteratee that puts data to a consumer function, then calls an eof function. For instance, handleI could be defined as:

 handleI :: (MonadIO m) => Handle -> Iter ByteString m ()
 handleI h = putI (liftIO . hPut h) (liftIO $ hShutdown h 1)

Send datagrams using a supplied function. The datagrams are fed as a list of packets, where each element of the list should be a separate datagram. For example, to create an Iter from a connected UDP socket:

 udpI :: (SendRecvString s, MonadIO m) => Socket -> Iter s m ()
 udpI sock = sendI $ liftIO . genSend sock

Return the first element when the Iteratee data type is a list.

Return Just the first element when the Iteratee data type is a list, or Nothing on EOF.

Like headLI, but works for any ListLike data type.

Like safeHeadLI, but works for any ListLike data type.

Return a line delimited by \r, \n, or \r\n.

Like lineI, but returns Nothing on EOF.

Return ListLike data that is at most the number of elements specified by the first argument, and at least one element (as long as a positive number is requested). Throws an exception if a positive number of items is requested and an EOF is encountered.

Return ListLike data that is at most the number of elements specified by the first argument, and at least one element unless EOF is encountered or 0 elements are requested, in which case mempty is returned.

Return the next len elements of a ListLike data stream, unless an EOF is encountered, in which case fewer may be returned. Note the difference from data0MaxI: takeI n will keep reading input until it has accumulated n elements or seen an EOF, then return the data; data0MaxI n will keep reading only until it has received any non-empty amount of data, even if the amount received is less than n elements and there is no EOF.

Puts strings (or ListLikeIO data) to a file Handle, then writes an EOF to the handle.

Note that this does not put the handle into binary mode. To do this, you may need to call hSetBinaryMode h True on the handle before using it with handleI. Otherwise, Haskell by default will treat the data as UTF-8. (On the other hand, if the Handle corresponds to a socket and the socket is being read in another thread, calling hSetBinaryMode can cause deadlock, so in this case it is better to have the thread handling reads call hSetBinaryMode.)

Also note that Haskell by default buffers data written to Handles. For many network protocols this is a problem. Don't forget to call hSetBuffering h NoBuffering before passing a handle to handleI.

Sends a list of packets to a datagram socket.

Sends output to a stream socket. Calls shutdown (e.g., to send a TCP FIN packet) upon receiving EOF.

An Iter that uses hPutStr to write all output to stdout.

A mode that determines the effect of hSeek hdl mode i.

A control command (issued with ctlI SizeC) requesting the size of the current file being enumerated.

A control command for seeking within a file, when a file is being enumerated. Flushes the residual input data.

A control command for determining the current offset within a file. Note that this subtracts the size of the residual input data from the offset in the file. Thus, it will only be accurate when all left-over input data is from the current file.

A handler function for the SizeC, SeekC, and TellC control requests. fileCtl is used internally by enumFile and enumHandle, and is exposed for similar enumerators to use.

A control request that returns the Socket from an enclosing socket enumerator.

A handler for the GetSocketC control request.

Read datagrams (of up to 64KiB in size) from a socket and feed a list of strings (one for each datagram) into an Iteratee.

Read datagrams from a socket and feed a list of (Bytestring, SockAddr) pairs (one for each datagram) into an Iteratee.

Read data from a stream (e.g., TCP) socket.

Puts a handle into binary mode with hSetBinaryMode, then enumerates data read from the handle to feed an Iter with any ListLikeIO input type.

A variant of enumHandle type restricted to input in the Lazy ByteString format.

Feeds an Iter with data from a file handle, using any input type in the ListLikeIO class. Note that enumNonBinHandle uses the handle as is, unlike enumHandle, and so can be used if you want to read the data in non-binary form.

Enumerate the contents of a file for an Iter taking input in any ListLikeIO type. Note that the file is opened with openBinaryFile to ensure binary mode.

Enumerate the contents of a file as a series of lazy ByteStrings. (This is a type-restricted version of enumFile.)

Enumerate standard input.

Feed up to some number of list elements (bytes in the case of ByteStrings) to an Iter, or feed fewer if the Iter returns or an EOF is encountered. The formulation inumMax n .| iter can be used to prevent iter from consuming unbounded amounts of input.

Feed exactly some number of bytes to an Iter. Throws an error if that many bytes are not available.

This inner enumerator is like inumNop in that it passes unmodified Chunks straight through to an iteratee. However, it also logs the Chunks to a file (which can optionally be truncated or appended to, based on the second argument).

Like inumLog, but takes a writeable file handle rather than a file name. Does not close the handle when done.

Log a copy of everything to standard error. (inumStderr = inumhLog stderr)

An Inum that converts input in the lazy ByteString format to strict ByteStrings.

The dual of inumLtoS--converts input from strict ByteStrings to lazy ByteStrings.

Add a finalizer to run when an Iter has received an EOF and an Inum has finished. This works regardless of the order in which the two events happen.

"Iterizes" a file Handle by turning into an Onum (for reading) and an Iter (for writing). Uses pairFinalizer to hClose the Handle when both the Iter and Onum are finished. Puts the handle into binary mode, but does not change the buffering. As mentioned for handleI, Haskell's default buffering can cause problems for many network protocols. Hence, you may wish to call hSetBuffering h NoBuffering before iterHandle h.

"Iterizes" a stream Socket by turning into an Onum (for reading) and an Iter (for writing). Uses pairFinalizer to sClose the Socket when both the Iter and Onum are finished.