Implement (Almost) All The Unicode Caseless Matching Systems

build.sbt

@@ -133,12 +133,15 @@ lazy val bench = project
   .enablePlugins(JmhPlugin)
   .settings(
     name := "case-insensitive-bench",
+    libraryDependencies ++= List(
+      "org.scalacheck" %% "scalacheck" % scalacheckV
+    ),
     console / initialCommands := {
       fullImports(List("cats", "cats.syntax.all", "org.typelevel.ci"), wildcardImport.value)
     },
     consoleQuick / initialCommands := ""
   )
-  .dependsOn(core.jvm)
+  .dependsOn(core.jvm, testing.jvm)
 
 lazy val docs = project
   .in(file("site"))

core/src/main/scala/org/typelevel/ci/CIString.scala

@@ -22,54 +22,30 @@ import java.io.Serializable
 import org.typelevel.ci.compat._
 import scala.math.Ordered
 
-/** A case-insensitive String.
-  *
-  * Two CI strings are equal if and only if they are the same length, and each corresponding
-  * character is equal after calling either `toUpper` or `toLower`.
-  *
-  * Ordering is based on a string comparison after folding each character to uppercase and then back
-  * to lowercase.
-  *
-  * All comparisons are insensitive to locales.
-  *
-  * @param toString
-  *   The original value the CI String was constructed with.
-  */
-final class CIString private (override val toString: String)
+@deprecated(
+  message =
+    "Please use either CIStringCF, CIStringCS, or CIStringS instead. CIString/CIStringS implement Unicode default caseless matching on simple case folded strings. For most applications you probably want to use CIStringCF which implements Unicode canonical caseless matching on full case folded strings.",
+  since = "1.3.0")
+final class CIString private (override val toString: String, val asCIStringS: CIStringS)
     extends Ordered[CIString]
     with Serializable {
+
+  @deprecated(message = "Please provide a CaseFoldedString directly.", since = "1.3.0")
+  private def this(toString: String) =
+    this(toString, CIStringS(toString))
+
   override def equals(that: Any): Boolean =
     that match {
       case that: CIString =>
-        this.toString.equalsIgnoreCase(that.toString)
+        this.asCIStringS == that.asCIStringS
       case _ => false
     }
 
-  @transient private[this] var hash = 0
-  override def hashCode(): Int = {
-    if (hash == 0)
-      hash = calculateHash
-    hash
-  }
-
-  private[this] def calculateHash: Int = {
-    var h = 17
-    var i = 0
-    val len = toString.length
-    while (i < len) {
-      // Strings are equal igoring case if either their uppercase or lowercase
-      // forms are equal. Equality of one does not imply the other, so we need
-      // to go in both directions. A character is not guaranteed to make this
-      // round trip, but it doesn't matter as long as all equal characters
-      // hash the same.
-      h = h * 31 + toString.charAt(i).toUpper.toLower
-      i += 1
-    }
-    h
-  }
+  override def hashCode(): Int =
+    this.asCIStringS.hashCode
 
   override def compare(that: CIString): Int =
-    this.toString.compareToIgnoreCase(that.toString)
+    Order[CIStringS].compare(asCIStringS, that.asCIStringS)
 
   def transform(f: String => String): CIString = CIString(f(toString))
 
@@ -87,8 +63,18 @@ final class CIString private (override val toString: String)
 
 @suppressUnusedImportWarningForCompat
 object CIString {
-  def apply(value: String): CIString = new CIString(value)
 
+  @deprecated(
+    message =
+      "Please use either CIStringCF, CIStringCS, or CIStringS instead. CIString/CIStringS implement Unicode default caseless matching on simple case folded strings. For most applications you probably want to use CIStringCF which implements Unicode canonical caseless matching on full case folded strings.",
+    since = "1.3.0")
+  def apply(value: String): CIString =
+    new CIString(value, CIStringS(value))
+
+  @deprecated(
+    message =
+      "Please use either CIStringCF, CIStringCS, or CIStringS instead. CIString/CIStringS implement Unicode default caseless matching on simple case folded strings. For most applications you probably want to use CIStringCF which implements Unicode canonical caseless matching on full case folded strings.",
+    since = "1.3.0")
   val empty = CIString("")
 
   implicit val catsInstancesForOrgTypelevelCIString: Order[CIString]

core/src/main/scala/org/typelevel/ci/CIStringCF.scala

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2020 Typelevel
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.typelevel.ci
+
+final class CIStringCF private (
+    override val toString: String,
+    val asCanonicalFullCaseFoldedString: CanonicalFullCaseFoldedString)
+    extends Serializable {
+  override def equals(that: Any): Boolean =
+    that match {
+      case that: CIStringCF =>
+        asCanonicalFullCaseFoldedString == that.asCanonicalFullCaseFoldedString
+      case _ =>
+        false
+    }
+
+  override def hashCode(): Int =
+    asCanonicalFullCaseFoldedString.hashCode
+}
+
+object CIStringCF {
+  def apply(value: String): CIStringCF =
+    new CIStringCF(
+      value,
+      CanonicalFullCaseFoldedString(value)
+    )
+}

core/src/main/scala/org/typelevel/ci/CIStringCS.scala

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2020 Typelevel
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.typelevel.ci
+
+import cats._
+import cats.kernel._
+import cats.syntax.all._
+
+final class CIStringCS private (
+    override val toString: String,
+    val asCanonicalSimpleCaseFoldedString: CanonicalSimpleCaseFoldedString)
+    extends Serializable {
+
+  override def equals(that: Any): Boolean =
+    that match {
+      case that: CIStringCS =>
+        asCanonicalSimpleCaseFoldedString == that.asCanonicalSimpleCaseFoldedString
+      case _ =>
+        false
+    }
+
+  override def hashCode(): Int =
+    asCanonicalSimpleCaseFoldedString.hashCode
+}
+
+object CIStringCS {
+
+  def apply(value: String): CIStringCS =
+    new CIStringCS(
+      value,
+      CanonicalSimpleCaseFoldedString(value)
+    )
+
+  val empty: CIStringCS = apply("")
+
+  implicit val hashAndOrderForCIStringCS: Hash[CIStringCS] with Order[CIStringCS] =
+    new Hash[CIStringCS] with Order[CIStringCS] {
+      override def hash(x: CIStringCS): Int =
+        x.hashCode
+
+      override def compare(x: CIStringCS, y: CIStringCS): Int =
+        x.asCanonicalSimpleCaseFoldedString.compare(y.asCanonicalSimpleCaseFoldedString)
+    }
+
+  implicit val orderingForCIStringCS: Ordering[CIStringCS] =
+    hashAndOrderForCIStringCS.toOrdering
+
+  implicit val showForCIStringCS: Show[CIStringCS] =
+    Show.fromToString
+
+  implicit val lowerBoundForCIStringCS: LowerBounded[CIStringCS] =
+    new LowerBounded[CIStringCS] {
+      override val partialOrder: PartialOrder[CIStringCS] =
+        hashAndOrderForCIStringCS
+
+      override val minBound: CIStringCS =
+        empty
+    }
+
+  implicit val monoidForCIStringCS: Monoid[CIStringCS] =
+    new Monoid[CIStringCS] {
+      override val empty: CIStringCS = CIStringCS.empty
+
+      override def combine(x: CIStringCS, y: CIStringCS): CIStringCS =
+        CIStringCS(x.toString + y.toString)
+
+      override def combineAll(xs: IterableOnce[CIStringCS]): CIStringCS = {
+        val sb: StringBuilder = new StringBuilder
+        xs.iterator.foreach(cfs => sb.append(cfs.toString))
+        CIStringCS(sb.toString)
+      }
+    }
+}

core/src/main/scala/org/typelevel/ci/CIStringS.scala

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2020 Typelevel
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.typelevel.ci
+
+import cats._
+import cats.kernel._
+import cats.syntax.all._
+
+final class CIStringS private (
+    override val toString: String,
+    val asSimpleCaseFoldedString: SimpleCaseFoldedString)
+    extends Serializable {
+
+  override def equals(that: Any): Boolean =
+    that match {
+      case that: CIStringS =>
+        asSimpleCaseFoldedString == that.asSimpleCaseFoldedString
+      case _ =>
+        false
+    }
+
+  override def hashCode(): Int =
+    asSimpleCaseFoldedString.hashCode
+}
+
+object CIStringS {
+
+  def apply(value: String): CIStringS =
+    new CIStringS(
+      value,
+      SimpleCaseFoldedString(value)
+    )
+
+  val empty: CIStringS = apply("")
+
+  implicit val hashAndOrderForCIStringS: Hash[CIStringS] with Order[CIStringS] =
+    new Hash[CIStringS] with Order[CIStringS] {
+      override def hash(x: CIStringS): Int =
+        x.hashCode
+
+      override def compare(x: CIStringS, y: CIStringS): Int =
+        x.asSimpleCaseFoldedString.compare(y.asSimpleCaseFoldedString)
+    }
+
+  implicit val orderingForCIStringS: Ordering[CIStringS] =
+    hashAndOrderForCIStringS.toOrdering
+
+  implicit val showForCIStringS: Show[CIStringS] =
+    Show.fromToString
+
+  implicit val lowerBoundForCIStringS: LowerBounded[CIStringS] =
+    new LowerBounded[CIStringS] {
+      override val partialOrder: PartialOrder[CIStringS] =
+        hashAndOrderForCIStringS
+
+      override val minBound: CIStringS =
+        empty
+    }
+
+  implicit val monoidForCIStringS: Monoid[CIStringS] =
+    new Monoid[CIStringS] {
+      override val empty: CIStringS = CIStringS.empty
+
+      override def combine(x: CIStringS, y: CIStringS): CIStringS =
+        CIStringS(x.toString + y.toString)
+
+      override def combineAll(xs: IterableOnce[CIStringS]): CIStringS = {
+        val sb: StringBuilder = new StringBuilder
+        xs.iterator.foreach(cfs => sb.append(cfs.toString))
+        CIStringS(sb.toString)
+      }
+    }
+}

core/src/main/scala/org/typelevel/ci/CanonicalFullCaseFoldedString.scala

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2020 Typelevel
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.typelevel.ci
+
+import java.text.Normalizer
+import scala.annotation.tailrec
+
+final case class CanonicalFullCaseFoldedString private (override val toString: String)
+    extends AnyVal
+
+object CanonicalFullCaseFoldedString {
+  def apply(value: String): CanonicalFullCaseFoldedString =
+    new CanonicalFullCaseFoldedString(
+      Normalizer.normalize(
+        if (Normalizer.isNormalized(value, Normalizer.Form.NFD)) {
+          CaseFolding.fullCaseFoldString(value)
+        } else {
+          CaseFolding.fullCaseFoldString(Normalizer.normalize(value, Normalizer.Form.NFD))
+        },
+        Normalizer.Form.NFD
+      )
+    )
+
+  val empty: CanonicalFullCaseFoldedString =
+    apply("")
+}