scala.language.implicitConversions Scala Examples

package com.qvantel.jsonapi

import scala.language.implicitConversions

import _root_.spray.json._

trait ResourceType[A] {
  def resourceType: String
}

object ResourceType {
  def apply[A](implicit rt: ResourceType[A]): ResourceType[A] = rt

  implicit def apply[A](s: String): ResourceType[A] = new ResourceType[A] {
    override def resourceType: String = s
  }

  implicit def resourceTypeJsonFormat[A](rt: ResourceType[A]): JsonFormat[ResourceType[A]] =
    new JsonFormat[ResourceType[A]] {
      override def write(obj: ResourceType[A]): JsValue = JsString(obj.resourceType)
      override def read(json: JsValue): ResourceType[A] = json match {
        case JsString(s) =>
          new ResourceType[A] {
            override def resourceType: String = s
          }
        case invalid => deserializationError(s"Expected ResourceType as JsString but got ‘$invalid’")
      }
    }
} 

package zio.interop

import cats.effect.ConcurrentEffect
import zio.{ IO, RIO, Runtime, Task, ZIO }

import scala.language.implicitConversions

trait CatsConcurrentEffectSyntax {
  implicit final def ZIOConcurrentEffectOps(@deprecated("", "") zio: ZIO.type): CatsConcurrentEffectSyntax.zioOps.type =
    CatsConcurrentEffectSyntax.zioOps
  implicit final def RIOConcurrentEffectOps(@deprecated("", "") rio: RIO.type): CatsConcurrentEffectSyntax.zioOps.type =
    CatsConcurrentEffectSyntax.zioOps

  implicit final def IOConcurrentEffectOps(@deprecated("", "") io: IO.type): CatsConcurrentEffectSyntax.ioOps.type =
    CatsConcurrentEffectSyntax.ioOps
  implicit final def TaskConcurrentEffectOps(@deprecated("", "") io: Task.type): CatsConcurrentEffectSyntax.ioOps.type =
    CatsConcurrentEffectSyntax.ioOps
}

private[interop] object CatsConcurrentEffectSyntax {
  object zioOps {
    final def concurrentEffect[R]: ZIO[R, Nothing, ConcurrentEffect[RIO[R, *]]] =
      ZIO.runtime.map(catz.taskEffectInstance(_: Runtime[R]))
    final def concurrentEffectWith[R, E, A](f: ConcurrentEffect[RIO[R, *]] => ZIO[R, E, A]): ZIO[R, E, A] =
      ZIO.runtime.flatMap(f apply catz.taskEffectInstance(_: Runtime[R]))
  }
  object ioOps {
    final def concurrentEffect: ZIO[Any, Nothing, ConcurrentEffect[RIO[Any, *]]] =
      ZIO.runtime.map(catz.taskEffectInstance(_: Runtime[Any]))
    def concurrentEffectWith[E, A](f: ConcurrentEffect[RIO[Any, *]] => ZIO[Any, E, A]): ZIO[Any, E, A] =
      ZIO.runtime.flatMap(f apply catz.taskEffectInstance(_: Runtime[Any]))
  }
} 

package org.coursera.courier.sbt

import xsbti.{Severity, Problem, Position}
import java.util.Optional
import sbt._

import scala.language.implicitConversions

object CourierExceptionCompat {

  
  class CourierCompilationException(
      source: Option[File],
      message: String,
      atLine: Option[Int],
      column: Option[Int],
      severity: Severity)
      extends xsbti.CompileFailed
      with FeedbackProvidedException {

    def arguments(): Array[String] = Array()
    def problems(): Array[Problem] =
      Array(new CourierCompilationProblem(source, message, atLine, column, severity))
    def line = atLine.map(_.asInstanceOf[java.lang.Integer]).orNull
    def position = column.map(_.asInstanceOf[java.lang.Integer]).orNull
    def sourceName = source.map(_.getAbsolutePath).orNull
  }

  class CourierCompilationProblem(
      source: Option[File],
      msg: String,
      atLine: Option[Int],
      column: Option[Int],
      svrty: Severity)
      extends Problem {
    def category(): String = "Courier"
    def severity(): Severity = svrty
    def message(): String = msg
    def position(): Position = new CourierCompilationErrorPosition(source, atLine, column)
  }

