Remove the last type parameter of Stream

It should be possible to read and write both String and Buffer at any
time; the Node API offers Strings for convenience only, so there is no
need for the last type parameter of Stream.

Author: hdgarrood

src/Node/Stream.js

@@ -10,7 +10,7 @@ exports.setEncodingImpl = function(s) {
     };
 };
 
-exports.onData = function(s) {
+exports.onDataImpl = function(s) {
     return function(f) {
         return function() {
             s.on('data', function(chunk) {

src/Node/Stream.purs

@@ -27,17 +27,19 @@ module Node.Stream
 import Prelude
 
 import Node.Encoding
+import Node.Buffer (Buffer())
+import Node.Buffer as Buffer
 
 import Control.Monad.Eff
+import Control.Monad.Eff.Unsafe (unsafeInterleaveEff)
 
 -- | 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.
--- | - The type of chunks which will be read from/written to this stream (`String` or `Buffer`).
-foreign import data Stream :: # * -> # ! -> * -> *
+foreign import data Stream :: # * -> # ! -> *
 
 -- | A phantom type associated with _readable streams_.
 data Read
@@ -54,56 +56,66 @@ type Writable r = Stream (write :: Write | r)
 -- | A duplex (readable _and_ writable stream)
 type Duplex = Stream (read :: Read, write :: Write)
 
-foreign import setEncodingImpl :: forall w eff. Readable w eff String -> String -> Eff eff Unit
+foreign import setEncodingImpl :: forall w eff. Readable w eff -> String -> Eff eff Unit
 
--- | Set the encoding used to read chunks from the stream.
-setEncoding :: forall w eff. Readable w eff String -> Encoding -> Eff eff Unit
+-- | Set the encoding used to read chunks as strings from the stream.
+setEncoding :: forall w eff. Readable w eff -> Encoding -> Eff eff Unit
 setEncoding r enc = setEncodingImpl r (show enc)
 
--- | Listen for `data` events.
-foreign import onData :: forall w eff a. Readable w eff a -> (a -> Eff eff Unit) -> Eff eff Unit
+foreign import onDataImpl :: forall w eff a. Readable w eff -> (a -> Eff eff Unit) -> Eff eff Unit
+
+-- | Listen for `data` events, returning data in a Buffer.
+onData :: forall w eff. Readable w eff -> (Buffer -> Eff eff Unit) -> Eff eff Unit
+onData = onDataImpl
+
+-- | Listen for `data` events, returning data in a String, decoded with the
+-- | given encoding.
+onDataString :: forall w eff. Readable w eff -> Encoding -> (String -> Eff eff Unit) -> Eff eff Unit
+onDataString r enc cb = onData r $ \buf -> do
+  str <- unsafeInterleaveEff (Buffer.toString enc buf)
+  cb str
 
 -- | Listen for `end` events.
-foreign import onEnd :: forall w eff a. Readable w eff a -> Eff eff Unit -> Eff eff Unit
+foreign import onEnd :: forall w eff. Readable w eff -> Eff eff Unit -> Eff eff Unit
 
 -- | Listen for `close` events.
-foreign import onClose :: forall w eff a. Readable w eff a -> Eff eff Unit -> Eff eff Unit
+foreign import onClose :: forall w eff. Readable w eff -> Eff eff Unit -> Eff eff Unit
 
 -- | Listen for `error` events.
-foreign import onError :: forall w eff a. Readable w eff a -> Eff eff Unit -> Eff eff Unit
+foreign import onError :: forall w eff. Readable w eff -> Eff eff Unit -> Eff eff Unit
 
 -- | Resume reading from the stream.
-foreign import resume :: forall w eff a. Readable w eff a -> Eff eff Unit
+foreign import resume :: forall w eff. Readable w eff -> Eff eff Unit
 
 -- | Pause reading from the stream.
-foreign import pause :: forall w eff a. Readable w eff a -> Eff eff Unit
+foreign import pause :: forall w eff. Readable w eff -> Eff eff Unit
 
 -- | Check whether or not a stream is paused for reading.
-foreign import isPaused :: forall w eff a. Readable w eff a -> Eff eff Boolean
+foreign import isPaused :: forall w eff. Readable w eff -> Eff eff Boolean
 
 -- | Read chunks from a readable stream and write them to a writable stream.
-foreign import pipe :: forall r w eff a. Readable w eff a -> Writable r eff a -> Eff eff (Writable r eff a)
+foreign import pipe :: forall r w eff. Readable w eff -> Writable r eff -> Eff eff (Writable r eff)
 
--- | Write a chunk to a writable stream.
-foreign import write :: forall r eff a. Writable r eff String -> a -> Eff eff Unit -> Eff eff Boolean
+-- | Write a Buffer to a writable stream.
+foreign import write :: forall r eff. Writable r eff -> Buffer -> Eff eff Unit -> Eff eff Boolean
 
-foreign import writeStringImpl :: forall r eff. Writable r eff String -> String -> String -> Eff eff Unit -> Eff eff Boolean
+foreign import writeStringImpl :: forall r eff. Writable r eff -> String -> String -> Eff eff Unit -> Eff eff Boolean
 
 -- | Write a string in the specified encoding to a writable stream.
-writeString :: forall r eff. Writable r eff String -> Encoding -> String -> Eff eff Unit -> Eff eff Boolean
+writeString :: forall r eff. Writable r eff -> Encoding -> String -> Eff eff Unit -> Eff eff Boolean
 writeString w enc = writeStringImpl w (show enc)
 
 -- | Force buffering of writes.
-foreign import cork :: forall r eff a. Writable r eff a -> Eff eff Unit
+foreign import cork :: forall r eff. Writable r eff -> Eff eff Unit
 
 -- | Flush buffered data.
-foreign import uncork :: forall r eff a. Writable r eff a -> Eff eff Unit
+foreign import uncork :: forall r eff. Writable r eff -> Eff eff Unit
 
-foreign import setDefaultEncodingImpl :: forall r eff. Writable r eff String -> String -> Eff eff Unit
+foreign import setDefaultEncodingImpl :: forall r eff. Writable r eff -> String -> Eff eff Unit
 
--- | Set the default encoding used to write chunks to the stream.
-setDefaultEncoding :: forall r eff. Writable r eff String -> Encoding -> Eff eff Unit
+-- | Set the default encoding used to write chunks to the stream. This
+setDefaultEncoding :: forall r eff. Writable r eff -> Encoding -> Eff eff Unit
 setDefaultEncoding r enc = setDefaultEncodingImpl r (show enc)
 
 -- | End writing data to the stream.
-foreign import end :: forall r eff a. Writable r eff a -> Eff eff Unit -> Eff eff Unit
+foreign import end :: forall r eff. Writable r eff -> Eff eff Unit -> Eff eff Unit

test/Main.purs

@@ -9,11 +9,11 @@ import Control.Monad.Eff.Console
 
 foreign import data GZIP :: !
 
-foreign import stdin :: forall eff. Readable () (console :: CONSOLE | eff) String
+foreign import stdin :: forall eff. Readable () (console :: CONSOLE | eff)
 
-foreign import stdout :: forall eff. Writable () (console :: CONSOLE | eff) String
+foreign import stdout :: forall eff. Writable () (console :: CONSOLE | eff)
 
-foreign import gzip :: forall eff a. Eff (gzip :: GZIP | eff) (Duplex (gzip :: GZIP | eff) a)
+foreign import gzip :: forall eff. Eff (gzip :: GZIP | eff) (Duplex (gzip :: GZIP | eff))
 
 main = do
   z <- gzip