non-orphan implicit typeclasses

build.sbt

@@ -822,7 +822,8 @@ lazy val example = projectMatrix
       (ThisBuild / baseDirectory).value / "sampleSpecs" / "mixins.smithy",
       (ThisBuild / baseDirectory).value / "sampleSpecs" / "defaults.smithy",
       (ThisBuild / baseDirectory).value / "sampleSpecs" / "quoted_string.smithy",
-      (ThisBuild / baseDirectory).value / "sampleSpecs" / "numeric.smithy"
+      (ThisBuild / baseDirectory).value / "sampleSpecs" / "numeric.smithy",
+      (ThisBuild / baseDirectory).value / "sampleSpecs" / "typeclass.smithy"
     ),
     Compile / resourceDirectory := (ThisBuild / baseDirectory).value / "modules" / "example" / "resources",
     libraryDependencies += Dependencies.Http4s.emberServer.value,

modules/codegen/src/smithy4s/codegen/internals/IR.scala

@@ -280,6 +280,8 @@ private[internals] object Hint {
     case object IndexedSeq extends SpecializedList
   }
   case object UniqueItems extends Hint
+  case class Typeclass(id: ShapeId, targetType: String, interpreter: String)
+  case class Typeclasses(values: NonEmptyList[Typeclass]) extends Hint
 
   implicit val eq: Eq[Hint] = Eq.fromUniversalEquals
 }

modules/codegen/src/smithy4s/codegen/internals/Renderer.scala

@@ -501,6 +501,24 @@ private[internals] class Renderer(compilationUnit: CompilationUnit) { self =>
     }
   }
 
+  private def renderTypeclass(hint: Hint.Typeclass, tpe: NameRef): Line = {
+    val target = NameRef(hint.targetType)
+    val interpreter = NameRef(hint.interpreter)
+    val lowerCasedName = s"${tpe.name.head.toLower.toString}${tpe.name.tail}"
+    line"implicit val $lowerCasedName${hint.id.getName.capitalize}: $target[$tpe] = $interpreter.fromSchema(schema)"
+  }
+
+  private def renderTypeclasses(
+      hints: List[Hint],
+      tpe: NameRef
+  ): Option[Lines] = {
+    (hints.collectFirst { case h: Hint.Typeclasses =>
+      newline ++ Lines(
+        h.values.map(renderTypeclass(_, tpe)).toList
+      )
+    })
+  }
+
   private def renderProductNonMixin(
       product: Product,
       adtParent: Option[NameRef],
@@ -591,6 +609,7 @@ private[internals] class Renderer(compilationUnit: CompilationUnit) { self =>
         } else {
           line"implicit val schema: $Schema_[${product.nameRef}] = $constant_(${product.nameRef}()).withId(id).addHints(hints)"
         },
+        renderTypeclasses(product.hints, product.nameRef),
         additionalLines
       )
     )
@@ -842,7 +861,8 @@ private[internals] class Renderer(compilationUnit: CompilationUnit) { self =>
               if (error) "" else ".withId(id).addHints(hints)"
             )
             .appendToLast(if (recursive) ")" else "")
-        }
+        },
+        renderTypeclasses(hints, name)
       )
     )
   }
@@ -914,7 +934,8 @@ private[internals] class Renderer(compilationUnit: CompilationUnit) { self =>
       line"val values: $list[$name] = $list".args(
         values.map(_.name)
       ),
-      line"implicit val schema: $Schema_[$name] = $enumeration_(values).withId(id).addHints(hints)"
+      line"implicit val schema: $Schema_[$name] = $enumeration_(values).withId(id).addHints(hints)",
+      renderTypeclasses(hints, name)
     )
   )
 
@@ -940,7 +961,8 @@ private[internals] class Renderer(compilationUnit: CompilationUnit) { self =>
         line"val underlyingSchema: $Schema_[$tpe] = ${tpe.schemaRef}$trailingCalls",
         lines(
           line"implicit val schema: $Schema_[$name] = $definition$bijection_(underlyingSchema, asBijection)$closing"
-        )
+        ),
+        renderTypeclasses(hints, name)
       )
     )
   }

modules/codegen/src/smithy4s/codegen/internals/SmithyToIR.scala

