Method injection (enrich my library) 

If we were to write a function that sums two types using the Monoid, we need to call it like this.

scala> def plus[A: Monoid](a: A, b: A): A = implicitly[Monoid[A]].mappend(a, b)
plus: [A](a: A, b: A)(implicit evidence$1: Monoid[A])A

scala> plus(3, 4)
res15: Int = 7

We would like to provide an operator. But we don’t want to enrich just one type, but enrich all types that has an instance for Monoid. Let me do this in Cats style using Simulacrum.

scala> import simulacrum._
import simulacrum._

scala> :paste
// Entering paste mode (ctrl-D to finish)
@typeclass trait Monoid[A] {
  @op("|+|") def mappend(a: A, b: A): A
  def mzero: A
}
object Monoid {
  // "ops" gets generated
  val syntax = ops
  implicit val IntMonoid: Monoid[Int] = new Monoid[Int] {
    def mappend(a: Int, b: Int): Int = a + b
    def mzero: Int = 0
  }
  implicit val StringMonoid: Monoid[String] = new Monoid[String] {
    def mappend(a: String, b: String): String = a + b
    def mzero: String = ""
  }
}

// Exiting paste mode, now interpreting.

defined trait Monoid
defined object Monoid

scala> import Monoid.syntax._
import Monoid.syntax._

scala> 3 |+| 4
res0: Int = 7

scala> "a" |+| "b"
res1: String = ab

We were able to inject |+| to both Int and String with just one definition.

Operator syntax for the standard datatypes 

Using the same technique, Cats occasionally provides method injections for standard library datatypes like Option and Vector:

scala> import cats._, cats.data._, cats.implicits._
import cats._
import cats.data._
import cats.implicits._

scala> 1.some
res2: Option[Int] = Some(1)

scala> 1.some.orEmpty
res3: Int = 1

But most operators in Cats are associated with typeclasses.

I hope you could get some feel on where Cats is coming from.