  class CourierCompilationErrorPosition(
      source: Option[File],
      atLine: Option[Int],
      column: Option[Int])
      extends Position {

    def toMaybe[T](option: Option[T]) =
      option.map { optionValue =>
        optionValue
      }.asJava

    def line(): Optional[Integer] = toMaybe(atLine.map(_.asInstanceOf[java.lang.Integer]))
    def lineContent(): String = ""
    def offset(): Optional[Integer] = toMaybe(column.map(_.asInstanceOf[java.lang.Integer]))
    def pointer(): Optional[Integer] = Optional.empty[java.lang.Integer]
    def pointerSpace(): Optional[String] = Optional.empty[String]
    def sourcePath(): Optional[String] = toMaybe(source.map(_.getAbsolutePath))
    def sourceFile(): Optional[File] = toMaybe(source)
  }
} 

package com.flaminem.flamy.utils.collection.mutable

import com.flaminem.flamy.utils.Named

import scala.collection.generic.CanBuildFrom
import scala.collection.mutable.{Builder, ListBuffer}
import scala.collection.{TraversableLike, mutable}
import scala.language.implicitConversions


class NamedCollection[V <: Named] extends IndexedCollection[String, V] with TraversableLike[V, NamedCollection[V]] {
  override def newBuilder: mutable.Builder[V, NamedCollection[V]] = {
    new ListBuffer[V] mapResult{x => new NamedCollection(x)}
  }

  def this(namedItems: Traversable[V]) = {
    this
    this++=namedItems
  }

  def getIndexOf(value: V): String = value.getName.toLowerCase

}

object NamedCollection {

  def newBuilder[V <: Named](): Builder[V, NamedCollection[V]] = {
    new Builder[V, NamedCollection[V]]() {
      val buffer = new NamedCollection[V]()

      override def +=(elem: V): this.type = {
        buffer += elem
        this
      }

      override def clear(): Unit = {
        buffer.clear()
      }

      override def result(): NamedCollection[V] = {
        buffer
      }
    }
  }

  implicit def canBuildFrom[In <: Named, Out <: Named]: CanBuildFrom[NamedCollection[In], Out, NamedCollection[Out]] = {
    new CanBuildFrom[NamedCollection[In], Out, NamedCollection[Out]]() {
      override def apply(from: NamedCollection[In]): Builder[Out, NamedCollection[Out]] = newBuilder()
      override def apply(): Builder[Out, NamedCollection[Out]] = newBuilder()
    }
  }

} 

package com.flaminem.flamy.model.names

import com.flaminem.flamy.model.exceptions.FlamyException
import org.rogach.scallop.ValueConverter

import scala.collection.TraversableLike
import scala.collection.generic.CanBuildFrom
import scala.language.{higherKinds, implicitConversions}
import scala.reflect.runtime.universe._
import scala.util.{Failure, Success, Try}


  def tryParse(s: String): Try[ItemName] = {
    Try{
      SchemaName.parse(s)
      .orElse{
        TableName.parse(s)
      }
      .orElse{
        TablePartitionName.parse(s)
      }
      .getOrElse {
        throw new IllegalArgumentException("Wrong item name : " + s)
      }
    }
  }

  def tryParse(s: String, allowedTypes: Set[Class[_]]): Try[ItemName] = {
    tryParse(s).flatMap {
      case item if allowedTypes.contains(item.getClass) => Success(item)
      case item =>
        Failure(
          new IllegalArgumentException(
            s"Item $item is a ${item.getClass.getSimpleName}, " +
            s"but only the following item types are allowed: ${allowedTypes.map{_.getSimpleName}.mkString("[", ", ", "]")}"
          )
        )
    }
  }

  implicit def fromStringTraversableLike[T[Z] <: TraversableLike[Z, T[Z]]]
  (l: T[String])(implicit bf: CanBuildFrom[T[String], ItemName, T[ItemName]]) : T[ItemName] = {
    l.map{tryParse(_).get}
  }

  private def fromArgs(args: Seq[String]): Either[String, Option[List[ItemName]]] = {
    val tries: Seq[Try[ItemName]] = args.map{tryParse}
    if(tries.forall{_.isSuccess}){
      Right(Some(tries.map{_.get}.toList))
    }
    else {
      val firstFailureIndex = tries.indexWhere(_.isFailure)
      Left(s"Could not parse the item name ${args(firstFailureIndex)}")
    }
  }

  implicit val scallopConverterList: ValueConverter[List[ItemName]] = {
    new ValueConverter[List[ItemName]] {
      override def parse(s: List[(String, List[String])]): Either[String, Option[List[ItemName]]] = {
        s match {
          case l if l.nonEmpty => fromArgs(l.flatMap{_._2})
          case Nil => Right(None)
        }
      }
      override val tag: TypeTag[List[ItemName]] = typeTag[List[ItemName]]
      override val argType = org.rogach.scallop.ArgType.LIST
    }
  }

} 