@@ -38,6 +38,7 @@ import scala.annotation.nowarn
 import scala.jdk.CollectionConverters._
 
 import Type.Alias
+import smithy4s.meta.TypeclassTrait
 
 private[codegen] object SmithyToIR {
 
@@ -810,6 +811,29 @@ private[codegen] class SmithyToIR(model: Model, namespace: String) {
     }
   }
 
+  def maybeTypeclassesHint(shape: Shape): Option[Hint.Typeclasses] = {
+    val result =
+      shape
+        .getAllTraits()
+        .asScala
+        .flatMap { case (_, trt) =>
+          model
+            .getShape(trt.toShapeId)
+            .asScala
+            .flatMap(_.getTrait(classOf[TypeclassTrait]).asScala)
+            .map(trt -> _)
+        }
+        .map { case (typeclassName, typeclassInfo) =>
+          Hint.Typeclass(
+            typeclassName.toShapeId,
+            typeclassInfo.getTargetType,
+            typeclassInfo.getInterpreter
+          )
+        }
+        .toList
+    result.toNel.map(Hint.Typeclasses)
+  }
+
   @annotation.nowarn(
     "msg=class UniqueItemsTrait in package traits is deprecated"
   )
@@ -897,7 +921,8 @@ private[codegen] class SmithyToIR(model: Model, namespace: String) {
     }
     traits.collect(traitToHint(shape)) ++
       documentationHint(shape) ++
-      nonConstraintNonMetaTraits.map(unfoldTrait)
+      nonConstraintNonMetaTraits.map(unfoldTrait) ++
+      maybeTypeclassesHint(shape)
   }
 
   case class AltInfo(name: String, tpe: Type, isAdtMember: Boolean)

modules/docs/markdown/04-codegen/01-customisation/09-typeclass.md

@@ -0,0 +1,69 @@
+---
+sidebar_label: Typeclass Instances
+title: Non-Orphan Typeclass Instances
+---
+
+As of smithy4s version `0.18.x` you are able to create custom typeclass instances inside the companion objects of classes in the code generated by smithy4s. This allows you to have instances that are found via implicit resolution without any need to special imports. Common examples where this will come in handy are for the `cats.Show` and `cats.Eq` typeclasses, but you can use this feature for any typeclass.
+
+Here we will show an example using the `cats.Eq` typeclass.
+
+## Setup Typeclass in Smithy
+
+Here we will use the `smithy4s.meta#typeclass` trait to define an `eq` trait that represents the `cats.Eq` typeclass.
+
+```smithy
+use smithy4s.meta#typeclass
+
+@trait
+@typeclass(targetType: "cats.Eq", interpreter: "smithy4s.example.typeclass.EqInterpreter")
+structure eq {}
+```
+
+We are specifying `cats.Eq` as the `targetType` since that is the typeclass which this trait represents. We are then specifying `smithy4s.example.typeclass.EqInterpreter` as the classpath which points to a `CachedSchemaCompiler` for the `cats.Eq` typeclass.
+
+## Implement CachedSchemaCompiler
+
+Smithy4s has a concept called `CachedSchemaCompiler` which is an abstraction which we use here to interpret a `smithy4s.Schema` to produce an instance of a typeclass. Here is what this will look like:
+
+```scala
+object EqInterpreter extends CachedSchemaCompiler.Impl[Eq] {
+
+  protected type Aux[A] = Eq[A]
+
+  def fromSchema[A](
+      schema: Schema[A],
+      cache: Cache
+  ): Eq[A] = {
+      schema.compile(new EqSchemaVisitor(cache))
+  }
+
+}
+```
+
+Here we are delegating to the `EqSchemaVisitor` which is doing the heavy lifting of interpreting the `smithy4s.Schema`. The `CachedSchemaCompiler.Impl` provides a `Cache` which we utilize to make sure we are not recompiling the same schema more than once. For more details on implementing a `SchemaVisitor`, you can check out the full `cats.Eq` schema compiler and visitor [here](<!-- TODO ADD LINK ONCE AVAILABLE -->).
+
+## Use the eq typeclass trait
+
+Now we are ready to use the `eq` trait we defined above.
+
+```smithy
+@eq
+structure MovieTheater {
+  name: String
+}
+```
+
+This tells smithy4s to generate an instance of the `Eq` typeclass in the companion object of the `MovieTheater` type and to use the `CachedSchemaCompiler` defined above for the implementation. The generated code will look like:
+
+```scala
+case class MovieTheater(name: Option[String] = None)
+object MovieTheater extends ShapeTag.Companion[MovieTheater] {
+  val id: ShapeId = ShapeId("smithy4s.example", "MovieTheater")
+
+  // ...
+
+  implicit val schema: Schema[MovieTheater] = // ...
+
+  implicit val movieTheaterEq: cats.Eq[MovieTheater] = EqInterpreter.fromSchema(schema)
+}
+```

