New method for WebSocketBuilder taking Pipe[F, WebSocketFrame, WebSocketFrame]

What’s your opinion about another build method that looks like this:

 def build(
        pipe: Pipe[F, WebSocketFrame, WebSocketFrame]
        headers: Headers = Headers.empty,
        onNonWebSocketRequest: F[Response[F]] =
          Response[F](Status.NotImplemented).withEntity("This is a WebSocket route.").pure[F],
        onHandshakeFailure: F[Response[F]] = Response[F](Status.BadRequest)
          .withEntity("WebSocket handshake failed.").pure[F])

Similarly how it’s done in akka-http. I believe it is enough for many use cases of websockets, can simplify the code and it’s easier to reason about for these use cases.

[SystemFw]

I’m actually thinking that a model based on a Pipe might be cleaner than what we have now, here’s a small snippet discussing translating back and forth between the two:

case class Builder(pipe: Pipe[F, Frame, Frame])
case class Split(in: Sink[F, Frame], out: Stream[F, Frame])

def splitToBuilder(s: Split) = Builder(input =>  s.out.concurrently(input.to(s.in))

case class Builder(in: Sink[F, Frame], out: Stream[F, Frame])
case class Piped(pipe: Pipe[F, Frame, Frame])

def pipedToBuilder(p: Piped): F[Builder] = 
needs to create the queue, and also quite possibly wrap everything in Option to use `unNoneTerminate`, 
without it you get race conditions like the one in Chris example that requires `sleep`

[SystemFw]

From what I could get, it would be an additional builder, and yes, a Pipe from input to output