package com.flaminem.flamy.model.names

import com.flaminem.flamy.parsing.ParsingUtils
import org.rogach.scallop.ValueConverter

import scala.language.implicitConversions
import scala.reflect.runtime.universe._
import scala.util.matching.Regex


class TableName private (val fullName: String) extends ItemName {
  lazy val schemaName: SchemaName = SchemaName(fullName.split('.')(0))
  lazy val name: String = fullName.split('.')(1)

  def isInSchema(schema: ItemName): Boolean = schema match {
    case s: SchemaName => s.equals(schemaName)
    case default => false
  }
  override def isInOrEqual(that: ItemName): Boolean = that match {
    case name: SchemaName => this.isInSchema(name)
    case name: TableName => name==this
    case _ => false
  }
}

object TableName {

  // TODO: during parsing, table names with wrong names are allowed. We should probably add some safety about that.
  def apply(fullName: String): TableName = {
    new TableName(fullName.toLowerCase)
  }

  def unapply(tableName: TableName): Option[String] = Some(tableName.fullName)

  def apply(schemaName: String, tableName: String): TableName = new TableName(schemaName.toLowerCase + "." + tableName.toLowerCase)

  def apply(schemaName: SchemaName, tableName: String): TableName = new TableName(schemaName.fullName + "." + tableName.toLowerCase)

  implicit val order: Ordering[TableName] = new Ordering[TableName]{
    override def compare(x: TableName, y: TableName): Int = x.fullName.compareTo(y.fullName)
  }

  val t: String = ParsingUtils.t
  val tableRegex: Regex = s"\\A$t[.]$t\\z".r

  def parse(s: String): Option[TableName] = {
    s match {
      case tableRegex() => Some(new TableName(s.toLowerCase))
      case _ => None
    }
  }

  private def fromArg(arg: String): Either[String, Option[TableName]] = {
    val res: Option[TableName] = parse(arg)
    if(res.isDefined){
      Right(Some(res.get))
    }
    else {
      Left("")
    }
  }

  private def fromArgs(args: Seq[String]): Either[String, Option[List[TableName]]] = {
    val tries: Seq[Option[TableName]] = args.map{parse}
    if(tries.forall{_.isDefined}){
      Right(Some(tries.map{_.get}.toList))
    }
    else {
      Left("")
    }
  }

  implicit val scallopConverter: ValueConverter[TableName] = {
    new ValueConverter[TableName] {
      override def parse(s: List[(String, List[String])]): Either[String, Option[TableName]] = {
        s match {
          case l if l.nonEmpty => fromArg(l.flatMap{_._2}.head)
          case Nil => Right(None)
        }
      }
      override val tag: TypeTag[TableName] = typeTag[TableName]
      override val argType = org.rogach.scallop.ArgType.SINGLE
    }
  }

  implicit val scallopConverterList: ValueConverter[List[TableName]] = {
    new ValueConverter[List[TableName]] {
      override def parse(s: List[(String, List[String])]): Either[String, Option[List[TableName]]] = {
        s match {
          case l if l.nonEmpty => fromArgs(l.flatMap{_._2})
          case Nil => Right(None)
        }
      }
      override val tag: TypeTag[List[TableName]] = typeTag[List[TableName]]
      override val argType = org.rogach.scallop.ArgType.LIST
    }
  }

  implicit def fromString(s: String): TableName = TableName(s)

} 

package com.flaminem.flamy.model.names

import com.flaminem.flamy.model.{PartitionColumn, PartitionKey}
import com.flaminem.flamy.parsing.ParsingUtils

import scala.language.{higherKinds, implicitConversions}


class TablePartitionName(val fullName: String) extends ItemName {
  lazy val schemaName: SchemaName = SchemaName(tableFullName.split('.')(0))
  lazy val tableName: TableName = TableName(tableFullName)
  private lazy val tableFullName: String = fullName.split('/')(0)

  lazy val partitionName: String = partColNames.mkString("/")
  lazy val partColNames: Seq[PartitionColumnName] = fullName.split('/').tail.map{PartitionColumnName}

  def partitionKeys: Seq[PartitionKey] = partColNames.map{_.toPartitionKey}

  def partitionColumns: Seq[PartitionColumn] = partColNames.map{_.toPartitionColumn}