modules/example/src/smithy4s/example/Eq.scala

@@ -0,0 +1,18 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.schema.Schema.constant
+
+case class Eq()
+object Eq extends ShapeTag.Companion[Eq] {
+  val id: ShapeId = ShapeId("smithy4s.example", "eq")
+
+  val hints: Hints = Hints(
+    smithy.api.Trait(selector = None, structurallyExclusive = None, conflicts = None, breakingChanges = None),
+  )
+
+  implicit val schema: Schema[Eq] = constant(Eq()).withId(id).addHints(hints)
+}

modules/example/src/smithy4s/example/MovieTheater.scala

@@ -0,0 +1,26 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.example.typeclass.EqInterpreter
+import smithy4s.schema.Schema.string
+import smithy4s.schema.Schema.struct
+
+case class MovieTheater(name: Option[String] = None)
+object MovieTheater extends ShapeTag.Companion[MovieTheater] {
+  val id: ShapeId = ShapeId("smithy4s.example", "MovieTheater")
+
+  val hints: Hints = Hints(
+    smithy4s.example.Eq(),
+  )
+
+  implicit val schema: Schema[MovieTheater] = struct(
+    string.optional[MovieTheater]("name", _.name),
+  ){
+    MovieTheater.apply
+  }.withId(id).addHints(hints)
+
+  implicit val movieTheaterEq: cats.Eq[MovieTheater] = EqInterpreter.fromSchema(schema)
+}

modules/example/src/smithy4s/example/NetworkConnectionType.scala

@@ -0,0 +1,37 @@
+package smithy4s.example
+
+import smithy4s.Enumeration
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.example.typeclass.EqInterpreter
+import smithy4s.schema.Schema.enumeration
+
+sealed abstract class NetworkConnectionType(_value: String, _name: String, _intValue: Int, _hints: Hints) extends Enumeration.Value {
+  override type EnumType = NetworkConnectionType
+  override val value: String = _value
+  override val name: String = _name
+  override val intValue: Int = _intValue
+  override val hints: Hints = _hints
+  override def enumeration: Enumeration[EnumType] = NetworkConnectionType
+  @inline final def widen: NetworkConnectionType = this
+}
+object NetworkConnectionType extends Enumeration[NetworkConnectionType] with ShapeTag.Companion[NetworkConnectionType] {
+  val id: ShapeId = ShapeId("smithy4s.example", "NetworkConnectionType")
+
+  val hints: Hints = Hints(
+    smithy4s.example.Eq(),
+  )
+
+  case object ETHERNET extends NetworkConnectionType("ETHERNET", "ETHERNET", 0, Hints())
+  case object WIFI extends NetworkConnectionType("WIFI", "WIFI", 1, Hints())
+
+  val values: List[NetworkConnectionType] = List(
+    ETHERNET,
+    WIFI,
+  )
+  implicit val schema: Schema[NetworkConnectionType] = enumeration(values).withId(id).addHints(hints)
+
+  implicit val networkConnectionTypeEq: cats.Eq[NetworkConnectionType] = EqInterpreter.fromSchema(schema)
+}

modules/example/src/smithy4s/example/PersonContactInfo.scala

