sangria-graphql/sangria

Thanks @kamisama-rney - i think I understand that much, with the exception of how the implicit keyword actually works. Example: a lazy val is a different object than a val, but implicit is just a flag. Minimal example:

trait CartTypes {
  val itemType: ObjectType[RequestServices, Item]
  lazy val cartType: ObjectType[Unit, Cart] = ObjectType[RequestServices, Cart](
  /* ... */
    fields = Field(
      "items",
      ListType(ItemType),
      resolve = c => c.ctx.getItems(c.value.id)
    )
  )
}

trait ItemTypes {
  implicit val cartType: ObjectType[RequestServices, ShoppingCart]
  lazy val itemType =  deriveObjectType[RequestServices, Item]()
}

case class Schema()(implicit val ec: ExecutionContextExecutor) extends CartTypes with ItemTypes {
  val QueryType = ObjectType(
    "Query",
    fields[RequestServices, Unit]( /* the types are used */ )
  )
}

My impression from the above is that

• For CartTypes and ItemTypes, the lazy vals are due to interdependence on each other
• val itemType: ObjectType[RequestServices, Item] means the member is necessary to be implemented in the concrete Schema implementation (straightforward)
• implicit val cartType: ObjectType[RequestServices, ShoppingCart]does the same but adds an additional flag to the compiler to make this val available within the deriveObjectType macro. This is because we don't refer to it directly as with an ObjectType literal. The ItemTypes is allowed to make its implemented cartType implicit.

Is this all correct? I think part of my confusion was on lazy vs implicit and when the name bound to the variable needs to match (vs just the type). I realize some of this is just scala basics :/