Delete MonadChain

modules/core/src/main/scala-2.12/dev/guardrail/CollectionsSyntax.scala → modules/core/src/main/scala-2.12/dev/guardrail/shims/CollectionsSyntax.scala

@@ -1,4 +1,4 @@
-package dev.guardrail
+package dev.guardrail.shims
 
 import scala.collection.IterableView
 

modules/core/src/main/scala-2.13/dev/guardrail/shims/CollectionsSyntax.scala

@@ -0,0 +1,3 @@
+package dev.guardrail.shims
+
+trait CollectionsSyntax

modules/core/src/main/scala/dev/guardrail/Common.scala

@@ -2,6 +2,7 @@ package dev.guardrail
 
 import _root_.io.swagger.v3.oas.models.OpenAPI
 import io.swagger.v3.oas.models.security.{ SecurityScheme => SwSecurityScheme }
+import cats.Monad
 import cats.data.NonEmptyList
 import cats.syntax.all._
 import cats.Id
@@ -23,7 +24,7 @@ object Common {
   val resolveFile: Path => List[String] => Path            = root => _.foldLeft(root)(_.resolve(_))
   val resolveFileNel: Path => NonEmptyList[String] => Path = root => _.foldLeft(root)(_.resolve(_))
 
-  private[this] def extractSecuritySchemes[L <: LA, F[_]](
+  private[this] def extractSecuritySchemes[L <: LA, F[_]: Monad](
       spec: OpenAPI,
       prefixes: List[String]
   )(implicit Sw: SwaggerTerms[L, F], Sc: LanguageTerms[L, F]): F[Map[String, SecurityScheme[L]]] = {
@@ -51,7 +52,7 @@ object Common {
       .map(_.toMap)
   }
 
-  def prepareDefinitions[L <: LA, F[_]](
+  def prepareDefinitions[L <: LA, F[_]: Monad](
       kind: CodegenTarget,
       context: Context,
       spec: Tracker[OpenAPI],
@@ -139,7 +140,7 @@ object Common {
     } yield (proto, codegen))
   }
 
-  def writePackage[L <: LA, F[_]](proto: ProtocolDefinitions[L], codegen: CodegenDefinitions[L], context: Context)(
+  def writePackage[L <: LA, F[_]: Monad](proto: ProtocolDefinitions[L], codegen: CodegenDefinitions[L], context: Context)(
       outputPath: Path,
       pkgName: List[String],
       dtoPackage: List[String],
@@ -226,7 +227,7 @@ object Common {
     ).toList
   }
 
-  def processArgs[L <: LA, F[_]](
+  def processArgs[L <: LA, F[_]: Monad](
       args: NonEmptyList[Args]
   )(implicit C: CoreTerms[L, F]): F[NonEmptyList[ReadSpec[Target[List[WriteTree]]]]] = {
     import C._
@@ -239,7 +240,7 @@ object Common {
     )
   }
 
-  def runM[L <: LA, F[_]](
+  def runM[L <: LA, F[_]: Monad](
       args: NonEmptyList[Args]
   )(implicit C: CoreTerms[L, F]): F[NonEmptyList[ReadSpec[Target[List[WriteTree]]]]] = {
     import C._

modules/core/src/main/scala/dev/guardrail/core/CoreTermInterp.scala

@@ -2,7 +2,6 @@ package dev.guardrail.core
 
 import cats.data.{ NonEmptyList, State }
 import cats.syntax.all._
-import cats.Monad
 import java.nio.file.Paths
 import scala.util.control.NonFatal
 
@@ -29,8 +28,6 @@ class CoreTermInterp[L <: LA](
     val frameworkMapping: String => Target[Set[String]],
     val handleImport: String => Either[Error, L#Import]
 ) extends CoreTerms[L, Target] { self =>
-  implicit def MonadF: Monad[Target] = Target.targetInstances
-
   def extendWith(
       defaultFramework: String = self.defaultFramework,
       handleModules: Set[String] => Target[Framework[L, Target]] = self.handleModules,

modules/core/src/main/scala/dev/guardrail/core/ResolvedType.scala

@@ -1,9 +1,8 @@
 package dev.guardrail.core
 
-import cats.{ FlatMap, Foldable }
+import cats.{ FlatMap, Foldable, Monad }
 import cats.syntax.all._
 
-import dev.guardrail._
 import dev.guardrail.languages.LA
 import dev.guardrail.terms.protocol._
 import dev.guardrail.terms.{ CollectionsLibTerms, LanguageTerms, SwaggerTerms }
@@ -27,7 +26,7 @@ case class DeferredArray[L <: LA](value: String, containerTpe: Option[L#Type])
 case class DeferredMap[L <: LA](value: String, containerTpe: Option[L#Type])                                                   extends LazyResolvedType[L]
 
 object ResolvedType {
-  def resolveReferences[L <: LA, F[_]](
+  def resolveReferences[L <: LA, F[_]: Monad](
       values: List[(String, ResolvedType[L])]
   )(implicit Sc: LanguageTerms[L, F], Cl: CollectionsLibTerms[L, F], Sw: SwaggerTerms[L, F]): F[List[(String, Resolved[L])]] =
     Sw.log.function("resolveReferences") {
@@ -71,7 +70,7 @@ object ResolvedType {
         }
     }
 
-  def resolve[L <: LA, F[_]](
+  def resolve[L <: LA, F[_]: Monad](
       value: ResolvedType[L],
       protocolElems: List[StrictProtocolElems[L]]
   )(implicit Sc: LanguageTerms[L, F], Cl: CollectionsLibTerms[L, F], Sw: SwaggerTerms[L, F]): F[Resolved[L]] = {

modules/core/src/main/scala/dev/guardrail/core/resolvers/ModelResolver.scala

@@ -7,27 +7,26 @@ import dev.guardrail.core.extract.{ CustomArrayTypeName, CustomMapTypeName, Cust
 import dev.guardrail.terms.{ CollectionsLibTerms, LanguageTerms, SchemaLiteral, SchemaProjection, SchemaRef, SwaggerTerms }
 import dev.guardrail.terms.framework.FrameworkTerms
 
+import cats.Monad
 import cats.syntax.all._
 import io.swagger.v3.oas.models._
 import io.swagger.v3.oas.models.media._
 import scala.jdk.CollectionConverters._
 
 object ModelResolver {
-  def propMeta[L <: LA, F[_]](property: Tracker[Schema[_]], components: Tracker[Option[Components]])(implicit
+  def propMeta[L <: LA, F[_]: Monad](property: Tracker[Schema[_]], components: Tracker[Option[Components]])(implicit
       Sc: LanguageTerms[L, F],
       Cl: CollectionsLibTerms[L, F],
       Sw: SwaggerTerms[L, F],
       Fw: FrameworkTerms[L, F]
-  ): F[core.ResolvedType[L]] = propMetaImpl(property, components)(Left(_))
+  ): F[core.ResolvedType[L]] = propMetaImpl[L, F](property, components)(Left(_))
 
-  def propMetaWithName[L <: LA, F[_]](tpe: L#Type, property: Tracker[Schema[_]], components: Tracker[Option[Components]])(implicit
+  def propMetaWithName[L <: LA, F[_]: Monad](tpe: L#Type, property: Tracker[Schema[_]], components: Tracker[Option[Components]])(implicit
       Sc: LanguageTerms[L, F],
       Cl: CollectionsLibTerms[L, F],
       Sw: SwaggerTerms[L, F],
       Fw: FrameworkTerms[L, F]
-  ): F[core.ResolvedType[L]] = {
-    implicit val M = Sc.MonadF
-
+  ): F[core.ResolvedType[L]] =
     propMetaImpl(property, components)(
       _.refine[core.ResolvedType[L]] { case schema: ObjectSchema if Option(schema.getProperties).exists(p => !p.isEmpty) => schema }(_ =>
         core.Resolved[L](tpe, None, None, ReifiedRawType.unsafeEmpty)
@@ -37,15 +36,14 @@ object ModelResolver {
         )
         .map(_.pure[F])
     )
-  }
 
-  def modelMetaType[L <: LA, F[_]](
+  def modelMetaType[L <: LA, F[_]: Monad](
       model: Tracker[Schema[_]],
       components: Tracker[Option[Components]]
   )(implicit Sc: LanguageTerms[L, F], Cl: CollectionsLibTerms[L, F], Sw: SwaggerTerms[L, F], Fw: FrameworkTerms[L, F]): F[core.ResolvedType[L]] =
     propMetaImpl[L, F](model, components)(Left(_))
 
-  private def propMetaImpl[L <: LA, F[_]](property: Tracker[Schema[_]], components: Tracker[Option[Components]])(
+  private def propMetaImpl[L <: LA, F[_]: Monad](property: Tracker[Schema[_]], components: Tracker[Option[Components]])(
       strategy: Tracker[Schema[_]] => Either[Tracker[Schema[_]], F[core.ResolvedType[L]]]
   )(implicit Sc: LanguageTerms[L, F], Cl: CollectionsLibTerms[L, F], Sw: SwaggerTerms[L, F], Fw: FrameworkTerms[L, F]): F[core.ResolvedType[L]] =
     Sw.log.function("propMeta") {
@@ -54,8 +52,6 @@ object ModelResolver {
       import Cl._
       import Sw._
 
-      implicit val M = Sc.MonadF
-
       for {
         _ <- log.debug(s"property:\n${log.schemaToString(property.unwrapTracker)} (${property.unwrapTracker.getExtensions()}, ${property.showHistory})")
 
@@ -122,7 +118,7 @@ object ModelResolver {
     }
 
   // Standard type conversions, as documented in http://swagger.io/specification/#data-types-12
-  def determineTypeName[L <: LA, F[_]](
+  def determineTypeName[L <: LA, F[_]: Monad](
       rawSchema: Tracker[Schema[_]],
       customType: Tracker[Option[String]],
       components: Tracker[Option[Components]]
@@ -132,8 +128,6 @@ object ModelResolver {
       import Cl._
       import Fw._
 
-      implicit val M = Sc.MonadF
-
       for {
         schemaProjection <- rawSchema
           .downField("$ref", _.get$ref())
@@ -240,14 +234,13 @@ object ModelResolver {
       } yield (result, reifiedRawType)
     }
 
-  private def enrichWithDefault[L <: LA, F[_]](schema: Tracker[Schema[_]])(implicit
+  private def enrichWithDefault[L <: LA, F[_]: Monad](schema: Tracker[Schema[_]])(implicit
       Sc: LanguageTerms[L, F],
       Cl: CollectionsLibTerms[L, F],
       Sw: SwaggerTerms[L, F],
       Fw: FrameworkTerms[L, F]
   ): core.ResolvedType[L] => F[core.ResolvedType[L]] = { resolved =>
     import Sc._
-    implicit val M = Sc.MonadF
     def buildResolve[B: Extractable, A <: Schema[_]: Default.GetDefault](transformLit: B => F[L#Term]): Tracker[A] => F[core.ResolvedType[L]] = { a =>
       for {
         default <- Default(a).extract[B].traverse(transformLit(_))
@@ -263,22 +256,20 @@ object ModelResolver {
       .orRefineFallback(_ => resolved.pure[F])
   }
 
-  private[this] def liftCustomType[L <: LA, F[_]](s: Tracker[String])(implicit Sc: LanguageTerms[L, F]): F[Option[L#Type]] = {
+  private[this] def liftCustomType[L <: LA, F[_]: Monad](s: Tracker[String])(implicit Sc: LanguageTerms[L, F]): F[Option[L#Type]] = {
     import Sc._
-    implicit val M = Sc.MonadF
-    val tpe        = s.map(_.trim)
+    val tpe = s.map(_.trim)
     if (tpe.unwrapTracker.nonEmpty) {
       parseType(tpe)
     } else Option.empty[L#Type].pure[F]
   }
 
-  private def resolveScalarTypes[L <: LA, F[_]](
+  private def resolveScalarTypes[L <: LA, F[_]: Monad](
       partial: Either[Tracker[Schema[_]], F[core.ResolvedType[L]]],
       components: Tracker[Option[Components]]
   )(implicit Sc: LanguageTerms[L, F], Cl: CollectionsLibTerms[L, F], Sw: SwaggerTerms[L, F], Fw: FrameworkTerms[L, F]): F[core.ResolvedType[L]] = {
     import Cl._
     import Sw._
-    implicit val M = Sc.MonadF
     def buildResolveNoDefault[A <: Schema[_]]: Tracker[A] => F[core.ResolvedType[L]] = { a =>
       for {
         prefixes       <- vendorPrefixes()

modules/core/src/main/scala/dev/guardrail/generators/LanguageParameter.scala

@@ -1,5 +1,6 @@
 package dev.guardrail.generators
 
+import cats.Monad
 import cats.syntax.all._
 import io.swagger.v3.oas.models.media
 import io.swagger.v3.oas.models.parameters._
@@ -49,7 +50,7 @@ object LanguageParameter {
   def unapply[L <: LA](param: LanguageParameter[L]): Some[(Option[String], L#MethodParameter, L#TermName, RawParameterName, L#Type)] =
     Some((param.in, param.param, param.paramName, param.argName, param.argType))
 
-  def fromParameter[L <: LA, F[_]](
+  def fromParameter[L <: LA, F[_]: Monad](
       protocolElems: List[StrictProtocolElems[L]],
       components: Tracker[Option[Components]]
   )(implicit
@@ -181,7 +182,7 @@ object LanguageParameter {
     )
   }
 
-  def fromParameters[L <: LA, F[_]](
+  def fromParameters[L <: LA, F[_]: Monad](
       protocolElems: List[StrictProtocolElems[L]],
       components: Tracker[Option[Components]]
   )(implicit

modules/core/src/main/scala/dev/guardrail/generators/SwaggerGenerator.scala

@@ -1,6 +1,5 @@
 package dev.guardrail.generators
 
-import cats.Monad
 import cats.syntax.all._
 import io.swagger.v3.oas.models.Components
 import io.swagger.v3.oas.models.Operation
@@ -30,8 +29,6 @@ object SwaggerGenerator {
 }
 
 class SwaggerGenerator[L <: LA] extends SwaggerTerms[L, Target] {
-  override def MonadF: Monad[Target] = Target.targetInstances
-
   private def splitOperationParts(operationId: String): (List[String], String) = {
     val parts = operationId.split('.')
     (parts.drop(1).toList, parts.last)

modules/core/src/main/scala/dev/guardrail/package.scala

@@ -1,37 +1,3 @@
 package dev
 
-import cats.Monad
-import dev.guardrail.languages.LA
-import dev.guardrail.terms.client.ClientTerms
-import dev.guardrail.terms.server.ServerTerms
-import dev.guardrail.terms.framework.FrameworkTerms
-import dev.guardrail.terms.{ CollectionsLibTerms, CoreTerms, LanguageTerms, ProtocolTerms, SwaggerTerms }
-
-package guardrail {
-  trait MonadChain8 {
-    implicit def monadForCollectionsLib[L <: LA, F[_]](implicit ev: CollectionsLibTerms[L, F]): Monad[F] = ev.MonadF
-  }
-  trait MonadChain7 extends MonadChain8 {
-    implicit def monadForProtocolTerms[L <: LA, F[_]](implicit ev: ProtocolTerms[L, F]): Monad[F] = ev.MonadF
-  }
-  trait MonadChain6 extends MonadChain7 {
-    implicit def monadForServerTerms[L <: LA, F[_]](implicit ev: ServerTerms[L, F]): Monad[F] = ev.MonadF
-  }
-  trait MonadChain5 extends MonadChain6 {
-    implicit def monadForFrameworkTerms[L <: LA, F[_]](implicit ev: FrameworkTerms[L, F]): Monad[F] = ev.MonadF
-  }
-  trait MonadChain4 extends MonadChain5 {
-    implicit def monadForSwagger[L <: LA, F[_]](implicit ev: SwaggerTerms[L, F]): Monad[F] = ev.MonadF
-  }
-  trait MonadChain3 extends MonadChain4 {
-    implicit def monadForLanguage[L <: LA, F[_]](implicit ev: LanguageTerms[L, F]): Monad[F] = ev.MonadF
-  }
-  trait MonadChain2 extends MonadChain3 {
-    implicit def monadForCore[L <: LA, F[_]](implicit ev: CoreTerms[L, F]): Monad[F] = ev.MonadF
-  }
-  trait MonadChain1 extends MonadChain2 {
-    implicit def monadForClient[L <: LA, F[_]](implicit ev: ClientTerms[L, F]): Monad[F] = ev.MonadF
-  }
-}
-
-package object guardrail extends MonadChain1 with CollectionsSyntax
+package object guardrail extends shims.CollectionsSyntax

modules/core/src/main/scala/dev/guardrail/terms/CollectionsLibTerms.scala

@@ -1,12 +1,9 @@
 package dev.guardrail.terms
 
-import cats.Monad
 import dev.guardrail.core.LazyResolvedType
 import dev.guardrail.languages.LA
 
 abstract class CollectionsLibTerms[L <: LA, F[_]] { self =>
-  def MonadF: Monad[F]
-
   def vendorPrefixes(): F[List[String]]
 
   def liftOptionalType(value: L#Type): F[L#Type]
@@ -25,7 +22,6 @@ abstract class CollectionsLibTerms[L <: LA, F[_]] { self =>
   def embedMap(tpe: LazyResolvedType[L], customTpe: Option[L#Type]): F[LazyResolvedType[L]]
 
   def copy(
-      MonadF: Monad[F] = self.MonadF,
       vendorPrefixes: () => F[List[String]] = self.vendorPrefixes _,
       liftOptionalType: L#Type => F[L#Type] = self.liftOptionalType,
       liftOptionalTerm: L#Term => F[L#Term] = self.liftOptionalTerm,
@@ -40,8 +36,6 @@ abstract class CollectionsLibTerms[L <: LA, F[_]] { self =>
       emptyMap: () => F[L#Term] = self.emptyMap _,
       embedMap: (LazyResolvedType[L], Option[L#Type]) => F[LazyResolvedType[L]] = self.embedMap
   ): CollectionsLibTerms[L, F] = {
-
-    val newMonadF            = MonadF
     val newVendorPrefixes    = vendorPrefixes
     val newLiftOptionalType  = liftOptionalType
     val newLiftOptionalTerm  = liftOptionalTerm
@@ -57,7 +51,6 @@ abstract class CollectionsLibTerms[L <: LA, F[_]] { self =>
     val newEmbedMap          = embedMap
 
     new CollectionsLibTerms[L, F] {
-      def MonadF: Monad[F]                                                = newMonadF
       def vendorPrefixes()                                                = newVendorPrefixes()
       def liftOptionalType(value: L#Type)                                 = newLiftOptionalType(value)
       def liftOptionalTerm(value: L#Term)                                 = newLiftOptionalTerm(value)

modules/core/src/main/scala/dev/guardrail/terms/CoreTerms.scala

@@ -1,32 +1,27 @@
 package dev.guardrail.terms
 
-import cats.Monad
 import cats.data.NonEmptyList
 import dev.guardrail._
 import dev.guardrail.languages.LA
 import dev.guardrail.generators.Framework
 
 abstract class CoreTerms[L <: LA, F[_]] { self =>
-  def MonadF: Monad[F]
   def getDefaultFramework: F[Option[String]]
   def extractGenerator(context: Context, defaultFramework: Option[String]): F[Framework[L, Target]]
   def validateArgs(parsed: List[Args]): F[NonEmptyList[Args]]
   def processArgSet(targetInterpreter: Framework[L, Target])(args: Args): F[ReadSpec[Target[List[WriteTree]]]]
   def copy(
-      MonadF: Monad[F] = self.MonadF,
       getDefaultFramework: F[Option[String]] = self.getDefaultFramework,
       extractGenerator: (Context, Option[String]) => F[Framework[L, Target]] = self.extractGenerator _,
       validateArgs: List[Args] => F[NonEmptyList[Args]] = self.validateArgs _,
       processArgSet: Framework[L, Target] => Args => F[ReadSpec[Target[List[WriteTree]]]] = self.processArgSet _
   ) = {
-    val newMonadF              = MonadF
     val newGetDefaultFramework = getDefaultFramework
     val newExtractGenerator    = extractGenerator
     val newValidateArgs        = validateArgs
     val newProcessArgSet       = processArgSet
 
     new CoreTerms[L, F] {
-      def MonadF                                                               = newMonadF
       def getDefaultFramework                                                  = newGetDefaultFramework
       def extractGenerator(context: Context, defaultFramework: Option[String]) = newExtractGenerator(context, defaultFramework)
       def validateArgs(parsed: List[Args])                                     = newValidateArgs(parsed)