  def isInSchema(schema: ItemName): Boolean = schema match {
    case s: SchemaName => s.equals(schemaName)
    case default => false
  }
  def isInTable(schema: ItemName): Boolean = schema match {
    case t: TableName => t.equals(tableName)
    case default => false
  }
  override def isInOrEqual(that: ItemName): Boolean = that match {
    case name: SchemaName => this.isInSchema(name)
    case name: TableName => this.isInTable(name)
    case name: TablePartitionName => name==this
    case _ => false
  }
}

object TablePartitionName {

  def apply(fullName: String): TablePartitionName = {
    parse(fullName).getOrElse{
      throw new IllegalArgumentException(s"$fullName is not a correct TablePartitionName")
    }
  }

  def parse(s: String): Option[TablePartitionName] = {
    val t = ParsingUtils.t
    val tablePartitionRegex = s"\\A($t[.]$t)/(.*)\\z".r
    s match {
      case tablePartitionRegex(tableName, partitionName) =>
        Some(new TablePartitionName(tableName.toLowerCase + "/" + partitionName))
      case _ => None
    }
  }

  def unapply(tablePartitionName: TablePartitionName): Option[String] = Some(tablePartitionName.fullName)

  def apply(tableName: TableName, columnNames: PartitionColumnName*): TablePartitionName = {
    new TablePartitionName(tableName.fullName + "/" + columnNames.mkString("/"))
  }

  def apply(tableName: TableName, columnNames: String): TablePartitionName = {
    new TablePartitionName(tableName.fullName + "/" + columnNames)
  }

  implicit val order: Ordering[TablePartitionName] = new Ordering[TablePartitionName]{
    override def compare(x: TablePartitionName, y: TablePartitionName): Int = x.fullName.compareTo(y.fullName)
  }
} 

package com.flaminem.flamy.model.names

import com.flaminem.flamy.parsing.ParsingUtils

import scala.language.implicitConversions
import scala.util.matching.Regex


class SchemaName private (val fullName: String) extends ItemName {
  def name: String = fullName
  override def isInOrEqual(that: ItemName): Boolean = that match {
    case name: SchemaName => name==this
    case _ => false
  }
}
object SchemaName {

  def apply(fullName: String): SchemaName = {
    parse(fullName).getOrElse{
      throw new IllegalArgumentException(
        s"$fullName is not a valid name for schemas. Valid names only contain alphabet characters, numbers and _."
      )
    }
  }

  val t: String = ParsingUtils.t
  val schemaRegex: Regex = s"\\A$t\\z".r

  def parse(s: String): Option[SchemaName] = {
    s match {
      case schemaRegex() => Some(new SchemaName(s))
      case _ => None
    }
  }

  def unapply(schemaName: SchemaName): Option[String] = Some(schemaName.fullName)

  implicit val order: Ordering[SchemaName] = new Ordering[SchemaName]{
    override def compare(x: SchemaName, y: SchemaName): Int = x.fullName.compareTo(y.fullName)
  }

  implicit def toString(schema: SchemaName): String = schema.fullName

} 

package com.flaminem.flamy.parsing.model

import com.flaminem.flamy.model.TableInfo
import com.flaminem.flamy.model.collection.immutable.MergeableTableInfoCollection
import com.flaminem.flamy.model.names.TableName
import com.flaminem.flamy.utils.collection.mutable.MergeableIndexedCollection

import scala.language.implicitConversions


class MergeableTableDependencyCollection()
  extends MergeableIndexedCollection[TableName, TableDependency] {

  def this(tableDependencies: Seq[TableDependency]){
    this
    this ++= tableDependencies
  }

  def toTableDependencyCollection: TableDependencyCollection = {
    new TableDependencyCollection(this)
  }

  def toTableInfoCollection: MergeableTableInfoCollection = {
    MergeableTableInfoCollection(getAllValues.map{TableInfo(_)}.toSeq:_*)
  }

  override def getIndexOf(value: TableDependency): TableName = {
    value.fullName
  }

}

object MergeableTableDependencyCollection {
  implicit class MergeableTableDependencyCollectionConvertible(s: Seq[TableDependency]) {
    def toMergeableTableDependencyCollection: MergeableTableDependencyCollection = {
      new MergeableTableDependencyCollection(s)
    }
  }
} 

package com.flaminem.flamy.parsing.model

import scala.language.implicitConversions
import scala.reflect.ClassTag


        case y : T => pf.isDefinedAt(y)
        case _ => false
      }
    }

    override def apply(x: Clause): Clause = {
      pf.apply(x.asInstanceOf[T])
    }

  }

  object Rule {

    def apply[T <: Clause: ClassTag](pf: PartialFunction[T, Clause]): Rule[T] = new Rule(pf)

  }

