Remove Collections from Headers

async-http-client/src/main/scala/org/http4s/client/asynchttpclient/AsyncHttpClient.scala

@@ -122,7 +122,7 @@ object AsyncHttpClient {
 
   private def toAsyncRequest[F[_]: ConcurrentEffect](request: Request[F]): AsyncRequest = {
     val headers = new DefaultHttpHeaders
-    for (h <- request.headers)
+    for (h <- request.headers.toList)
       headers.add(h.name.value, h.value)
     new RequestBuilder(request.method.renderString)
       .setUrl(request.uri.renderString)

bench/src/main/scala/org/http4s/bench/HttpHeadersBench.scala

@@ -10,7 +10,7 @@ import org.openjdk.jmh.annotations._
 class HttpHeadersBench {
   @Benchmark
   def apply(in: HeadersInput) =
-    Headers(in.headerSeq: _*)
+    Headers(in.headerSeq.toList)
 
   @Benchmark
   def add(in: HeadersInput) = {
@@ -39,7 +39,7 @@ class HeadersInput {
     headerSeq = (0 until size).map { i =>
       Header(s"X-Headers-Benchmark-$i", i.toString)
     }
-    headers = Headers(headerSeq: _*)
+    headers = Headers(headerSeq.toList)
     replacement = Header(s"X-Headers-Benchmark-${headers.size / 2}", "replacement")
   }
 }

blaze-client/src/main/scala/org/http4s/client/blaze/Http1Connection.scala

@@ -132,7 +132,7 @@ private final class Http1Connection[F[_]](
 
           // Side Effecting Code
           encodeRequestLine(req, rr)
-          Http1Stage.encodeHeaders(req.headers, rr, isServer)
+          Http1Stage.encodeHeaders(req.headers.toList, rr, isServer)
           if (userAgent.nonEmpty && req.headers.get(`User-Agent`).isEmpty) {
             rr << userAgent.get << "\r\n"
           }

blaze-client/src/test/scala/org/http4s/client/blaze/BlazeClientSpec.scala

@@ -206,7 +206,7 @@ class BlazeClientSpec extends Http4sSpec {
           val name = address.getHostName
           val port = address.getPort
           mkClient(1)
-            .use { client =>
+            .use { _ =>
               val submit = successTimeClient
                 .expect[String](Uri.fromString(s"http://$name:$port/delayed").yolo)
               for {
@@ -222,7 +222,7 @@ class BlazeClientSpec extends Http4sSpec {
           val name = address.getHostName
           val port = address.getPort
 
-          Ref[IO].of(0L).flatMap { nanos =>
+          Ref[IO].of(0L).flatMap { _ =>
             mkClient(1, requestTimeout = 1.second).use { client =>
               val submit =
                 client.status(Request[IO](uri = Uri.fromString(s"http://$name:$port/simple").yolo))

blaze-client/src/test/scala/org/http4s/client/blaze/Http1ClientStageSpec.scala

@@ -276,7 +276,7 @@ class Http1ClientStageSpec extends Http4sSpec {
         // body is empty due to it being HEAD request
         response.body.compile.toVector
           .unsafeRunSync()
-          .foldLeft(0L)((long, byte) => long + 1L) must_== 0L
+          .foldLeft(0L)((long, _) => long + 1L) must_== 0L
       } finally {
         tail.shutdown()
       }
@@ -301,7 +301,7 @@ class Http1ClientStageSpec extends Http4sSpec {
           } yield hs
         }
 
-        hs.unsafeRunSync().mkString must_== "Foo: Bar"
+        hs.map(_.toList.mkString).unsafeRunSync() must_== "Foo: Bar"
       }
 
       "Fail to get trailers before they are complete" in {

blaze-client/src/test/scala/org/http4s/client/blaze/MockClientBuilder.scala

@@ -9,7 +9,7 @@ import org.http4s.blaze.pipeline.{HeadStage, LeafBuilder}
 private[blaze] object MockClientBuilder {
   def builder(
       head: => HeadStage[ByteBuffer],
-      tail: => BlazeConnection[IO]): ConnectionBuilder[IO, BlazeConnection[IO]] = { req =>
+      tail: => BlazeConnection[IO]): ConnectionBuilder[IO, BlazeConnection[IO]] = { _ =>
     IO {
       val t = tail
       LeafBuilder(t).base(head)

blaze-core/src/main/scala/org/http4s/blazecore/util/ChunkWriter.scala

@@ -36,7 +36,9 @@ private[util] object ChunkWriter {
       if (trailerHeaders.nonEmpty) {
         val rr = new StringWriter(256)
         rr << "0\r\n" // Last chunk
-        trailerHeaders.foreach(h => h.render(rr) << "\r\n") // trailers
+        trailerHeaders.foreach { h =>
+          h.render(rr) << "\r\n"; ()
+        } // trailers
         rr << "\r\n" // end of chunks
         ByteBuffer.wrap(rr.result.getBytes(ISO_8859_1))
       } else ChunkEndBuffer

blaze-core/src/test/scala/org/http4s/blazecore/util/Http1WriterSpec.scala

@@ -92,17 +92,19 @@ class Http1WriterSpec extends Http4sSpec {
   }
 
   "CachingChunkWriter" should {
-    runNonChunkedTests(tail => new CachingChunkWriter[IO](tail, IO.pure(Headers()), 1024 * 1024))
+    runNonChunkedTests(
+      tail => new CachingChunkWriter[IO](tail, IO.pure(Headers.empty), 1024 * 1024))
   }
 
   "CachingStaticWriter" should {
-    runNonChunkedTests(tail => new CachingChunkWriter[IO](tail, IO.pure(Headers()), 1024 * 1024))
+    runNonChunkedTests(
+      tail => new CachingChunkWriter[IO](tail, IO.pure(Headers.empty), 1024 * 1024))
   }
 
   "FlushingChunkWriter" should {
 
     def builder(tail: TailStage[ByteBuffer]): FlushingChunkWriter[IO] =
-      new FlushingChunkWriter[IO](tail, IO.pure(Headers()))
+      new FlushingChunkWriter[IO](tail, IO.pure(Headers.empty))
 
     "Write a strict chunk" in {
       // n.b. in the scalaz-stream version, we could introspect the
@@ -271,7 +273,7 @@ class Http1WriterSpec extends Http4sSpec {
       def builderWithTrailer(tail: TailStage[ByteBuffer]): FlushingChunkWriter[IO] =
         new FlushingChunkWriter[IO](
           tail,
-          IO.pure(Headers(Header("X-Trailer", "trailer header value"))))
+          IO.pure(Headers.of(Header("X-Trailer", "trailer header value"))))
 
       val p = eval(IO(messageBuffer)).flatMap(chunk(_).covary[IO])
 

blaze-server/src/main/scala/org/http4s/server/blaze/Http1ServerStage.scala

@@ -207,7 +207,7 @@ private[blaze] class Http1ServerStage[F[_]](
     val rr = new StringWriter(512)
     rr << req.httpVersion << ' ' << resp.status.code << ' ' << resp.status.reason << "\r\n"
 
-    Http1Stage.encodeHeaders(resp.headers, rr, isServer = true)
+    Http1Stage.encodeHeaders(resp.headers.toList, rr, isServer = true)
 
     val respTransferCoding = `Transfer-Encoding`.from(resp.headers)
     val lengthHeader = `Content-Length`.from(resp.headers)

blaze-server/src/main/scala/org/http4s/server/blaze/Http2NodeStage.scala

@@ -232,6 +232,7 @@ private class Http2NodeStage[F[_]](
       if (h.name != headers.`Transfer-Encoding`.name &&
         h.name != headers.Connection.name) {
         hs += ((h.name.value.toLowerCase(Locale.ROOT), h.value))
+        ()
       }
     }
 

blaze-server/src/main/scala/org/http4s/server/blaze/WebSocketSupport.scala

@@ -29,7 +29,7 @@ private[blaze] trait WebSocketSupport[F[_]] extends Http1ServerStage[F] {
     ws match {
       case None => super.renderResponse(req, resp, cleanup)
       case Some(wsContext) =>
-        val hdrs = req.headers.map(h => (h.name.toString, h.value))
+        val hdrs = req.headers.toList.map(h => (h.name.toString, h.value))
         if (WebSocketHandshake.isWebSocketRequest(hdrs)) {
           WebSocketHandshake.serverHandshake(hdrs) match {
             case Left((code, msg)) =>
@@ -55,8 +55,10 @@ private[blaze] trait WebSocketSupport[F[_]] extends Http1ServerStage[F] {
                 case (k, v) => sb.append(k).append(": ").append(v).append('\r').append('\n')
               }
 
-              wsContext.headers.foreach(hdr =>
-                sb.append(hdr.name).append(": ").append(hdr.value).append('\r').append('\n'))
+              wsContext.headers.foreach { hdr =>
+                sb.append(hdr.name).append(": ").append(hdr.value).append('\r').append('\n')
+                ()
+              }
 
               sb.append('\r').append('\n')
 

blaze-server/src/test/scala/org/http4s/server/blaze/Http1ServerStageSpec.scala

@@ -172,7 +172,7 @@ class Http1ServerStageSpec extends Http4sSpec with AfterAll {
       val routes = HttpRoutes
         .of[IO] {
           case _ =>
-            val headers = Headers(H.`Transfer-Encoding`(TransferCoding.identity))
+            val headers = Headers.of(H.`Transfer-Encoding`(TransferCoding.identity))
             IO.pure(Response[IO](headers = headers)
               .withEntity("hello world"))
         }
@@ -432,14 +432,14 @@ class Http1ServerStageSpec extends Http4sSpec with AfterAll {
             for {
               _ <- req.body.compile.drain
               hs <- req.trailerHeaders
-              resp <- Ok(hs.mkString)
+              resp <- Ok(hs.toList.mkString)
             } yield resp
 
           case req if req.pathInfo == "/bar" =>
             for {
               // Don't run the body
               hs <- req.trailerHeaders
-              resp <- Ok(hs.mkString)
+              resp <- Ok(hs.toList.mkString)
             } yield resp
         }
         .orNotFound
@@ -466,7 +466,7 @@ class Http1ServerStageSpec extends Http4sSpec with AfterAll {
       .flatMap { canceled =>
         Deferred[IO, Unit].flatMap { gate =>
           val req = "POST /sync HTTP/1.1\r\nConnection:keep-alive\r\nContent-Length: 4\r\n\r\ndone"
-          val app: HttpApp[IO] = HttpApp { req =>
+          val app: HttpApp[IO] = HttpApp { _ =>
             gate.complete(()) >> IO.cancelable(_ => canceled.complete(()))
           }
           for {

client/src/main/scala/org/http4s/client/impl/RequestGenerator.scala

@@ -12,7 +12,7 @@ trait EmptyRequestGenerator[F[_]] extends Any with RequestGenerator {
 
   /** Make a [[org.http4s.Request]] using this [[Method]] */
   final def apply(uri: Uri, headers: Header*)(implicit F: Applicative[F]): F[Request[F]] =
-    F.pure(Request(method, uri, headers = Headers(headers: _*)))
+    F.pure(Request(method, uri, headers = Headers(headers.toList)))
 }
 
 trait EntityRequestGenerator[F[_]] extends Any with EmptyRequestGenerator[F] {
@@ -21,7 +21,7 @@ trait EntityRequestGenerator[F[_]] extends Any with EmptyRequestGenerator[F] {
   final def apply[A](body: A, uri: Uri, headers: Header*)(
       implicit F: Applicative[F],
       w: EntityEncoder[F, A]): F[Request[F]] = {
-    val h = w.headers ++ headers
+    val h = w.headers ++ Headers(headers.toList)
     val entity = w.toEntity(body)
     val newHeaders = entity.length
       .map { l =>

client/src/test/scala/org/http4s/client/ClientRouteTestBattery.scala

@@ -107,13 +107,15 @@ abstract class ClientRouteTestBattery(name: String) extends Http4sSpec with Http
   }
 
   private def checkResponse(rec: Response[IO], expected: Response[IO]): IO[Boolean] = {
-    val hs = rec.headers.toSeq
+    val hs = rec.headers.toList
     for {
       _ <- IO(rec.status must be_==(expected.status))
       body <- rec.body.compile.to[Array]
       expBody <- expected.body.compile.to[Array]
       _ <- IO(body must_== expBody)
-      _ <- IO(expected.headers.foreach(h => h must beOneOf(hs: _*)))
+      _ <- IO(expected.headers.foreach { h =>
+        h must beOneOf(hs: _*); ()
+      })
       _ <- IO(rec.httpVersion must be_==(expected.httpVersion))
     } yield true
   }

client/src/test/scala/org/http4s/client/PoolManagerSpec.scala

@@ -6,6 +6,7 @@ import fs2.Stream
 import scala.concurrent.duration._
 
 class PoolManagerSpec(name: String) extends Http4sSpec {
+  val _ = name
   val key = RequestKey(Uri.Scheme.http, Uri.Authority(host = Uri.IPv4("127.0.0.1")))
   class TestConnection extends Connection[IO] {
     def isClosed = false

client/src/test/scala/org/http4s/client/middleware/RetrySpec.scala

@@ -98,7 +98,7 @@ class RetrySpec extends Http4sSpec with Tables {
       resubmit(PUT)(RetryPolicy.defaultRetriable) must_== Status.Ok
     }
     "recklesslyRetriable resubmits bodies on non-idempotent methods" in {
-      resubmit(POST)((req, result) => RetryPolicy.recklesslyRetriable(result)) must_== Status.Ok
+      resubmit(POST)((_, result) => RetryPolicy.recklesslyRetriable(result)) must_== Status.Ok
     }
 
     "retry exceptions" in {

core/src/main/scala/org/http4s/HeaderKey.scala

@@ -53,18 +53,19 @@ object HeaderKey {
           hs: Headers,
           acc: NonEmptyList[HeaderT#Value]): NonEmptyList[HeaderT#Value] =
         if (hs.nonEmpty) {
-          matchHeader(hs.head) match {
+          matchHeader(hs.toList.head) match {
             case Some(header) =>
-              loop(hs.tail, acc.concatNel(header.values.widen[HeaderT#Value]))
+              loop(Headers(hs.toList.tail), acc.concatNel(header.values.widen[HeaderT#Value]))
             case None =>
-              loop(hs.tail, acc)
+              loop(Headers(hs.toList.tail), acc)
           }
         } else acc
       @tailrec def start(hs: Headers): Option[HeaderT] =
         if (hs.nonEmpty) {
-          matchHeader(hs.head) match {
-            case Some(header) => Some(apply(loop(hs.tail, header.values.widen[HeaderT#Value])))
-            case None => start(hs.tail)
+          matchHeader(hs.toList.head) match {
+            case Some(header) =>
+              Some(apply(loop(Headers(hs.toList.tail), header.values.widen[HeaderT#Value])))
+            case None => start(Headers(hs.toList.tail))
           }
         } else None
       start(headers)