Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add RuntimeConstraint #175

Merged
merged 9 commits into from
Sep 28, 2023
Merged

Add RuntimeConstraint #175

Show file tree
Hide file tree
Changes from 5 commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
53ad033
POC for RuntimeConstraint
kyri-petrou Sep 19, 2023
fd7e919
Use RuntimeConstraint in zio/cats newtypes
kyri-petrou Sep 21, 2023
e2d9ca8
Remove inlining where not necessary
kyri-petrou Sep 22, 2023
e0e0bdd
PR comments
kyri-petrou Sep 24, 2023
ea590ff
Avoid auto-deriving when implicit exists
kyri-petrou Sep 24, 2023
6728342
PR comments
kyri-petrou Sep 24, 2023
76efae0
Make `rtc` a val
kyri-petrou Sep 24, 2023
b5d4ba9
Inline RuntimeConstraint given
kyri-petrou Sep 25, 2023
1538ffa
Add scaladoc for RuntimeConstraint
kyri-petrou Sep 28, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
27 changes: 14 additions & 13 deletions cats/src/io/github/iltotore/iron/cats.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -127,7 +127,7 @@ object cats extends IronCatsInstances:
* @return a [[Right]] containing this value as [[IronType]] or a [[Left]] containing the constraint message.
* @see [[either]], [[eitherNel]].
*/
inline def eitherNec(value: A)(using inline c: Constraint[A, C]): EitherNec[String, T] = value.refineNec[C].map(_.asInstanceOf[T])
def eitherNec(value: A): EitherNec[String, T] = ops.either(value).toEitherNec

/**
* Refine the given value at runtime, resulting in an [[EitherNel]].
Expand All @@ -136,7 +136,7 @@ object cats extends IronCatsInstances:
* @return a [[Right]] containing this value as [[IronType]] or a [[Left]] containing the constraint message.
* @see [[either]], [[eitherNec]].
*/
inline def eitherNel(value: A)(using inline c: Constraint[A, C]): EitherNel[String, T] = value.refineNel[C].map(_.asInstanceOf[T])
def eitherNel(value: A): EitherNel[String, T] = ops.either(value).toEitherNel

/**
* Refine the given value at runtime, resulting in a [[Validated]].
Expand All @@ -145,7 +145,8 @@ object cats extends IronCatsInstances:
* @return a [[Valid]] containing this value as [[IronType]] or an [[Invalid]] containing the constraint message.
* @see [[validatedNec]], [[validatedNel]].
*/
inline def validated(value: A)(using inline c: Constraint[A, C]): Validated[String, T] = value.refineValidated[C].map(_.asInstanceOf[T])
def validated(value: A): Validated[String, T] =
if ops.rtc.test(value) then Validated.valid(value.asInstanceOf[T]) else Validated.invalid(ops.rtc.message)

/**
* Refine the given value applicatively at runtime, resulting in a [[ValidatedNec]].
Expand All @@ -154,8 +155,8 @@ object cats extends IronCatsInstances:
* @return a [[Valid]] containing this value as [[IronType]] or an [[Invalid]] containing a [[NonEmptyChain]] of error messages.
* @see [[validated]], [[validatedNel]].
*/
inline def validatedNec(value: A)(using inline c: Constraint[A, C]): ValidatedNec[String, T] =
value.refineValidatedNec[C].map(_.asInstanceOf[T])
def validatedNec(value: A): ValidatedNec[String, T] =
if ops.rtc.test(value) then Validated.validNec(value.asInstanceOf[T]) else Validated.invalidNec(ops.rtc.message)

/**
* Refine the given value applicatively at runtime, resulting in a [[ValidatedNel]].
Expand All @@ -164,15 +165,15 @@ object cats extends IronCatsInstances:
* @return a [[Valid]] containing this value as [[IronType]] or an [[Invalid]] containing a [[NonEmptyList]] of error messages.
* @see [[validated]], [[validatedNec]].
*/
inline def validatedNel(value: A)(using inline c: Constraint[A, C]): ValidatedNel[String, T] =
value.refineValidatedNel[C].map(_.asInstanceOf[T])
def validatedNel(value: A): ValidatedNel[String, T] =
if ops.rtc.test(value) then Validated.validNel(value.asInstanceOf[T]) else Validated.invalidNel(ops.rtc.message)

