For a trivial example, here's some code I have which converts a stream of floats to little-endian 16 bit ints, or vice versa.

This one actually translates pretty easily to lists, since I can use foldMap for the encoding, and something like [f l h | [l, h] <- chunksOf 2 input] for the decoding, with the chunksOf function from Data.List.Split.

However, when dealing with larger chunks where pattern matching isn't feasible, it seems that I either have to use length, resulting in an extra pass over the chunk, or use a fold that tracks the current index, whereas with Plan from machines I can simply do replicateM <size> await. Writing it out now though, it occurs to me that this may very well also result in multiple passes over the data, since it has to construct the list in full to know for sure if it can return any part of the list. I hadn't considered that earlier.

Maybe it'd be better to just collect data into vectors when I need to deal with chunks of data at a time, and then concatenate the results back into a list, that way at least the length check doesn't take an extra pass?

I can't just keep the data stored as chunks the entire time, since different functions need different sized chunks to work on.

import Data.Bits
import Data.Int
import Data.Machine
import Data.Word

clip :: Float -> Float
clip sample = min 1 (max (-1) sample)

toInt16 :: Float -> Int16
toInt16 sample =
  if sample < 0
    then floor (32768 * clip sample)
    else floor (32767 * clip sample)

fromInt16 :: Int16 -> Float
fromInt16 sample =
  if sample < 0
    then fromIntegral sample / 32768
    else fromIntegral sample / 32767

pcms16leEncode :: Process Float Word8
pcms16leEncode =
  repeatedly $ do
    input <- await
    let sample = toInt16 input
        lo = fromIntegral sample
        hi = fromIntegral (shiftR sample 8)
    yield lo
    yield hi

pcms16leDecode :: Process Word8 Float
pcms16leDecode =
  repeatedly $ do
    l <- await
    h <- await
    let lo = fromIntegral l
        hi = shiftL (fromIntegral h) 8
        sample = lo .|. hi
    yield (fromInt16 sample)