Node.Stream

data Stream :: Row Type -> Typedata Stream t0

A stream.

The type arguments track, in order:

• Whether reading and/or writing from/to the stream are allowed.
• Effects associated with reading/writing from/to this stream.

data Read

A phantom type associated with readable streams.

type Readable :: Row Type -> Typetype Readable r = Stream (read :: Read | r)

A readable stream.

data Write

A phantom type associated with writable streams.

type Writable :: Row Type -> Typetype Writable r = Stream (write :: Write | r)

A writable stream.

type Duplex = Stream (read :: Read, write :: Write)

A duplex (readable and writable stream)

onData :: forall w. Readable w -> (Buffer -> Effect Unit) -> Effect Unit

Listen for data events, returning data in a Buffer. Note that this will fail if setEncoding has been called on the stream.

onDataString :: forall w. Readable w -> Encoding -> (String -> Effect Unit) -> Effect Unit

Listen for data events, returning data in a String, which will be decoded using the given encoding. Note that this will fail if setEncoding has been called on the stream.

onDataEither :: forall r. Readable r -> (Either String Buffer -> Effect Unit) -> Effect Unit

Listen for data events, returning data in an Either String Buffer. This function is provided for the (hopefully rare) case that setEncoding has been called on the stream.

setEncoding :: forall w. Readable w -> Encoding -> Effect Unit

Set the encoding used to read chunks as strings from the stream. This function may be useful when you are passing a readable stream to some other JavaScript library, which already expects an encoding to be set.

Where possible, you should try to use onDataString instead of this function.

onReadable :: forall w. Readable w -> Effect Unit -> Effect Unit

Listen for readable events.

onEnd :: forall w. Readable w -> Effect Unit -> Effect Unit

Listen for end events.

onFinish :: forall w. Writable w -> Effect Unit -> Effect Unit

Listen for finish events.

onClose :: forall w. Stream w -> Effect Unit -> Effect Unit

Listen for close events.

onError :: forall w. Stream w -> (Error -> Effect Unit) -> Effect Unit

Listen for error events.

resume :: forall w. Readable w -> Effect Unit

Resume reading from the stream.

pause :: forall w. Readable w -> Effect Unit

Pause reading from the stream.

isPaused :: forall w. Readable w -> Effect Boolean

Check whether or not a stream is paused for reading.

pipe :: forall r w. Readable w -> Writable r -> Effect (Writable r)

Read chunks from a readable stream and write them to a writable stream.

unpipe :: forall r w. Readable w -> Writable r -> Effect Unit

Detach a Writable stream previously attached using pipe.

unpipeAll :: forall w. Readable w -> Effect Unit

Detach all Writable streams previously attached using pipe.

read :: forall w. Readable w -> Maybe Int -> Effect (Maybe Buffer)

readString :: forall w. Readable w -> Maybe Int -> Encoding -> Effect (Maybe String)

readEither :: forall w. Readable w -> Maybe Int -> Effect (Maybe (Either String Buffer))

write :: forall r. Writable r -> Buffer -> (Maybe Error -> Effect Unit) -> Effect Boolean

Write a Buffer to a writable stream.

writeString :: forall r. Writable r -> Encoding -> String -> (Maybe Error -> Effect Unit) -> Effect Boolean

Write a string in the specified encoding to a writable stream.

cork :: forall r. Writable r -> Effect Unit

Force buffering of writes.

uncork :: forall r. Writable r -> Effect Unit

Flush buffered data.

setDefaultEncoding :: forall r. Writable r -> Encoding -> Effect Unit

Set the default encoding used to write strings to the stream. This function is useful when you are passing a writable stream to some other JavaScript library, which already expects a default encoding to be set. It has no effect on the behaviour of the writeString function (because that function ensures that the encoding is always supplied explicitly).

end :: forall r. Writable r -> (Maybe Error -> Effect Unit) -> Effect Unit

End writing data to the stream.

destroy :: forall r. Stream r -> Effect Unit

Destroy the stream. It will release any internal resources.

destroyWithError :: forall r. Stream r -> Error -> Effect Unit

Destroy the stream and emit 'error'.