//  type Rule = PartialFunction[Clause, Clause]

  import com.flaminem.flamy.parsing.model.Clause._

  val simpleRules: Seq[Rule[Clause]] = Seq(
    Rule[And]{
      case _ And False => False
      case False And _ => False
      case Maybe And _ => Maybe
      case _ And Maybe => Maybe
      case True And True => True
    },
    Rule[Or]{
      case _ Or True => True
      case True Or _ => True
      case Maybe Or _ => Maybe
      case _ Or Maybe => Maybe
    },
    Rule[Not]{
      case Not(False) => True
      case Not(True) => False
      case Not(Maybe) => Maybe
    }
  )

  implicit def rulesApplier(rules: Seq[Rule[Clause]]): PartialFunction[Clause, Clause] = {
    case clause: Clause =>
      rules.foldLeft(clause) {
        case (c, rule) if rule.isDefinedAt(c) => rule.apply(c)
        case (c, _) => c
      }
  }

} 

package com.flaminem.flamy.model

import com.flaminem.flamy.model.names.{ItemName, SchemaName, TableName, TablePartitionName}
import org.scalatest.FunSpec

import scala.language.implicitConversions


class ItemNameTest extends FunSpec {


  describe("a SchemaName") {
    it("should be recognised from a String"){
      assert(ItemName("db").isInstanceOf[SchemaName])
    }
    it("should not recognize incorrect Strings"){
      intercept[Exception]{ItemName("db.table").asInstanceOf[SchemaName]}
      intercept[Exception]{ItemName("col = true").asInstanceOf[SchemaName]}
    }
    it("should have correct attributes"){
      val schemaName = ItemName("db").asInstanceOf[SchemaName]
      assert(schemaName.name === "db")
      assert(schemaName.fullName === "db")
    }
    it("should have correct membership methods"){
      val schemaName = ItemName("db").asInstanceOf[SchemaName]
      assert(schemaName.isInOrEqual("db"))
      assert(!schemaName.isInOrEqual("db.table"))
      assert(!schemaName.isInOrEqual("db.table/part1=val1/part2=val2"))
      assert(!schemaName.isInOrEqual("toto"))
      assert(!schemaName.isInOrEqual("db.toto"))
      assert(!schemaName.isInOrEqual("db.table/part1=val1/part2=toto"))
    }
  }


  describe("a TableName") {
    val name = "db.table"
    it("should be recognised from a String") {
      val itemName = ItemName(name)
      assert(itemName.isInstanceOf[TableName])
    }
    it("should have correct attributes"){
      val tableName = ItemName(name).asInstanceOf[TableName]
      assert(tableName.name === "table")
      assert(tableName.schemaName.name === "db")
      assert(tableName.fullName === "db.table")
    }
    it("should have correct membership methods"){
      val tableName = ItemName(name).asInstanceOf[TableName]
      assert(tableName.isInSchema("db"))
      assert(!tableName.isInSchema("toto"))
      assert(tableName.isInOrEqual("db"))
      assert(tableName.isInOrEqual("db.table"))
      assert(!tableName.isInOrEqual("db.table/part1=val1/part2=val2"))
      assert(!tableName.isInOrEqual("toto"))
      assert(!tableName.isInOrEqual("db.toto"))
      assert(!tableName.isInOrEqual("db.table/part1=val1/part2=toto"))
    }
  }


  describe("a TablePartitionName") {
    val name = "db.table/part1=val1/part2=val2"
    it("should be recognised from a String"){
      val itemName = ItemName(name)
      assert(itemName.isInstanceOf[TablePartitionName])
    }
    it("should have correct attributes"){
      val partitionName = ItemName(name).asInstanceOf[TablePartitionName]
      assert(partitionName.tableName.fullName=== "db.table")
      assert(partitionName.tableName.name === "table")
      assert(partitionName.schemaName.name === "db")
      assert(partitionName.partitionName === "part1=val1/part2=val2")
    }
    it("should have correct membership methods"){
      val partitionName = ItemName(name).asInstanceOf[TablePartitionName]
      assert(partitionName.isInSchema("db"))
      assert(!partitionName.isInSchema("toto"))
      assert(partitionName.isInTable("db.table"))
      assert(!partitionName.isInTable("db"))
      assert(!partitionName.isInTable("db.toto"))
      assert(!partitionName.isInTable("toto.table"))
      assert(partitionName.isInOrEqual("db"))
      assert(partitionName.isInOrEqual("db.table"))
      assert(partitionName.isInOrEqual("db.table/part1=val1/part2=val2"))
      assert(!partitionName.isInOrEqual("toto"))
      assert(!partitionName.isInOrEqual("db.toto"))
      assert(!partitionName.isInOrEqual("db.table/part1=val1/part2=toto"))
    }
  }



  } 

