tofu-tf / derevo Goto Github PK

trait encoder {
  type Raw
  type Tag <: this.type

  implicit def liftedEncoder(implicit raw: Encoder[Raw]): Encoder[Raw @@ Tag] = LiftF[Encoder].lift
}

object Example extends TaggedType[String] with encoder
type Example = Example.Type

@derive(encoder)
object Example extends TaggedType[String] with encoder
type Example = Example.Type

 object bsonDocumentWriter 
   extends PolyDerivation[BSONWriter[?, _ <: BSONValue], BSONDocumentWriter]

import upickle.default.{ReadWriter => RW, macroRW}
case class Thing(myFieldA: Int, myFieldB: String)
object Thing{
  implicit val rw: RW[Thing] = macroRW
}
case class Big(i: Int, b: Boolean, str: String, c: Char, t: Thing)
object Big{
  implicit val rw: RW[Big] = macroRW
}

sealed trait IntOrTuple
object IntOrTuple{
  implicit val rw: RW[IntOrTuple] = RW.merge(IntThing.rw, TupleThing.rw)
}
case class IntThing(i: Int) extends IntOrTuple
object IntThing{
  implicit val rw: RW[IntThing] = macroRW
}
case class TupleThing(name: String, t: (Int, Int)) extends IntOrTuple
object TupleThing{
  implicit val rw: RW[TupleThing] = macroRW
}

@derive(functorK)
trait FooCache[F[_], K, V] {
  def get(key: K): F[Option[V]]
  def upsert(key: K, value: V): F[Unit]
  def invalidate(key: K): F[Unit]
}

import com.sksamuel.avro4s.{Encoder, Decoder, SchemaFor}

@derive(Encoder, Decoder, SchemaFor)
case class FooBar(foo: String, bar: Int)

@avro4sCodec
case class FooBar(foo: String, bar: Int)

@derive(avro4sCodec)
case class FooBar(foo: String, bar: Int)

[error] brand.scala:35:4: Could not find io.circe.Decoder instance for shop.domain.brand.BrandId
[error]   @derive(decoder, encoder)
[error]    ^

import java.util.UUID

import derevo.derive
import derevo.circe.{ decoder, encoder }
import io.estatico.newtype.macros.newtype

object brand {
  @newtype @derive(decoder, encoder)
  case class BrandId(value: UUID)
 
  @newtype @derive(decoder, encoder)
  case class BrandName(value: String) {
    def toBrand(brandId: BrandId): Brand =
      Brand(brandId, this)
  }
 
  @derive(decoder, encoder)
  case class Brand(uuid: BrandId, name: BrandName)
}

object brand {
  @newtype case class BrandId(value: UUID)
  object BrandId {
    implicit val jsonEncoder: Encoder[BrandId] = deriving
    implicit val jsonDecoder: Decoder[BrandId] = deriving
  }
 
  @newtype case class BrandName(value: String) {
    def toBrand(brandId: BrandId): Brand =
      Brand(brandId, this)
  }
  object BrandName {
    implicit val jsonEncoder: Encoder[BrandName] = deriving
    implicit val jsonDecoder: Decoder[BrandName] = deriving
  }
 
  @derive(decoder, encoder)
  case class Brand(uuid: BrandId, name: BrandName)
}

@derive(decoder, encoder, eqv, show, uuid)
@newtype
case class ItemId(value: UUID)
object ItemId {
  implicit val keyEncoder: KeyEncoder[ItemId] = deriving
  implicit val keyDecoder: KeyDecoder[ItemId] = deriving
}

import derevo.{ Derivation, NewTypeDerivation }
import io.circe.KeyDecoder
import magnolia.{ CaseClass, Magnolia }

object keyDecoder extends Derivation[KeyDecoder] with NewTypeDerivation[KeyDecoder] {
  type Typeclass[T] = KeyDecoder[T]

  def combine[T](ctx: CaseClass[KeyDecoder, T]): KeyDecoder[T] = new KeyDecoder[T] {
    def apply(key: String): Option[T] =
      ctx.parameters.toList match {
        case (p :: _) => p.typeclass.apply(key).map(_.asInstanceOf[T])
        case _        => None
      }
  }

  def instance[T]: KeyDecoder[T] = macro Magnolia.gen[T]
}

object keyEncoder extends Derivation[KeyEncoder] with NewTypeDerivation[KeyEncoder] {
  type Typeclass[T] = KeyEncoder[T]

  def combine[T](ctx: CaseClass[KeyEncoder, T]): KeyEncoder[T] = new KeyEncoder[T] {
    def apply(key: T): String =
      ctx.parameters.toList match {
        case (p :: _) => p.typeclass.apply(key.asInstanceOf[p.PType])
        case _        => "error"
      }
  }

  def instance[T]: KeyEncoder[T] = macro Magnolia.gen[T]
}

@derive(decoder, encoder, keyDecoder, keyEncoder, eqv, show, uuid)
@newtype
case class ItemId(value: UUID)

@derive(functor)
trait Bar[A] {
  def bar(x: Int): A
}

@SuppressWarnings(Array("deprecation")) // any annotation here
object Bar

data {
  name = Demo
  list = [1, 2, 3]
  map.wtf = 1
  map.lol = 2
  map.wut = 3
  rate {
    elements = 2
    duration = 100 millis
  }
}

Data(Demo,List(3, 2, 1),Map(wut -> 3, lol -> 2, wtf -> 1),Rate(2))

@newtype
@derive(show)
case class Foo(value: String)

@newtype
@derive(show)
case class Bar(value: Int)

@derive(show)
final case class Ctx(foo: Foo, bar: Bar)

import derevo.cats.{eqv, show}
import derevo.circe.magnolia.{decoder, encoder}
import derevo.derive
import io.estatico.newtype.macros.newtype
import io.circe.refined._
import org.mongodb.scala.bson.annotations.BsonProperty
import eu.timepit.refined.cats._
import derevo.reactivemongo.{bsonDocumentReader, bsonDocumentWriter}

object myObject {

  @derive(decoder, encoder, eqv, show, bsonDocumentReader, bsonDocumentWriter)
  @newtype case class Id(value: String)
  
   @derive(decoder, encoder, eqv, show)
   @newtype case class Name(value: String)
  
  @derive(decoder, encoder, eqv, show)
  case class MyOject(@BsonProperty("_id") id: Id, name: Option[Name])
}

@derive(labeled["foo"]("bar1")) // Any does not take type parameters