refined VS cats

Perhaps refined would help you? It lets you set constraints (i.e. "rules") for values / types. You get compile-time enforcement for constants and fallible methods for runtime values (i.e. Either[Error, RefinedValue]).

This is more or less how derivation works when you want to use something like Refined types (it exposes Validate[Type, Refinement] typeclass if I remember correctly). Enumeratum exposes Enum[A], and newtypes expose Coercible[From, To].

You will probably be interested into Iron or Refined.

You want either a refined type, a newtype, or if you are in Scala 3 an opaque type.

Refined Scala

Additionally, I also like to use Refined, so that my names are actually NonEmptyStrings, and I'll usually go even farther and make a LastName type alias to NonEmptyString and a FirstName type alias to NonEmptyString so that I can legitimately return just Char as an initial, for example. That way parsing guarantees you're not just sending me empty stuff that is just as useless as an empty person, and also so that I don't accidentally put a FirstName where a LastName should go somewhere in my code.

I wrote a short piece on my company's blog explaining how we used refined to validate incoming data and parse it into more… well, refined types: https://engineering.contentsquare.com/2021/scala-refined-types/

This example uses probably the most popular JSON library for Scala, Circe. There is another Scala library that lets us "be more specific with," or "refine," our types, called Refined. http4s doesn't provide any particular support for Refined, but Circe has a module integrating Refined, meaning that all of Circe's parsing, encoding, and decoding support is integrated with Refined. Putting together http4s' Circe support, Circe's generic codec derivation, and Circe's Refined integration, here's what I came up with:

Scala is like a cross between Java and Haskell. Scala has a notation for monads similar to Haskell's `do ...` notation. It has libraries like (cats)[http://typelevel.org/cats/] (the name "cats" is short for "category theory") for functional programming. It has immutable classes with copy constructors similar to Haskell's records. Both languages have implicit parameters. I like immutability and strong type systems.

Is that the pure from the Cats library? https://github.com/typelevel/cats/blob/main/alleycats-core/src/main/scala/alleycats/Pure.scala

Cats is a library which provides abstractions for functional programming in the Scala programming language. The name is a playful shortening of the word category. https://typelevel.org/cats/

Obviamente que teoria de categorias https://typelevel.org/cats/

Akka HTTP, Cats, Quill, ninny, Monix Observable, mill.

Have a look at Profunctor. Specifically at rmap

Example of how it makes life worse

But not so long ago he was doing releases for Cats even though he was officially out of TL. And when he had some outburst I saw more support from TL-related people than scolding. Unless he really went over the top (like the time he ranted some guy on GitHub) there was no action.