package com.rallyhealth.sbt.versioning

import scala.language.implicitConversions


  override def compare(that: SemVerIdentifierList): Int = {
    val thisIdentifiers = values.sorted
    val thatIdentifiers = that.values.sorted

    if (thisIdentifiers.isEmpty && thatIdentifiers.isEmpty) {
      0
      // an empty list of identifiers is considered GREATER than a non-empty list, see http://semver.org/#spec-item-11
    } else if (thisIdentifiers.isEmpty) {
      1
      // an empty list of identifiers is considered GREATER than a non-empty list, see http://semver.org/#spec-item-11
    } else if (thatIdentifiers.isEmpty) {
      -1
    } else {
      thisIdentifiers.zipAll(thatIdentifiers, SemVerIdentifier.Empty, SemVerIdentifier.Empty).foldLeft(0) {
        case (result, _) if result != 0 => result
        case (_, (a, b)) => a.compare(b)
      }
    }
  }

  def :+(other: SemVerIdentifier): SemVerIdentifierList = SemVerIdentifierList(values :+ other)

  def ++(other: SemVerIdentifierList): SemVerIdentifierList = SemVerIdentifierList(values ++ other.values)

  def ++(other: Seq[SemVerIdentifier]): SemVerIdentifierList = SemVerIdentifierList(values ++ other)

  def ++(other: Option[SemVerIdentifier]): SemVerIdentifierList = this ++ other.toSeq
}

object SemVerIdentifierList {

  val separatorChar = '-'

  val empty = SemVerIdentifierList(Seq.empty)

  implicit def identifier2IdentifierList(id: SemVerIdentifier): SemVerIdentifierList =
    SemVerIdentifierList(Seq(id))

  implicit def identifierSeq2IdentifierList(values: Seq[SemVerIdentifier]): SemVerIdentifierList =
    SemVerIdentifierList(values)

  implicit def stringIdentifierSeq2IdentifierList(values: Seq[String]): SemVerIdentifierList =
    SemVerIdentifierList(values.map(StringSemVerIdentifier(_)))
} 

package com.rallyhealth.sbt.versioning

import com.rallyhealth.sbt.versioning.LowerBoundedSemanticVersion._
import org.scalatest.{FunSpec, Matchers}

import scala.language.implicitConversions

class LowerBoundedSemanticVersionSpec extends FunSpec with Matchers {

  private val hash1 = HashSemVerIdentifier("0123abc")
  // for these tests we need a full hash, not an abbreviation
  private val hashAndCount1 = HashAndCount(hash1, 1)

  describe("BoundedSemanticVersion") {

    describe("ReleaseVersion") {

      it("equal bound") {
        val version = ReleaseVersion(1, 2, 3, SemVerIdentifierList.empty, isDirty = false)
        val bound = LowerBound(1, 2, 3)
        val result = version.lowerBound(bound, hashAndCount1)
        assert(result === version)
      }

      it("lower bound") {
        val version = ReleaseVersion(1, 2, 3, SemVerIdentifierList.empty, isDirty = false)
        val bound = LowerBound(1, 0, 0)
        val result = version.lowerBound(bound, hashAndCount1)
        assert(result === version)
      }

      it("higher bound") {
        val version = ReleaseVersion(1, 2, 3, SemVerIdentifierList.empty, isDirty = false)
        val bound = LowerBound(1, 2, 4)
        an[IllegalArgumentException] shouldBe thrownBy {
          version.lowerBound(bound, hashAndCount1)
        }
      }
    }

    describe("SnapshotVersion") {

      it("equal bound") {
        val version = SnapshotVersion(1, 2, 3, SemVerIdentifierList.empty, isDirty = false, hashAndCount1, 1)
        val result = version.lowerBound(LowerBound(1, 2, 3), hashAndCount1)
        assert(result === version)
      }

      it("lower bound") {
        val version = SnapshotVersion(1, 2, 3, SemVerIdentifierList.empty, isDirty = false, hashAndCount1, 1)
        val bound = LowerBound(1, 0, 0)
        val result = version.lowerBound(bound, hashAndCount1)
        assert(result === version)
        assert(result.toString === s"1.2.3-1-$hash1-SNAPSHOT")
      }

      it("greater bound") {
        val version = SnapshotVersion(1, 2, 3, SemVerIdentifierList.empty, isDirty = false, hashAndCount1, 1)
        val bound = LowerBound(2, 0, 0)
        val result = version.lowerBound(bound, hashAndCount1)
        assert(result.toString === s"2.0.0-1-$hash1-SNAPSHOT")
      }

      it("version is dirty") {
        val version = SnapshotVersion(1, 2, 3, SemVerIdentifierList.empty, isDirty = true, hashAndCount1, 1)
        val bound = LowerBound(2, 0, 0)
        val result = version.lowerBound(bound, hashAndCount1)
        assert(result.toString === s"2.0.0-1-$hash1-dirty-SNAPSHOT")
      }

      it("bound is dirty") {
        val version = SnapshotVersion(1, 2, 3, SemVerIdentifierList.empty, isDirty = false, hashAndCount1, 1)
        val bound = LowerBound(2, 0, 0)
        val result = version.lowerBound(bound, hashAndCount1)
        assert(result.toString === s"2.0.0-1-$hash1-SNAPSHOT")
      }

      it("identifiers") {
        val version = SnapshotVersion(1, 0, 0, Seq("rc.0"), isDirty = false, hashAndCount1, 1)
        val bound = LowerBound(2, 0, 0)
        val result = version.lowerBound(bound, hashAndCount1)
        assert(result === SnapshotVersion(2, 0, 0, SemVerIdentifierList.empty, false, hashAndCount1, 1))
      }

    }
  }