/**
* Represent all Cats' typeclass instances for Iron.
*/
private trait IronCatsInstances extends IronCatsLowPriority, RefinedTypeOpsCats:

//The `NotGiven` implicit parameter is mandatory to avoid ambiguous implicit error when both Eq[A] and Hash[A]/PartialOrder[A] exist
// The `NotGiven` implicit parameter is mandatory to avoid ambiguous implicit error when both Eq[A] and Hash[A]/PartialOrder[A] exist
inline given [A, C](using inline ev: Eq[A], notHashOrOrder: NotGiven[Hash[A] | PartialOrder[A]]): Eq[A :| C] = ev.asInstanceOf[Eq[A :| C]]

inline given [A, C](using inline ev: PartialOrder[A], notOrder: NotGiven[Order[A]]): PartialOrder[A :| C] = ev.asInstanceOf[PartialOrder[A :| C]]
Expand Down Expand Up @@ -226,14 +227,14 @@ private trait IronCatsLowPriority:

private trait RefinedTypeOpsCats extends RefinedTypeOpsCatsLowPriority:

inline given[T](using mirror: RefinedTypeOps.Mirror[T], ev: Eq[mirror.IronType]): Eq[T] = ev.asInstanceOf[Eq[T]]
inline given [T](using mirror: RefinedTypeOps.Mirror[T], ev: Eq[mirror.IronType]): Eq[T] = ev.asInstanceOf[Eq[T]]

inline given[T](using mirror: RefinedTypeOps.Mirror[T], ev: Order[mirror.IronType]): Order[T] = ev.asInstanceOf[Order[T]]
inline given [T](using mirror: RefinedTypeOps.Mirror[T], ev: Order[mirror.IronType]): Order[T] = ev.asInstanceOf[Order[T]]

inline given[T](using mirror: RefinedTypeOps.Mirror[T], ev: Show[mirror.IronType]): Show[T] = ev.asInstanceOf[Show[T]]
inline given [T](using mirror: RefinedTypeOps.Mirror[T], ev: Show[mirror.IronType]): Show[T] = ev.asInstanceOf[Show[T]]

inline given[T](using mirror: RefinedTypeOps.Mirror[T], ev: PartialOrder[mirror.IronType]): PartialOrder[T] = ev.asInstanceOf[PartialOrder[T]]
inline given [T](using mirror: RefinedTypeOps.Mirror[T], ev: PartialOrder[mirror.IronType]): PartialOrder[T] = ev.asInstanceOf[PartialOrder[T]]

private trait RefinedTypeOpsCatsLowPriority:

inline given[T](using mirror: RefinedTypeOps.Mirror[T], ev: Hash[mirror.IronType]): Hash[T] = ev.asInstanceOf[Hash[T]]
inline given [T](using mirror: RefinedTypeOps.Mirror[T], ev: Hash[mirror.IronType]): Hash[T] = ev.asInstanceOf[Hash[T]]
31 changes: 15 additions & 16 deletions main/src/io/github/iltotore/iron/RefinedTypeOps.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -48,7 +48,10 @@ object RefinedTypeOps:
*/
type FinalType = T

trait RefinedTypeOpsImpl[A, C, T]:

trait RefinedTypeOpsImpl[A, C, T](using rtcAuto: RuntimeConstraint.AutoDerived[A, A :| C]):
given rtc: RuntimeConstraint[A, T] = rtcAuto.inner.asInstanceOf[RuntimeConstraint[A, T]]
Copy link
Owner

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I don't think we need such given instance. If someone want to get the constraint bound to a newtype, it can do it as follow:

inline def foo[T](using mirror: RefinedTypeOps.Mirror[T], constraint: Constraint[mirror.BaseType, mirror.ConstraintType] /*Or runtime constraint*/) = ???

But we can get rtc as a public val to allow using it in RefinedTypeOps extensions like in Cats or ZIO

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I made it a val but also created a protected given RuntimeConstraint[A, C]. My reasoning behind having the protected given is so that it can be used in the companion object of opaque types when creating codecs etc


/**
* Implicitly refine at compile-time the given value.
*
Expand All @@ -67,7 +70,7 @@ trait RefinedTypeOpsImpl[A, C, T]:
* @return a constrained value, without performing constraint checks.
* @see [[apply]], [[applyUnsafe]].
*/
inline def assume(value: A): T = value.assume[C].asInstanceOf[T]
inline def assume(value: A): T = value.asInstanceOf[T]

