Read a ByteArray consisting of one or more bytes from a file handle. If no data is available on the handle it blocks until at least one byte becomes available. If any data is available then it immediately returns that data without blocking. As a result of this behavior, it may read less than or equal to the size requested.

Read a ByteArray consisting of exactly the specified number of bytes from a file handle.

Unimplemented

Write an Array to a file handle.

Generate a byte stream from a file Handle.

>>> read h = Stream.unfoldMany Array.reader $ Handle.readChunks h

Pre-release

readWith bufsize handle reads a byte stream from a file handle, reads are performed in chunks of up to bufsize.

>>> readWith size h = Stream.unfoldMany Array.reader $ Handle.readChunksWith size h

Pre-release

readChunksWith size handle reads a stream of arrays from the file handle handle. The maximum size of a single array is limited to size. The actual size read may be less than or equal to size.

>>> readChunksWith size h = Stream.unfold Handle.chunkReaderWith (size, h)

getChunks handle reads a stream of arrays from the specified file handle. The maximum size of a single array is limited to defaultChunkSize. The actual size read may be less than or equal to defaultChunkSize.

>>> readChunks = Handle.readChunksWith IO.defaultChunkSize

Pre-release

Unfolds a file handle into a byte stream. IO requests to the device are performed in sizes of defaultChunkSize.

>>> reader = Unfold.many Array.reader Handle.chunkReader

Unfolds the tuple (bufsize, handle) into a byte stream, read requests to the IO device are performed using buffers of bufsize.

>>> readerWith = Unfold.many Array.reader Handle.chunkReaderWith

Unfolds a handle into a stream of Word8 arrays. Requests to the IO device are performed using a buffer of size defaultChunkSize. The size of arrays in the resulting stream are therefore less than or equal to defaultChunkSize.

>>> chunkReader = Unfold.first IO.defaultChunkSize Handle.chunkReaderWith

Unfold the tuple (bufsize, handle) into a stream of Word8 arrays. Read requests to the IO device are performed using a buffer of size bufsize. The size of an array in the resulting stream is always less than or equal to bufsize.

Write a byte stream to a file handle. Accumulates the input in chunks of up to defaultChunkSize before writing to the IO device.

>>> write = Handle.writeWith IO.defaultChunkSize

writeWith reqSize handle writes the input stream to handle. Bytes in the input stream are collected into a buffer until we have a chunk of reqSize and then written to the IO device.

>>> writeWith n h = Fold.groupsOf n (Array.writeNUnsafe n) (Handle.writeChunks h)

Write a stream of arrays to a handle. Each array in the stream is written to the device as a separate IO request.

writeChunks h = Fold.drainBy (Handle.putChunk h)

writeChunksWith bufsize handle writes a stream of arrays to handle after coalescing the adjacent arrays in chunks of bufsize. We never split an array, if a single array is bigger than the specified size it emitted as it is. Multiple arrays are coalesed as long as the total size remains below the specified size.

Write a stream of Maybe values. Keep buffering the just values in an array until a Nothing is encountered or the buffer size exceeds the specified limit, at that point flush the buffer to the handle.

Pre-release

Like write but uses the experimental Refold API.

Internal

Like writeWith but uses the experimental Refold API.

Internal

Like writeChunks but uses the experimental Refold API.

Internal

Write a byte stream to a file handle. Accumulates the input in chunks of up to defaultChunkSize before writing.

NOTE: This may perform better than the write fold, you can try this if you need some extra perf boost.

>>> putBytes = Handle.putBytesWith IO.defaultChunkSize

putBytesWith bufsize handle stream writes stream to handle in chunks of bufsize. A write is performed to the IO device as soon as we collect the required input size.

putChunksWith bufsize handle stream writes a stream of arrays to handle after coalescing the adjacent arrays in chunks of bufsize. The chunk size is only a maximum and the actual writes could be smaller as we do not split the arrays to fit exactly to the specified size.

Write a stream of arrays to a handle.

>>> putChunks h = Stream.fold (Fold.drainBy (Handle.putChunk h))

The input to the unfold is (from, to, bufferSize, handle). It starts reading from the offset from in the file and reads up to the offset to.

Same as chunkReaderWith

Same as readerWith

Same as writeChunksWith

Same as writeWith