  implicit def hashAndCountAsHash(hc: HashAndCount): HashSemVerIdentifier = hc.hash
} 

package io.circe.jackson

import cats.instances.AllInstances
import cats.syntax.{ AllSyntax, EitherOps }
import io.circe.Json
import io.circe.testing.{ ArbitraryInstances, EqInstances }
import org.scalatest.flatspec.AnyFlatSpec
import org.scalatestplus.scalacheck.ScalaCheckDrivenPropertyChecks
import org.typelevel.discipline.scalatest.FlatSpecDiscipline
import scala.language.implicitConversions


trait CirceSuite
    extends AnyFlatSpec
    with FlatSpecDiscipline
    with ScalaCheckDrivenPropertyChecks
    with AllInstances
    with AllSyntax
    with ArbitraryInstances
    with EqInstances {

  override def convertToEqualizer[T](left: T): Equalizer[T] =
    sys.error("Intentionally ambiguous implicit for Equalizer")

  implicit def prioritizedCatsSyntaxEither[A, B](eab: Either[A, B]): EitherOps[A, B] = new EitherOps(eab)

  val glossary: Json = Json.obj(
    "glossary" -> Json.obj(
      "title" -> Json.fromString("example glossary"),
      "GlossDiv" -> Json.obj(
        "title" -> Json.fromString("S"),
        "GlossList" -> Json.obj(
          "GlossEntry" -> Json.obj(
            "ID" -> Json.fromString("SGML"),
            "SortAs" -> Json.fromString("SGML"),
            "GlossTerm" -> Json.fromString("Standard Generalized Markup Language"),
            "Acronym" -> Json.fromString("SGML"),
            "Abbrev" -> Json.fromString("ISO 8879:1986"),
            "GlossDef" -> Json.obj(
              "para" -> Json.fromString(
                "A meta-markup language, used to create markup languages such as DocBook."
              ),
              "GlossSeeAlso" -> Json.arr(Json.fromString("GML"), Json.fromString("XML"))
            ),
            "GlossSee" -> Json.fromString("markup")
          )
        )
      )
    )
  )
} 

package edu.neu.coe.csye._7200.enums.enumeration



object Rank extends Enumeration {
   type Rank = Value
   val Deuce, Trey, Four, Five, Six, Seven, Eight, Nine, Ten, Knave, Queen, King, Ace = Value
   class RankValue(rank: Value) {
     def isSpot = !isHonor
     def isHonor = rank match {
       case Ace | King | Queen | Knave | Ten => true
       case _ => false
     }
   }
   implicit def value2RankValue(rank: Value) = new RankValue(rank)
}

object Suit extends Enumeration {
   type Suit = Value
   val Clubs, Diamonds, Hearts, Spades = Value
   class SuitValue(suit: Value) {
      def isRed = !isBlack
      def isBlack = suit match {
         case Clubs | Spades => true
         case _              => false
      }
   }
   implicit def value2SuitValue(suit: Value) = new SuitValue(suit)
} 

import edu.neu.coe.csye._7200.enums.enumeration.Rank._
import edu.neu.coe.csye._7200.enums.enumeration.Suit._

import scala.language.implicitConversions

case class Card (rank: Rank, suit: Suit) 