/**
* Refine the given value at runtime, resulting in an [[Either]].
Expand All @@ -76,8 +79,8 @@ trait RefinedTypeOpsImpl[A, C, T]:
* @return a [[Right]] containing this value as [[T]] or a [[Left]] containing the constraint message.
* @see [[fromIronType]], [[option]], [[applyUnsafe]].
*/
inline def either(value: A)(using constraint: Constraint[A, C]): Either[String, T] =
Either.cond(constraint.test(value), value.asInstanceOf[T], constraint.message)
def either(value: A): Either[String, T] =
Either.cond(rtc.test(value), value.asInstanceOf[T], rtc.message)

/**
* Refine the given value at runtime, resulting in an [[Option]].
Expand All @@ -86,8 +89,8 @@ trait RefinedTypeOpsImpl[A, C, T]:
* @return an Option containing this value as [[T]] or [[None]].
* @see [[fromIronType]], [[either]], [[applyUnsafe]].
*/
inline def option(value: A)(using constraint: Constraint[A, C]): Option[T] =
Option.when(constraint.test(value))(value.asInstanceOf[T])
def option(value: A): Option[T] =
Option.when(rtc.test(value))(value.asInstanceOf[T])

/**
* Refine the given value at runtime.
Expand All @@ -97,23 +100,19 @@ trait RefinedTypeOpsImpl[A, C, T]:
* @throws an [[IllegalArgumentException]] if the constraint is not satisfied.
* @see [[fromIronType]], [[either]], [[option]].
*/
inline def applyUnsafe(value: A)(using Constraint[A, C]): T =
value.refine[C].asInstanceOf[T]
inline def applyUnsafe(value: A): T =
if rtc.test(value) then value.asInstanceOf[T] else throw new IllegalArgumentException(rtc.message)
Iltotore marked this conversation as resolved.
Show resolved Hide resolved

inline def unapply(value: T): Option[A :| C] = Some(value.asInstanceOf[A :| C])
def unapply(value: T): Option[A :| C] = Some(value.asInstanceOf[A :| C])

inline given RefinedTypeOps.Mirror[T] with
override type BaseType = A
override type ConstraintType = C

inline given [R]: TypeTest[T, R] = summonInline[TypeTest[A :| C, R]].asInstanceOf[TypeTest[T, R]]

inline given [L](using inline constraint: Constraint[A, C]): TypeTest[L, T] =
val test = summonInline[TypeTest[L, A]]

new TypeTest:
override def unapply(value: L): Option[value.type & T] =
test.unapply(value).filter(constraint.test(_)).asInstanceOf
given [L](using test: TypeTest[L, A]): TypeTest[L, T] with
override def unapply(value: L): Option[value.type & T] = test.unapply(value).filter(rtc.test(_)).asInstanceOf

extension (wrapper: T)
inline def value: IronType[A, C] = wrapper.asInstanceOf[IronType[A, C]]
inline def value: IronType[A, C] = wrapper.asInstanceOf[IronType[A, C]]
21 changes: 21 additions & 0 deletions main/src/io/github/iltotore/iron/RuntimeConstraint.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,21 @@
package io.github.iltotore.iron

import scala.util.NotGiven

final class RuntimeConstraint[A, T](_test: A => Boolean, val message: String):
inline def test(value: A): Boolean = _test(value)

object RuntimeConstraint:

inline def derived[A, C](using inline c: Constraint[A, C]): RuntimeConstraint[A, A :| C] =
new RuntimeConstraint[A, A :| C](c.test(_), c.message)

final class AutoDerived[A, T](val inner: RuntimeConstraint[A, T])
object AutoDerived:
inline given [A, C](using rtc: RuntimeConstraint[A, A :| C]): AutoDerived[A, A :| C] =
new AutoDerived[A, A :| C](rtc)

inline given [A, C](using inline c: Constraint[A, C], ng: NotGiven[RuntimeConstraint[A, A :| C]]): AutoDerived[A, A :| C] =
new AutoDerived[A, A :| C](RuntimeConstraint.derived[A, C])
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

One of the things that was bugging me was having auto-derivation of RuntimeConstraint from a Constraint enabled by default. This is fairly dangerous as methods requiring a RuntimeConstraint would auto-derive one if one wasn't in scope, which can lead to increased compilation time and generated code size.

