Skip to content

Commit 4f869ba

Browse files
author
pkiersznowski
committed
Replace given with implicits
1 parent 34a9bdb commit 4f869ba

File tree

19 files changed

+64
-68
lines changed

19 files changed

+64
-68
lines changed

‎README.md

+1-8
Original file line numberDiff line numberDiff line change
@@ -668,13 +668,6 @@ If you're using recursive types - due to [this issue](https://github.com/circe/c
668668
case class R(a: Int, rs: Seq[R]) derives Decoder, Encoder.AsObject
669669
```
670670

671-
672-
3. If you're using flat format or Snakified/Capitalized formats, remember to import `given` instances, e.g.:
673-
```scala
674-
object KebsProtocol extends KebsCirce with KebsCirce.Snakified
675-
import KebsProtocol.{given, _}
676-
```
677-
678671
#### - kebs generates akka-http / pekko-http Unmarshaller (kebs-akka-http / kebs-pekko-http)
679672

680673
It makes it very easy to use 1-element case-classes or `enumeratum` enums/value enums in eg. `parameters` directive:
@@ -729,7 +722,7 @@ import org.http4s.dsl.io._
729722
import org.http4s.implicits._
730723

731724
import pl.iterators.kebs.opaque.Opaque
732-
import pl.iterators.kebs.http4s.{given, _}
725+
import pl.iterators.kebs.http4s._
733726
import pl.iterators.kebs.instances.KebsInstances._ // optional, if you want instances support, ex. java.util.Currency
734727

735728
opaque type Age = Int

‎circe/src/main/scala-3/pl/iterators/kebs/circe/KebsCirce.scala

+4-4
Original file line numberDiff line numberDiff line change
@@ -30,17 +30,17 @@ private[circe] trait KebsAutoDerivation extends CaseClass1ToValueClass {
3030
}
3131
trait KebsCirce extends KebsAutoDerivation {
3232

33-
inline given[T, A](using rep: ValueClassLike[T, A], decoder: Decoder[A]): Decoder[T] = {
33+
implicit inline def kebsDecoder[T, A](using rep: ValueClassLike[T, A], decoder: Decoder[A]): Decoder[T] = {
3434
decoder.emap(obj => Try(rep.apply(obj)).toEither.left.map(_.getMessage))
3535
}
3636

37-
inline given[T, A](using rep: ValueClassLike[T, A], encoder: Encoder[A]): Encoder[T] =
37+
implicit inline def kebsEncoder[T, A](using rep: ValueClassLike[T, A], encoder: Encoder[A]): Encoder[T] =
3838
encoder.contramap(rep.unapply)
3939

40-
inline given[T, A](using rep: InstanceConverter[T, A], encoder: Encoder[A]): Encoder[T] =
40+
implicit inline def kebsEncoder[T, A](using rep: InstanceConverter[T, A], encoder: Encoder[A]): Encoder[T] =
4141
encoder.contramap(rep.encode)
4242

43-
inline given[T, A](using rep: InstanceConverter[T, A], decoder: Decoder[A]): Decoder[T] =
43+
implicit inline def kebsDecoder[T, A](using rep: InstanceConverter[T, A], decoder: Decoder[A]): Decoder[T] =
4444
decoder.emap(obj => Try(rep.decode(obj)).toEither.left.map(_.getMessage))
4545
}
4646

‎circe/src/main/scala-3/pl/iterators/kebs/circe/KebsEnumFormats.scala

+8-8
Original file line numberDiff line numberDiff line change
@@ -60,29 +60,29 @@ trait CirceValueEnum {
6060
}
6161

6262
trait KebsEnumFormats extends CirceEnum with CirceValueEnum {
63-
implicit inline given[E <: Enum](using ev: EnumLike[E]): Decoder[E] = enumDecoder(ev)
63+
implicit inline def kebsEnumDecoder[E <: Enum](using ev: EnumLike[E]): Decoder[E] = enumDecoder(ev)
6464

65-
implicit inline given[E <: Enum](using ev: EnumLike[E]): Encoder[E] = enumEncoder(ev)
65+
implicit inline def kebsEnumEncoder[E <: Enum](using ev: EnumLike[E]): Encoder[E] = enumEncoder(ev)
6666

67-
implicit inline given[V, E <: ValueEnumLikeEntry[V]](using ev: ValueEnumLike[V, E], decoder: Decoder[V]): Decoder[E] =
67+
implicit inline def kebsValueEnumDecoder[V, E <: ValueEnumLikeEntry[V]](using ev: ValueEnumLike[V, E], decoder: Decoder[V]): Decoder[E] =
6868
valueEnumDecoder(ev)
6969

70-
implicit inline given[V, E <: ValueEnumLikeEntry[V]](using ev: ValueEnumLike[V, E], encoder: Encoder[V]): Encoder[E] =
70+
implicit inline def kebsValueEnumEncoder[V, E <: ValueEnumLikeEntry[V]](using ev: ValueEnumLike[V, E], encoder: Encoder[V]): Encoder[E] =
7171
valueEnumEncoder(ev)
7272

7373
trait Uppercase extends CirceEnum {
74-
implicit inline given[E <: Enum](using ev: EnumLike[E]): Decoder[E] =
74+
implicit inline def kebsUppercaseEnumDecoder[E <: Enum](using ev: EnumLike[E]): Decoder[E] =
7575
uppercaseEnumDecoder(ev)
7676

77-
implicit inline given[E <: Enum](using ev: EnumLike[E]): Encoder[E] =
77+
implicit inline def kebsUppercaseEnumEncoder[E <: Enum](using ev: EnumLike[E]): Encoder[E] =
7878
uppercaseEnumEncoder(ev)
7979
}
8080

8181
trait Lowercase extends CirceEnum {
82-
implicit inline given[E <: Enum](using ev: EnumLike[E]): Decoder[E] =
82+
implicit inline def kebsLowercaseEnumDecoder[E <: Enum](using ev: EnumLike[E]): Decoder[E] =
8383
lowercaseEnumDecoder(ev)
8484

85-
implicit inline given[E <: Enum](using ev: EnumLike[E]): Encoder[E] =
85+
implicit inline def kebsLowercaseEnumEncoder[E <: Enum](using ev: EnumLike[E]): Encoder[E] =
8686
lowercaseEnumEncoder(ev)
8787
}
8888
}

‎circe/src/test/scala-3/pl/iterators/kebs/circe/CirceFormatCapitalizedVariantTests.scala

+1-1
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ import pl.iterators.kebs.circe.model._
1010

1111
class CirceFormatCapitalizedVariantTests extends AnyFunSuite with Matchers {
1212
object KebsProtocol extends KebsCirce with KebsCirce.Capitalized
13-
import KebsProtocol.{given, _}
13+
import KebsProtocol._
1414

1515
test("Flat format remains unchanged") {
1616
val decoder = implicitly[Decoder[C]]

‎circe/src/test/scala-3/pl/iterators/kebs/circe/CirceFormatSnakifiedVariantTests.scala

+1-1
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ import io.circe.derivation.Configuration
1212

1313
class CirceFormatSnakifiedVariantTests extends AnyFunSuite with Matchers {
1414
object KebsProtocol extends KebsCirce with KebsCirce.Snakified
15-
import KebsProtocol.{given, _}
15+
import KebsProtocol._
1616

1717
test("Flat format remains unchanged") {
1818
val decoder = implicitly[Decoder[C]]

‎circe/src/test/scala-3/pl/iterators/kebs/circe/CirceFormatTests.scala

+1-1
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ import pl.iterators.kebs.circe.model._
1313

1414
class CirceFormatTests extends AnyFunSuite with Matchers {
1515
object KebsProtocol extends KebsCirce
16-
import KebsProtocol.{given, _}
16+
import KebsProtocol._
1717

1818
// https://github.com/circe/circe/issues/1980
1919
case class R(a: Int, rs: Seq[R]) derives Decoder, Encoder.AsObject

‎circe/src/test/scala-3/pl/iterators/kebs/circe/instances/TimeInstancesMixinTests.scala

+4-4
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ class TimeInstancesMixinTests extends AnyFunSuite with Matchers {
1717

1818
test("Instant epoch milli format") {
1919
object TimeInstancesProtocol extends KebsCirce with InstantEpochMilliLong
20-
import TimeInstancesProtocol.{given, _}
20+
import TimeInstancesProtocol._
2121

2222
"implicitly[ValueClassLike[Instant, Long]]" shouldNot typeCheck
2323
"implicitly[ValueClassLike[Long, Instant]]" shouldNot typeCheck
@@ -33,7 +33,7 @@ class TimeInstancesMixinTests extends AnyFunSuite with Matchers {
3333

3434
test("Duration nanos format, Instant epoch milli format") {
3535
object TimeInstancesProtocol extends KebsCirce with DurationNanosLong with InstantEpochMilliLong
36-
import TimeInstancesProtocol.{given, _}
36+
import TimeInstancesProtocol._
3737

3838
"implicitly[ValueClassLike[Instant, Long]]" shouldNot typeCheck
3939
"implicitly[ValueClassLike[Long, Instant]]" shouldNot typeCheck
@@ -64,7 +64,7 @@ class TimeInstancesMixinTests extends AnyFunSuite with Matchers {
6464
override implicit val localDateTimeFormatter: InstanceConverter[LocalDateTime, String] =
6565
InstanceConverter.apply[LocalDateTime, String](_.format(formatter), LocalDateTime.parse(_, formatter))
6666
}
67-
import TimeInstancesProtocol.{given, _}
67+
import TimeInstancesProtocol._
6868

6969
"implicitly[ValueClassLike[LocalDateTime, String]]" shouldNot typeCheck
7070
"implicitly[ValueClassLike[String, LocalDateTime]]" shouldNot typeCheck
@@ -98,7 +98,7 @@ class TimeInstancesMixinTests extends AnyFunSuite with Matchers {
9898
}
9999
}
100100
}
101-
import TimeInstancesProtocol.{given, _}
101+
import TimeInstancesProtocol._
102102

103103
"implicitly[ValueClassLike[LocalDateTime, String]]" shouldNot typeCheck
104104
"implicitly[ValueClassLike[String, LocalDateTime]]" shouldNot typeCheck

‎core/src/main/scala-3/pl/iterators/kebs/core/macros/ValueClassReps.scala

+1-1
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ import scala.deriving.Mirror
55
final class ValueClassLike[VC, F1](val apply: F1 => VC, val unapply: VC => F1)
66

77
trait CaseClass1ToValueClass {
8-
inline given[T <: Product, F1](using m: Mirror.ProductOf[T], teq: m.MirroredElemTypes =:= F1 *: EmptyTuple.type): ValueClassLike[T, F1] = {
8+
implicit inline def caseClass1ToValueClassLike[T <: Product, F1](using m: Mirror.ProductOf[T], teq: m.MirroredElemTypes =:= F1 *: EmptyTuple.type): ValueClassLike[T, F1] = {
99
new ValueClassLike[T, F1](f1 => m.fromProduct(Tuple1(f1)), _.productElement(0).asInstanceOf[F1])
1010
}
1111
}

‎doobie/src/main/scala-3/pl/iterators/kebs/doobie/Kebs.scala

+7-7
Original file line numberDiff line numberDiff line change
@@ -8,17 +8,17 @@ import pl.iterators.kebs.core.macros.ValueClassLike
88
import scala.reflect.ClassTag
99

1010
trait Kebs {
11-
inline given[A, M](using vcLike: ValueClassLike[A, M], m: Meta[M]): Meta[A] = m.imap(vcLike.apply)(vcLike.unapply)
11+
implicit inline def meta[A, M](using vcLike: ValueClassLike[A, M], m: Meta[M]): Meta[A] = m.imap(vcLike.apply)(vcLike.unapply)
1212

13-
inline given[A, M](using vcLike: ValueClassLike[A, M], m: Meta[Option[M]]): Meta[Option[A]] = m.imap(_.map(vcLike.apply))(_.map(vcLike.unapply))
13+
implicit inline def metaOption[A, M](using vcLike: ValueClassLike[A, M], m: Meta[Option[M]]): Meta[Option[A]] = m.imap(_.map(vcLike.apply))(_.map(vcLike.unapply))
1414

15-
inline given[A, M](using vcLike: ValueClassLike[A, M], m: Meta[Array[M]], cta: ClassTag[A], ctm: ClassTag[M]): Meta[Array[A]] = m.imap(_.map(vcLike.apply))(_.map(vcLike.unapply))
15+
implicit inline def metaArray[A, M](using vcLike: ValueClassLike[A, M], m: Meta[Array[M]], cta: ClassTag[A], ctm: ClassTag[M]): Meta[Array[A]] = m.imap(_.map(vcLike.apply))(_.map(vcLike.unapply))
1616

17-
inline given[A, M](using vcLike: ValueClassLike[A, M], m: Meta[Array[Option[M]]], cta: ClassTag[Option[A]]): Meta[Array[Option[A]]] = m.imap(_.map(_.map(vcLike.apply)))(_.map(_.map(vcLike.unapply)))
17+
implicit inline def metaArrayOption[A, M](using vcLike: ValueClassLike[A, M], m: Meta[Array[Option[M]]], cta: ClassTag[Option[A]]): Meta[Array[Option[A]]] = m.imap(_.map(_.map(vcLike.apply)))(_.map(_.map(vcLike.unapply)))
1818

19-
inline given[A, M](using instanceConverter: InstanceConverter[A, M], m: Meta[M]): Meta[A] = m.imap(instanceConverter.decode)(instanceConverter.encode)
19+
implicit inline def meta[A, M](using instanceConverter: InstanceConverter[A, M], m: Meta[M]): Meta[A] = m.imap(instanceConverter.decode)(instanceConverter.encode)
2020

21-
inline given[A, M](using instanceConverter: InstanceConverter[A, M], m: Meta[Array[M]], cta: ClassTag[A], ctm: ClassTag[M]): Meta[Array[A]] = m.imap(_.map(instanceConverter.decode))(_.map(instanceConverter.encode))
21+
implicit inline def metaArray[A, M](using instanceConverter: InstanceConverter[A, M], m: Meta[Array[M]], cta: ClassTag[A], ctm: ClassTag[M]): Meta[Array[A]] = m.imap(_.map(instanceConverter.decode))(_.map(instanceConverter.encode))
2222

23-
inline given[A, M](using instanceConverter: InstanceConverter[A, M], m: Meta[Array[Option[M]]], cta: ClassTag[Option[A]]): Meta[Array[Option[A]]] = m.imap(_.map(_.map(instanceConverter.decode)))(_.map(_.map(instanceConverter.encode)))
23+
implicit inline def metaArrayOption[A, M](using instanceConverter: InstanceConverter[A, M], m: Meta[Array[Option[M]]], cta: ClassTag[Option[A]]): Meta[Array[Option[A]]] = m.imap(_.map(_.map(instanceConverter.decode)))(_.map(_.map(instanceConverter.encode)))
2424
}

‎doobie/src/main/scala-3/pl/iterators/kebs/doobie/enums/KebsEnums.scala

+9-9
Original file line numberDiff line numberDiff line change
@@ -7,19 +7,19 @@ import scala.reflect.Enum
77
import pl.iterators.kebs.core.enums.EnumLike
88

99
trait KebsEnums {
10-
inline given enumMeta[E](using e: EnumLike[E]): Meta[E] = Meta.StringMeta.imap(e.valueOf)(_.toString)
11-
inline given enumArrayMeta[E](using e: EnumLike[E], m: Meta[Array[String]], ct: ClassTag[E]): Meta[Array[E]] = m.imap(_.map(e.valueOf))(_.map(_.toString))
12-
inline given enumOptionArrayMeta[E](using e: EnumLike[E], m: Meta[Array[Option[String]]], ct: ClassTag[Option[E]]): Meta[Array[Option[E]]] = m.imap(_.map(_.map(e.valueOf)))(_.map(_.map(_.toString)))
10+
implicit inline def enumMeta[E](using e: EnumLike[E]): Meta[E] = Meta.StringMeta.imap(e.valueOf)(_.toString)
11+
implicit inline def enumArrayMeta[E](using e: EnumLike[E], m: Meta[Array[String]], ct: ClassTag[E]): Meta[Array[E]] = m.imap(_.map(e.valueOf))(_.map(_.toString))
12+
implicit inline def enumOptionArrayMeta[E](using e: EnumLike[E], m: Meta[Array[Option[String]]], ct: ClassTag[Option[E]]): Meta[Array[Option[E]]] = m.imap(_.map(_.map(e.valueOf)))(_.map(_.map(_.toString)))
1313

1414
trait Uppercase {
15-
inline given enumUppercaseMeta[E](using e: EnumLike[E]): Meta[E] = Meta.StringMeta.imap(s => e.values.find(_.toString.toUpperCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s")))(_.toString.toUpperCase)
16-
inline given enumUppercaseArrayMeta[E](using e: EnumLike[E], m: Meta[Array[String]], ct: ClassTag[E]): Meta[Array[E]] = m.imap(_.map(s => e.values.find(_.toString.toUpperCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s"))))(_.map(_.toString.toUpperCase))
17-
inline given enumUppercaseOptionArrayMeta[E](using e: EnumLike[E], m: Meta[Array[Option[String]]], ct: ClassTag[Option[E]]): Meta[Array[Option[E]]] = m.imap(_.map(_.map(s => e.values.find(_.toString.toUpperCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s")))))(_.map(_.map(_.toString.toUpperCase)))
15+
implicit inline def enumUppercaseMeta[E](using e: EnumLike[E]): Meta[E] = Meta.StringMeta.imap(s => e.values.find(_.toString.toUpperCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s")))(_.toString.toUpperCase)
16+
implicit inline def enumUppercaseArrayMeta[E](using e: EnumLike[E], m: Meta[Array[String]], ct: ClassTag[E]): Meta[Array[E]] = m.imap(_.map(s => e.values.find(_.toString.toUpperCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s"))))(_.map(_.toString.toUpperCase))
17+
implicit inline def enumUppercaseOptionArrayMeta[E](using e: EnumLike[E], m: Meta[Array[Option[String]]], ct: ClassTag[Option[E]]): Meta[Array[Option[E]]] = m.imap(_.map(_.map(s => e.values.find(_.toString.toUpperCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s")))))(_.map(_.map(_.toString.toUpperCase)))
1818
}
1919

2020
trait Lowercase {
21-
inline given enumLowercaseMeta[E](using e: EnumLike[E]): Meta[E] = Meta.StringMeta.imap(s => e.values.find(_.toString.toLowerCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s")))(_.toString.toLowerCase)
22-
inline given enumLowercaseMeta[E](using e: EnumLike[E], m: Meta[Array[String]], ct: ClassTag[E]): Meta[Array[E]] = m.imap(_.map(s => e.values.find(_.toString.toLowerCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s"))))(_.map(_.toString.toLowerCase))
23-
inline given enumLowercaseOptionArrayMeta[E](using e: EnumLike[E], m: Meta[Array[Option[String]]], ct: ClassTag[Option[E]]): Meta[Array[Option[E]]] = m.imap(_.map(_.map(s => e.values.find(_.toString.toLowerCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s")))))(_.map(_.map(_.toString.toLowerCase)))
21+
implicit inline def enumLowercaseMeta[E](using e: EnumLike[E]): Meta[E] = Meta.StringMeta.imap(s => e.values.find(_.toString.toLowerCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s")))(_.toString.toLowerCase)
22+
implicit inline def enumLowercaseMeta[E](using e: EnumLike[E], m: Meta[Array[String]], ct: ClassTag[E]): Meta[Array[E]] = m.imap(_.map(s => e.values.find(_.toString.toLowerCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s"))))(_.map(_.toString.toLowerCase))
23+
implicit inline def enumLowercaseOptionArrayMeta[E](using e: EnumLike[E], m: Meta[Array[Option[String]]], ct: ClassTag[Option[E]]): Meta[Array[Option[E]]] = m.imap(_.map(_.map(s => e.values.find(_.toString.toLowerCase == s).getOrElse(throw new IllegalArgumentException(s"enum case not found: $s")))))(_.map(_.map(_.toString.toLowerCase)))
2424
}
2525
}

‎doobie/src/test/scala-3/pl/iterators/kebs/doobie/ComplexTypesTests.scala

+3-3
Original file line numberDiff line numberDiff line change
@@ -8,9 +8,9 @@ import org.scalatest.funsuite.AnyFunSuite
88
import org.scalatest.matchers.should.Matchers
99
import pl.iterators.kebs.doobie.model._
1010
import pl.iterators.kebs.enums.KebsEnum
11-
import pl.iterators.kebs.doobie.given
12-
import pl.iterators.kebs.doobie.enums.given
13-
import pl.iterators.kebs.instances.KebsInstances.given
11+
import pl.iterators.kebs.doobie._
12+
import pl.iterators.kebs.doobie.enums._
13+
import pl.iterators.kebs.instances.KebsInstances._
1414
import pl.iterators.kebs.opaque.Opaque
1515

1616
import java.util.Currency

‎enumeratum/src/main/scala-3/pl/iterators/kebs/enumeratum/KebsEnumeratum.scala

+1-1
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ import scala.reflect.{ClassTag, Enum}
1010
import pl.iterators.kebs.core.enums.EnumLike
1111

1212
trait KebsEnumeratum {
13-
inline given [E <: EnumEntry](using m: Mirror.SumOf[E], ct: ClassTag[E]): EnumLike[E] = {
13+
implicit inline def enumLike[E <: EnumEntry](using m: Mirror.SumOf[E], ct: ClassTag[E]): EnumLike[E] = {
1414
val enumValues = summonCases[m.MirroredElemTypes, E]
1515
new EnumLike[E] {
1616
override def values: immutable.Seq[E] = enumValues.toSeq

‎enumeratum/src/main/scala-3/pl/iterators/kebs/enumeratum/KebsValueEnumeratum.scala

+1-1
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ import scala.reflect.{ClassTag, Enum}
1010
import pl.iterators.kebs.core.enums.{ValueEnumLike, ValueEnumLikeEntry}
1111

1212
trait KebsValueEnumeratum {
13-
inline given [V, E <: ValueEnumEntry[V] with ValueEnumLikeEntry[V]](using m: Mirror.SumOf[E], ct: ClassTag[E]): ValueEnumLike[V, E] = {
13+
inline implicit def valueEnumLike[V, E <: ValueEnumEntry[V] with ValueEnumLikeEntry[V]](using m: Mirror.SumOf[E], ct: ClassTag[E]): ValueEnumLike[V, E] = {
1414
val enumValues = summonValueCases[m.MirroredElemTypes, V, E]
1515
new ValueEnumLike[V, E] {
1616
override def values: immutable.Seq[E] = enumValues

‎http4s-stir/src/main/scala-3/pl/iterators/kebs/http4sstir/unmarshallers/enums/KebsEnumUnmarshallers.scala

+6-6
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ trait EnumUnmarshallers {
1818
}
1919
}
2020

21-
given kebsEnumUnmarshaller[E <: Enum](using e: EnumLike[E]): FromStringUnmarshaller[E] =
21+
implicit def kebsEnumUnmarshaller[E <: Enum](using e: EnumLike[E]): FromStringUnmarshaller[E] =
2222
enumUnmarshaller
2323
}
2424

@@ -39,19 +39,19 @@ trait ValueEnumUnmarshallers extends EnumUnmarshallers {
3939
}
4040
}
4141

42-
given kebsValueEnumUnmarshaller[V, E <: ValueEnumLikeEntry[V]](using `enum`: ValueEnumLike[V, E], cls: ClassTag[V]): Unmarshaller[V, E] =
42+
implicit def kebsValueEnumUnmarshaller[V, E <: ValueEnumLikeEntry[V]](using `enum`: ValueEnumLike[V, E], cls: ClassTag[V]): Unmarshaller[V, E] =
4343
valueEnumUnmarshaller
4444

45-
given kebsIntValueEnumFromStringUnmarshaller[E <: ValueEnumLikeEntry[Int]](using ev: ValueEnumLike[Int, E]): FromStringUnmarshaller[E] =
45+
implicit def kebsIntValueEnumFromStringUnmarshaller[E <: ValueEnumLikeEntry[Int]](using ev: ValueEnumLike[Int, E]): FromStringUnmarshaller[E] =
4646
intFromStringUnmarshaller andThen valueEnumUnmarshaller
4747

48-
given kebsLongValueEnumFromStringUnmarshaller[E <: ValueEnumLikeEntry[Long]](using ev: ValueEnumLike[Long, E]): FromStringUnmarshaller[E] =
48+
implicit def kebsLongValueEnumFromStringUnmarshaller[E <: ValueEnumLikeEntry[Long]](using ev: ValueEnumLike[Long, E]): FromStringUnmarshaller[E] =
4949
longFromStringUnmarshaller andThen valueEnumUnmarshaller
5050

51-
given kebsShortValueEnumFromStringUnmarshaller[E <: ValueEnumLikeEntry[Short]](using ev: ValueEnumLike[Short, E]): FromStringUnmarshaller[E] =
51+
implicit def kebsShortValueEnumFromStringUnmarshaller[E <: ValueEnumLikeEntry[Short]](using ev: ValueEnumLike[Short, E]): FromStringUnmarshaller[E] =
5252
shortFromStringUnmarshaller andThen valueEnumUnmarshaller
5353

54-
given kebsByteValueEnumFromStringUnmarshaller[E <: ValueEnumLikeEntry[Byte]](using ev: ValueEnumLike[Byte, E]): FromStringUnmarshaller[E] =
54+
implicit def kebsByteValueEnumFromStringUnmarshaller[E <: ValueEnumLikeEntry[Byte]](using ev: ValueEnumLike[Byte, E]): FromStringUnmarshaller[E] =
5555
byteFromStringUnmarshaller andThen valueEnumUnmarshaller
5656
}
5757

‎http4s/src/main/scala-3/pl/iterators/kebs/http4s/package.scala

+3-3
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,6 @@ object InstanceUUID {
5252
def apply[T](using rep: InstanceConverter[T, UUID]) = new PathVar[T](str => Try(rep.decode(UUID.fromString(str))))
5353
}
5454

55-
given[T, U](using rep: ValueClassLike[T, U], qpd: QueryParamDecoder[U]): QueryParamDecoder[T] = qpd.emap(u => Try(rep.apply(u)).toEither.left.map(t => ParseFailure(t.getMessage, t.getMessage)))
56-
given[T, U](using rep: InstanceConverter[T, U], qpd: QueryParamDecoder[U]): QueryParamDecoder[T] = qpd.emap(u => Try(rep.decode(u)).toEither.left.map(t => ParseFailure(t.getMessage, t.getMessage)))
57-
given[E <: Enum](using e: EnumLike[E]): QueryParamDecoder[E] = QueryParamDecoder[String].emap(str => Try(e.values.find(_.toString.toUpperCase == str.toUpperCase).getOrElse(throw new IllegalArgumentException(s"enum case not found: $str"))).toEither.left.map(t => ParseFailure(t.getMessage, t.getMessage)))
55+
implicit def valueClassQueryParamDecoder[T, U](using rep: ValueClassLike[T, U], qpd: QueryParamDecoder[U]): QueryParamDecoder[T] = qpd.emap(u => Try(rep.apply(u)).toEither.left.map(t => ParseFailure(t.getMessage, t.getMessage)))
56+
implicit def instanceConverterQueryParamDecoder[T, U](using rep: InstanceConverter[T, U], qpd: QueryParamDecoder[U]): QueryParamDecoder[T] = qpd.emap(u => Try(rep.decode(u)).toEither.left.map(t => ParseFailure(t.getMessage, t.getMessage)))
57+
implicit def enumQueryParamDecoder[E <: Enum](using e: EnumLike[E]): QueryParamDecoder[E] = QueryParamDecoder[String].emap(str => Try(e.values.find(_.toString.toUpperCase == str.toUpperCase).getOrElse(throw new IllegalArgumentException(s"enum case not found: $str"))).toEither.left.map(t => ParseFailure(t.getMessage, t.getMessage)))

0 commit comments

Comments
 (0)