package highperfscala.free

import scala.language.{higherKinds, implicitConversions, postfixOps}
import scalaz.{-\/, Free, Functor, \/, \/-}

case class LimitMs(value: Long) extends AnyVal

sealed trait Thunk[A]
case class Timed[A](
  whenActive: () => A,
  whenExpired: () => A,
  limit: LimitMs) extends Thunk[A]
case class StartProcessing[A](
  whenActive: BboUpdated => A,
  whenExpired: BboUpdated => A,
  limit: LimitMs) extends Thunk[A]
case class TradingDecision[A](
  makeDecision: TradingStrategy => A) extends Thunk[A]

object Thunk {
  implicit val functor: Functor[Thunk] = new Functor[Thunk] {
    def map[A, B](t: Thunk[A])(f: (A) => B): Thunk[B] = t match {
      case Timed(whenActive, whenExpired, limit) =>
        Timed(() => f(whenActive()), () => f(whenExpired()), limit)
      case StartProcessing(whenActive, whenExpired, limit) =>
        StartProcessing(c => f(whenActive(c)), c => f(whenExpired(c)), limit)
      case TradingDecision(makeDecision) => TradingDecision(
        (makeDecision.apply _).andThen(f))
    }
  }

  def timed[L, R](
    f: () => R,
    exp: () => L,
    limit: LimitMs): Free[Thunk, L \/ R] = Free.liftF(
    Timed(() => \/-(f()), () => -\/(exp()), limit))
  def startProcessing[L, R](
    f: BboUpdated => R,
    exp: BboUpdated => L,
    limit: LimitMs): Free[Thunk, L \/ R] =
    Free.liftF(StartProcessing(f.andThen(\/-(_)), exp.andThen(-\/(_)), limit))
  def tradingDecision[L, R](f: TradingStrategy => R): Free[Thunk, L \/ R] =
    Free.liftF(TradingDecision((f.apply _).andThen(\/-(_))))
} 

package io.orkestra.cluster.management

import akka.http.scaladsl.marshalling.{Marshaller, ToEntityMarshaller}
import akka.http.scaladsl.model.HttpCharsets
import akka.http.scaladsl.model.MediaTypes.`application/json`
import akka.http.scaladsl.unmarshalling.{FromEntityUnmarshaller, Unmarshaller}
import akka.stream.Materializer
import play.api.libs.json._

import scala.concurrent.ExecutionContext
import scala.language.implicitConversions


trait PlayJsonSupport {

  type Printer = (JsValue ⇒ String)

  def read[T](jsValue: JsValue)(implicit reads: Reads[T]): T = {
    reads.reads(jsValue) match {
      case s: JsSuccess[T] ⇒ s.get
      case e: JsError ⇒ throw JsResultException(e.errors)
    }
  }

  implicit def playJsonUnmarshallerConverter[T](reads: Reads[T])(implicit ec: ExecutionContext, mat: Materializer): FromEntityUnmarshaller[T] =
    playJsonUnmarshaller(reads, ec, mat)

  implicit def playJsonUnmarshaller[T](implicit reads: Reads[T], ec: ExecutionContext, mat: Materializer): FromEntityUnmarshaller[T] =
    playJsValueUnmarshaller.map(read[T])

  implicit def playJsValueUnmarshaller(implicit ec: ExecutionContext, mat: Materializer): FromEntityUnmarshaller[JsValue] =
    Unmarshaller.byteStringUnmarshaller.forContentTypes(`application/json`).mapWithCharset { (data, charset) ⇒
      if (charset == HttpCharsets.`UTF-8`) Json.parse(data.toArray)
      else Json.parse(data.decodeString(charset.nioCharset.name)) // FIXME: identify charset by instance, not by name!
    }

  implicit def playJsonMarshallerConverter[T](writes: Writes[T])(implicit printer: Printer = Json.prettyPrint, ec: ExecutionContext): ToEntityMarshaller[T] =
    playJsonMarshaller[T](writes, printer, ec)

  implicit def playJsonMarshaller[T](implicit writes: Writes[T], printer: Printer = Json.prettyPrint, ec: ExecutionContext): ToEntityMarshaller[T] =
    playJsValueMarshaller[T].compose(writes.writes)

  implicit def playJsValueMarshaller[T](implicit writes: Writes[T], printer: Printer = Json.prettyPrint, ec: ExecutionContext): ToEntityMarshaller[JsValue] =
    Marshaller.StringMarshaller.wrap(`application/json`)(printer)
}

object PlayJsonSupport extends PlayJsonSupport