refined

# refined: simple refinement types for Scala
[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/fthomas/refined/ci.yml)](https://github.com/fthomas/refined/actions/workflows/ci.yml)
[![codecov.io](https://img.shields.io/codecov/c/github/fthomas/refined.svg)](http://codecov.io/github/fthomas/refined)
[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/fthomas/refined?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![refined Scala version support](https://index.scala-lang.org/fthomas/refined/refined/latest-by-scala-version.svg?color=blue)](https://index.scala-lang.org/fthomas/refined/refined)
[![Scaladoc](https://www.javadoc.io/badge/eu.timepit/refined_2.12.svg?color=blue&label=Scaladoc)](https://javadoc.io/doc/eu.timepit/refined_2.12/0.11.4)

**refined** is a Scala library for refining types with type-level predicates
which constrain the set of values described by the refined type.
It started as a port of the [refined][refined.hs] Haskell library by
[Nikita Volkov](https://github.com/nikita-volkov) (which also provides an excellent
motivation why this kind of library is useful).
The idea of expressing constraints at the type-level as Scala library was first
explored by [Flavio W. Brasil](https://github.com/fwbrasil) in [bond][bond].

A quick example:

```scala
import eu.timepit.refined._
import eu.timepit.refined.api.Refined
import eu.timepit.refined.auto._
import eu.timepit.refined.numeric._

// This refines Int with the Positive predicate and checks via an
// implicit macro that the assigned value satisfies it:
scala> val i1: Int Refined Positive = 5
i1: Int Refined Positive = 5

// If the value does not satisfy the predicate, we get a meaningful
// compile error:
scala> val i2: Int Refined Positive = -5
<console>:22: error: Predicate failed: (-5 > 0).
       val i2: Int Refined Positive = -5
                                       ^

// There is also the explicit refineMV macro that can infer the base
// type from its parameter:
scala> refineMV[Positive](5)
res0: Int Refined Positive = 5

// Macros can only validate literals because their values are known at
// compile-time. To validate arbitrary (runtime) values we can use the
// refineV function:

scala> val x = 42 // suppose the value of x is not known at compile-time

scala> refineV[Positive](x)
res1: Either[String, Int Refined Positive] = Right(42)

scala> refineV[Positive](-x)
res2: Either[String, Int Refined Positive] = Left(Predicate failed: (-42 > 0).)
```

**refined** also contains inference rules for converting between different
refined types. For example, ``Int Refined Greater[10]`` can be safely
converted to `Int Refined Positive` because all integers greater than ten
are also positive. The type conversion of refined types is a compile-time
operation that is provided by the library:

```scala
scala> val a: Int Refined Greater[5] = 10
a: Int Refined Greater[Int(5)] = 10

// Since every value greater than 5