With this, a user / method / etc can define whether they want an explicit or implicit given to be provided. For newtypes, this is generated by default

Example:

// will raise a compile-time error if one isn't explicitely defined (newtypes are OK since we create one for them in RefinedTypeOpsImpl)
def foo(value: Int)(using RuntimeConstraint[Int, Int :| Greater[10]]) = ??? 

 // Will prioritise an explicitly defined RuntimeConstraint and auto-derive one if it doesn't exist
def foo(value: Int)(using RuntimeConstraint.AutoDerived[Int, Int :| Greater[10]]) = ???

Copy link
Owner

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I still don't understand why RuntimeConstraint does not have the same type parameters than Constraint. Then, it would look like:

def foo(value: Int)(using RuntimeConstraint[Int, Greater[10]]) = ???

def foo(value: Int)(using RuntimeConstraint.AutoDerived[Int, Greater[10]]) = ???

Also, I'm not sure about the usefulness of AutoDerived. It would leak an implementation detail (how the instance is generated) and I'm not sure about the real impact of auto deriving automatically on bytecode size and compilation times.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

After sleeping on it, I think you're right. I reverted these changes


end RuntimeConstraint
17 changes: 7 additions & 10 deletions zio/src/io/github/iltotore/iron/zio.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,12 +1,11 @@
package io.github.iltotore.iron

import _root_.zio.NonEmptyChunk
import _root_.zio.prelude.{Debug, Equal, Hash, Ord, PartialOrd, Validation}
import _root_.zio.prelude.{Debug, Equal, Hash, Ord, Validation}

object zio extends RefinedTypeOpsZio:

extension [A](value: A)

/**
* Refine the given value applicatively at runtime, resulting in a [[Validation]].
*
Expand All @@ -16,9 +15,7 @@ object zio extends RefinedTypeOpsZio:
inline def refineValidation[C](using inline constraint: Constraint[A, C]): Validation[String, A :| C] =
Validation.fromPredicateWith(constraint.message)(value.asInstanceOf[A :| C])(constraint.test(_))


extension [A, C1](value: A :| C1)

/**
* Refine the given value again applicatively at runtime, resulting in a [[Validation]].
*
Expand All @@ -35,17 +32,17 @@ object zio extends RefinedTypeOpsZio:
* @param constraint the constraint to test with the value to refine.
* @return a [[Valid]] containing this value as [[T]] or an [[Validation.Failure]] containing a [[NonEmptyChunk]] of error messages.
*/
inline def validation(value: A)(using inline constraint: Constraint[A, C]): Validation[String, T] =
value.refineValidation[C].map(_.asInstanceOf[T])
def validation(value: A): Validation[String, T] =
Validation.fromPredicateWith(ops.rtc.message)(value)(ops.rtc.test(_)).asInstanceOf[Validation[String, T]]

private trait RefinedTypeOpsZio extends RefinedTypeOpsZioLowPriority:

inline given[T](using mirror: RefinedTypeOps.Mirror[T], ev: Debug[mirror.IronType]): Debug[T] = ev.asInstanceOf[Debug[T]]
inline given [T](using mirror: RefinedTypeOps.Mirror[T], ev: Debug[mirror.IronType]): Debug[T] = ev.asInstanceOf[Debug[T]]

inline given[T](using mirror: RefinedTypeOps.Mirror[T], ev: Equal[mirror.IronType]): Equal[T] = ev.asInstanceOf[Equal[T]]
inline given [T](using mirror: RefinedTypeOps.Mirror[T], ev: Equal[mirror.IronType]): Equal[T] = ev.asInstanceOf[Equal[T]]

inline given[T](using mirror: RefinedTypeOps.Mirror[T], ev: Ord[mirror.IronType]): Ord[T] = ev.asInstanceOf[Ord[T]]
inline given [T](using mirror: RefinedTypeOps.Mirror[T], ev: Ord[mirror.IronType]): Ord[T] = ev.asInstanceOf[Ord[T]]

private trait RefinedTypeOpsZioLowPriority:

inline given[T](using mirror: RefinedTypeOps.Mirror[T], ev: Hash[mirror.IronType]): Hash[T] = ev.asInstanceOf[Hash[T]]
inline given [T](using mirror: RefinedTypeOps.Mirror[T], ev: Hash[mirror.IronType]): Hash[T] = ev.asInstanceOf[Hash[T]]