@@ -0,0 +1,44 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.example.typeclass.EqInterpreter
+import smithy4s.schema.Schema.bijection
+import smithy4s.schema.Schema.union
+
+sealed trait PersonContactInfo extends scala.Product with scala.Serializable {
+  @inline final def widen: PersonContactInfo = this
+}
+object PersonContactInfo extends ShapeTag.Companion[PersonContactInfo] {
+  val id: ShapeId = ShapeId("smithy4s.example", "PersonContactInfo")
+
+  val hints: Hints = Hints(
+    smithy4s.example.Eq(),
+  )
+
+  case class EmailCase(email: PersonEmail) extends PersonContactInfo
+  case class PhoneCase(phone: PersonPhoneNumber) extends PersonContactInfo
+
+  object EmailCase {
+    val hints: Hints = Hints.empty
+    val schema: Schema[EmailCase] = bijection(PersonEmail.schema.addHints(hints), EmailCase(_), _.email)
+    val alt = schema.oneOf[PersonContactInfo]("email")
+  }
+  object PhoneCase {
+    val hints: Hints = Hints.empty
+    val schema: Schema[PhoneCase] = bijection(PersonPhoneNumber.schema.addHints(hints), PhoneCase(_), _.phone)
+    val alt = schema.oneOf[PersonContactInfo]("phone")
+  }
+
+  implicit val schema: Schema[PersonContactInfo] = union(
+    EmailCase.alt,
+    PhoneCase.alt,
+  ){
+    case c: EmailCase => EmailCase.alt(c)
+    case c: PhoneCase => PhoneCase.alt(c)
+  }.withId(id).addHints(hints)
+
+  implicit val personContactInfoEq: cats.Eq[PersonContactInfo] = EqInterpreter.fromSchema(schema)
+}

modules/example/src/smithy4s/example/PersonEmail.scala

@@ -0,0 +1,20 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.Newtype
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.example.typeclass.EqInterpreter
+import smithy4s.schema.Schema.bijection
+import smithy4s.schema.Schema.string
+
+object PersonEmail extends Newtype[String] {
+  val id: ShapeId = ShapeId("smithy4s.example", "PersonEmail")
+  val hints: Hints = Hints(
+    smithy4s.example.Eq(),
+  )
+  val underlyingSchema: Schema[String] = string.withId(id).addHints(hints)
+  implicit val schema: Schema[PersonEmail] = bijection(underlyingSchema, asBijection)
+
+  implicit val personEmailEq: cats.Eq[PersonEmail] = EqInterpreter.fromSchema(schema)
+}

modules/example/src/smithy4s/example/PersonPhoneNumber.scala

@@ -0,0 +1,20 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.Newtype
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.example.typeclass.EqInterpreter
+import smithy4s.schema.Schema.bijection
+import smithy4s.schema.Schema.string
+
+object PersonPhoneNumber extends Newtype[String] {
+  val id: ShapeId = ShapeId("smithy4s.example", "PersonPhoneNumber")
+  val hints: Hints = Hints(
+    smithy4s.example.Eq(),
+  )
+  val underlyingSchema: Schema[String] = string.withId(id).addHints(hints)
+  implicit val schema: Schema[PersonPhoneNumber] = bijection(underlyingSchema, asBijection)
+
+  implicit val personPhoneNumberEq: cats.Eq[PersonPhoneNumber] = EqInterpreter.fromSchema(schema)
+}

modules/example/src/smithy4s/example/package.scala

@@ -32,6 +32,7 @@ package object example {
   type ArbitraryData = smithy4s.example.ArbitraryData.Type
   type DogName = smithy4s.example.DogName.Type
   type SomeVector = smithy4s.example.SomeVector.Type
+  type PersonPhoneNumber = smithy4s.example.PersonPhoneNumber.Type
   type FancyList = smithy4s.example.FancyList.Type
   type DefaultStringMap = smithy4s.example.DefaultStringMap.Type
   @deprecated
@@ -40,6 +41,7 @@ package object example {
   @deprecated
   type DeprecatedString = smithy4s.example.DeprecatedString.Type
   type ObjectSize = smithy4s.example.ObjectSize.Type
+  type PersonEmail = smithy4s.example.PersonEmail.Type
   type NonEmptyCandies = smithy4s.example.NonEmptyCandies.Type
   type SomeIndexSeq = smithy4s.example.SomeIndexSeq.Type
   type StringList = smithy4s.example.StringList.Type