Doc edits

modules/core/shared/src/main/scala/Session.scala

@@ -133,7 +133,7 @@ trait Session[F[_]] {
    * times with different arguments.
    * @group Queries
    */
-  def prepare[A, B](query: Query[A, B]): Resource[F, PreparedQuery[F, A, B]] = 
+  def prepare[A, B](query: Query[A, B]): Resource[F, PreparedQuery[F, A, B]] =
     Resource.eval(prepareAndCache(query))
 
   /**
@@ -143,16 +143,16 @@ trait Session[F[_]] {
    */
   def prepare[A](command: Command[A]): Resource[F, PreparedCommand[F, A]] =
     Resource.eval(prepareAndCache(command))
-  
+
   /**
-   * Prepares then cache a query, yielding a `PreparedQuery` which can be executed multiple
-   * times with different arguments. 
+   * Prepares then caches a query, yielding a `PreparedQuery` which can be executed multiple
+   * times with different arguments.
    * @group Queries
    */
   def prepareAndCache[A, B](query: Query[A, B]): F[PreparedQuery[F, A, B]]
 
   /**
-   * Prepares then cache an `INSERT`, `UPDATE`, or `DELETE` command that returns no rows. The resulting
+   * Prepares then caches an `INSERT`, `UPDATE`, or `DELETE` command that returns no rows. The resulting
    * `PreparedCommand` can be executed multiple times with different arguments.
    * @group Commands
    */

modules/core/shared/src/main/scala/data/SemispaceCache.scala

@@ -28,9 +28,8 @@ sealed abstract case class SemispaceCache[K, V](gen0: Map[K, V], gen1: Map[K, V]
   def containsKey(k: K): Boolean =
     gen0.contains(k) || gen1.contains(k)
 
-  def values: Seq[V] = 
-    (gen0.values.toSet | gen1.values.toSet).toSeq 
-
+  def values: Seq[V] =
+    (gen0.values.toSet | gen1.values.toSet).toSeq
 }
 
 object SemispaceCache {
@@ -41,4 +40,4 @@ object SemispaceCache {
   def empty[K, V](max: Int): SemispaceCache[K, V] =
     SemispaceCache[K, V](Map.empty, Map.empty, max max 0)
 
-}
+}

modules/core/shared/src/main/scala/net/Protocol.scala

@@ -63,13 +63,13 @@ trait Protocol[F[_]] {
 
   /**
    * Prepare a command (a statement that produces no rows), yielding a `Protocol.PreparedCommand`
-   * which will cached per session and closed on session close.
+   * which will be cached per session and closed on session close.
    */
   def prepare[A](command: Command[A], ty: Typer): F[Protocol.PreparedCommand[F, A]]
 
   /**
    * Prepare a query (a statement that produces rows), yielding a `Protocol.PreparedCommand` which
-   * which will cached per session and closed on session close.
+   * which will be cached per session and closed on session close.
    */
   def prepare[A, B](query: Query[A, B], ty: Typer): F[Protocol.PreparedQuery[F, A, B]]
 
@@ -94,9 +94,9 @@ trait Protocol[F[_]] {
   def startup(user: String, database: String, password: Option[String], parameters: Map[String, String]): F[Unit]
 
   /**
-   * Cleanup the session. This will close ay cached prepared statement
+   * Cleanup the session. This will close any cached prepared statements.
    */
-  def cleanup:F[Unit]
+  def cleanup: F[Unit]
 
   /**
    * Signal representing the current transaction status as reported by `ReadyForQuery`. It's not
@@ -106,10 +106,9 @@ trait Protocol[F[_]] {
 
   /** Cache for the `Describe` protocol. */
   def describeCache: Describe.Cache[F]
-  
+
   /** Cache for the `Parse` protocol. */
   def parseCache: Parse.Cache[F]
-
 }
 
 object Protocol {

modules/core/shared/src/main/scala/net/protocol/Prepare.scala

@@ -41,7 +41,7 @@ object Prepare {
               }
             }
         }
-      
+
       override def apply[A, B](query: skunk.Query[A, B], ty: Typer): F[PreparedQuery[F, A, B]] =
         for {
           id <- Parse[F](parseCache).apply(query, ty)
@@ -58,4 +58,4 @@ object Prepare {
 
       }
 
-}
+}