Merge pull request #2228 from xuwei-k/using-clause-implicit

add `using` clause

Author: jatcwang

modules/core/src/main/scala/doobie/util/fragment.scala

@@ -94,7 +94,7 @@ object fragment {
 
     /** Construct an [[Update0]] from this fragment with the given label. */
     def updateWithLabel(label: String): Update0 =
-      Update[elems.type](sql, pos, label)(implicitly[Write[elems.type]]).toUpdate0(elems)
+      Update[elems.type](sql, pos, label)(using implicitly[Write[elems.type]]).toUpdate0(elems)
 
     override def toString =
       s"""Fragment("$sql")"""

modules/core/src/main/scala/doobie/util/query.scala

@@ -120,7 +120,7 @@ object query {
       * @group Results
       */
     def toMap[K, V](a: A)(implicit ev: B =:= (K, V), f: FactoryCompat[(K, V), Map[K, V]]): ConnectionIO[Map[K, V]] =
-      toConnectionIO(a, IHRS.buildPair[Map, K, V](f, read.map(ev)))
+      toConnectionIO(a, IHRS.buildPair[Map, K, V](using f, read.map(ev)))
 
     /** Just like `toMap` but allowing to alter `PreparedExecution`.
       */
@@ -131,7 +131,7 @@ object query {
         ev: B =:= (K, V),
         f: FactoryCompat[(K, V), Map[K, V]]
     ): ConnectionIO[Map[K, V]] =
-      toConnectionIOAlteringExecution(a, IHRS.buildPair[Map, K, V](f, read.map(ev)), fn)
+      toConnectionIOAlteringExecution(a, IHRS.buildPair[Map, K, V](using f, read.map(ev)), fn)
 
     /** Apply the argument `a` to construct a program in `[[doobie.free.connection.ConnectionIO ConnectionIO]]` yielding
       * an `F[B]` accumulated via `MonadPlus` append. This method is more general but less efficient than `to`.

modules/core/src/main/scala/doobie/util/transactor.scala

@@ -211,14 +211,14 @@ object transactor {
       * and translate it to back `M` effect.
       */
     def liftF[I](mkEffect: M ~> ConnectionIO => ConnectionIO[I])(implicit ev: Async[M]): M[I] =
-      WeakAsync.liftK[M, ConnectionIO].use(toConnectionIO => trans(ev).apply(mkEffect(toConnectionIO)))(ev)
+      WeakAsync.liftK[M, ConnectionIO].use(toConnectionIO => trans(using ev).apply(mkEffect(toConnectionIO)))(using ev)
 
     /** Crate a program expressed as `Stream` with `ConnectionIO` effects using a provided natural transformation `M ~>
       * ConnectionIO` and translate it back to a `Stream` with `M` effects.
       */
     def liftS[I](mkStream: M ~> ConnectionIO => Stream[ConnectionIO, I])(implicit ev: Async[M]): Stream[M, I] =
-      Stream.resource(WeakAsync.liftK[M, ConnectionIO])(ev).flatMap(toConnectionIO =>
-        transP(ev).apply(mkStream(toConnectionIO)))
+      Stream.resource(WeakAsync.liftK[M, ConnectionIO])(using ev).flatMap(toConnectionIO =>
+        transP(using ev).apply(mkStream(toConnectionIO)))
 
     /** Embed a `Pipe` with `ConnectionIO` effects inside a `Pipe` with `M` effects by lifting incoming stream to
       * `ConnectionIO` effects and lowering outgoing stream to `M` effects.

modules/refined/src/main/scala/doobie/refined/Instances.scala

@@ -46,7 +46,7 @@ trait Instances {
       validate: Validate[T, P],
       manifest: TypeName[F[T, P]]
   ): F[T, P] =
-    rightOrException[F[T, P]](refType.refine[P](t)(validate))
+    rightOrException[F[T, P]](refType.refine[P](t)(using validate))
 
   private def unwrapRefinedType[T, P, F[_, _]](ftp: F[T, P])(
       implicit refType: RefType[F]
@@ -57,7 +57,7 @@ trait Instances {
       implicit manifest: TypeName[T]
   ): T =
     either match {
-      case Left(err) => throw new SecondaryValidationFailed[T](err)(manifest)
+      case Left(err) => throw new SecondaryValidationFailed[T](err)(using manifest)
       case Right(t)  => t
     }