Code for SCALA-350

build.sbt

@@ -480,6 +480,14 @@ lazy val tapir = (project in file("scala-libraries-standalone/tapir"))
     scalaVersion := scala3Version
   )
 
+lazy val refined = (project in file("scala-libraries-standalone/refined"))
+  .settings(
+    name := "refined",
+    scalaVersion := scalaV,
+    libraryDependencies += "eu.timepit" %% "refined" % "0.11.1",
+    libraryDependencies ++= scalaTestDeps
+  )
+
 val spireVersion = "0.18.0"
 val kafkaVersion = "7.6.1-ce"
 val pureconfigVersion = "0.17.6"

scala-libraries-standalone/refined/src/main/scala/com/baeldung/refined/RefinedIntro.scala

@@ -0,0 +1,77 @@
+package com.baeldung.refined
+
+import eu.timepit.refined._
+import eu.timepit.refined.api.Refined
+import eu.timepit.refined.auto._
+import eu.timepit.refined.numeric._
+import eu.timepit.refined.string._
+import eu.timepit.refined.collection._
+import eu.timepit.refined.char._
+import eu.timepit.refined.boolean._
+import eu.timepit.refined.api.Validate
+
+object RefinedIntro {
+  // val oddNumber: Refined[Int, Odd] = 8
+  // val oddNumber: Int Refined Odd = 8
+
+  val age: Int Refined Less[35] = 30
+  val ageInterval: Int Refined Interval.Closed[30, 35] = 35
+  val age2: Int Refined GreaterEqual[35] = 35
+  val ageInput: Int = 36
+  val ageCheck = refineV[GreaterEqual[35]](ageInput)
+
+  val myDigit: Char Refined Digit = '8'
+  val myLetter: Char Refined Letter = 'H'
+
+  val myName: String Refined StartsWith["S"] = "Sandra"
+  val myName2: String Refined EndsWith["t"] = "Herbert"
+  // val myName3: String Refined StartsWith["s"] = "Sandra"
+  // val myAddr: String Refined IPv6 = "127.0.0.1"
+
+  type myRegex = MatchesRegex["""[A-Za-z0-9]+"""]
+  val accessCode: String Refined myRegex = "DC13h"
+
+  type myIntRegex = myRegex And ValidInt
+  val accessCode2: String Refined myIntRegex = "97426"
+  // val accessCode3: String Refined myIntRegex = "9742B"
+
+  val fruits = List("Banana", "Orange", "Lemon", "Guava")
+  val contains = refineV[Contains["Berry"]](fruits)
+  val forall = refineV[Forall[Trimmed]](fruits)
+  val last = refineV[Last[Uuid]](fruits)
+  val size = refineV[Size[Less[5]]](fruits)
+
+  case class Person(name: String, height: Double)
+  case class Tall()
+  case class Average()
+  case class Short()
+
+  implicit val tallValidate: Validate.Plain[Person, Tall] =
+    Validate.fromPredicate(
+      p => p.height >= 6.0,
+      p => s"(${p.name} is tall)",
+      Tall()
+    )
+
+  implicit val averageValidate: Validate.Plain[Person, Average] =
+    Validate.fromPredicate(
+      p => p.height >= 5.0 && p.height < 6.0,
+      p => s"(${p.name} is average)",
+      Average()
+    )
+
+  implicit val shortValidate: Validate.Plain[Person, Short] =
+    Validate.fromPredicate(
+      p => p.height < 5.0,
+      p => s"(${p.name} is short)",
+      Short()
+    )
+
+  val tall = refineV[Tall](Person("Herbert", 5.5))
+  val average = refineV[Average](Person("Herbert", 5.5))
+}
+
+object Hello extends App {
+  import RefinedIntro._
+  println(refineV[Short](Person("Herbert", 4.0)))
+}

scala-libraries-standalone/refined/src/test/scala/com/baeldung/refined/RefinedUnitTest.scala

@@ -0,0 +1,75 @@
+package com.baeldung.refined
+
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import eu.timepit.refined._
+import eu.timepit.refined.api.Refined
+import eu.timepit.refined.auto._
+import eu.timepit.refined.numeric._
+import eu.timepit.refined.string._
+import eu.timepit.refined.collection._
+import eu.timepit.refined.char._
+import eu.timepit.refined.boolean._
+import eu.timepit.refined.api.Validate
+import scala.util.{Right, Left}
+
+class RefinedUnitTest extends AnyFlatSpec with Matchers {
+  import RefinedIntro.{size => sizeTest, _}
+
+  "Int checks" should "pass with refined types" in {
+    assert(refineV[Odd](8) == Left("Predicate (8 % 2 == 0) did not fail."))
+    age shouldBe an[Int Refined Less[35]]
+    ageInterval shouldBe an[Int Refined Interval.Closed[30, 35]]
+    age2 shouldBe an[Int Refined GreaterEqual[35]]
+    ageInput shouldBe an[Int]
+    ageCheck shouldBe an[Either[String, Refined[Int, GreaterEqual[35]]]]
+  }
+
+  "Char checks" should "pass for refined types" in {
+    assert(myDigit.isInstanceOf[Char Refined Digit])
+    assert(myLetter.isInstanceOf[Char Refined Letter])
+  }
+
+  "String checks" should "pass for refined types" in {
+    assert(
+      refineV[StartsWith["s"]]("Sandra") == Left(
+        "Predicate failed: \"Sandra\".startsWith(\"s\")."
+      )
+    )
+    assert(
+      refineV[IPv6]("127.0.0.1") == Left(
+        "Predicate failed: 127.0.0.1 is a valid IPv6."
+      )
+    )
+    assert(myName.isInstanceOf[String Refined StartsWith["S"]])
+    assert(myName2.isInstanceOf[String Refined EndsWith["t"]])
+  }
+
+  "Regex checks" should "pass for refined types" in {
+    assert(
+      refineV[myIntRegex]("9742B") == Left(
+        "Right predicate of (\"9742B\".matches(\"[A-Za-z0-9]+\") && isValidValidInt(\"9742B\")) failed: ValidInt predicate failed: For input string: \"9742B\""
+      )
+    )
+    assert(accessCode.isInstanceOf[String Refined myRegex])
+
+    assert(accessCode2.isInstanceOf[String Refined myIntRegex])
+  }
+
+  "collection checks" should "pass for refined types" in {
+    assert(
+      forall
+        .isInstanceOf[Either[String, Refined[List[String], Forall[Trimmed]]]]
+    )
+    assert(last.isInstanceOf[Either[String, Refined[List[String], Last[Uuid]]]])
+    assert(
+      sizeTest
+        .isInstanceOf[Either[String, Refined[List[String], Size[Less[5]]]]]
+    )
+  }
+
+  "Person checks" should "pass for custom refined types" in {
+    assert(tall.isInstanceOf[Either[String, Refined[Person, Tall]]])
+    assert(average.isInstanceOf[Either[String, Refined[Person, Average]]])
+  }
+}