Add Arrow Choice #2096
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,43 @@ | ||
| package cats | ||
| package arrow | ||
|
|
||
| import simulacrum.typeclass | ||
|
|
||
| /** | ||
| * Must obey the laws defined in cats.laws.ArrowChoiceLaws. | ||
| */ | ||
| @typeclass trait ArrowChoice[F[_, _]] extends Arrow[F] with Choice[F] { self => | ||
|
|
||
| /** | ||
| * ArrowChoice yields Arrows with choice, allowing distribution | ||
| * over coproducts. | ||
| * | ||
| * Given two `F`s (`f` and `g`), create a new `F` with | ||
| * domain the coproduct of the domains of `f` and `g`, | ||
| * and codomain the coproduct of the codomains of `f` and `g`. | ||
| * This is the sum notion to `split`'s product. | ||
| * | ||
| * Example: | ||
| * {{{ | ||
| * scala> import cats.implicits._ | ||
| * scala> val toLong: Int => Long = _.toLong | ||
| * scala> val toDouble: Float => Double = _.toDouble | ||
| * scala> val f: Either[Int, Float] => Either[Long, Double] = toLong +++ toDouble | ||
| * scala> f(Left(3)) | ||
| * res0: Either[Long,Double] = Left(3) | ||
| * scala> f(Right(3)) | ||
| * res1: Either[Long,Double] = Right(3.0) | ||
| * }}} | ||
| */ | ||
| @simulacrum.op("+++", alias = true) | ||
| def choose[A, B, C, D](f: F[A, C])(g: F[B, D]): F[Either[A, B], Either[C, D]] | ||
|
|
||
| def left[A, B, C](fab: F[A, B]): F[Either[A, C], Either[B, C]] = | ||
| choose(fab)(lift(identity[C])) | ||
|
|
||
| def right[A, B, C](fab: F[A, B]): F[Either[C, A], Either[C, B]] = | ||
| choose(lift(identity[C]))(fab) | ||
|
|
||
| override def choice[A, B, C](f: F[A, C], g: F[B, C]): F[Either[A, B], C] = | ||
| rmap(choose(f)(g))(_.fold(identity, identity)) | ||
|
There was a problem hiding this comment. I noticed that There was a problem hiding this comment. Good call, I can add. |
||
| } | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -2,7 +2,7 @@ package cats | |
| package instances | ||
|
|
||
| import cats.Contravariant | ||
| import cats.arrow.{Category, ArrowChoice, CommutativeArrow} | ||
|
|
||
| import annotation.tailrec | ||
|
|
||
|
|
@@ -68,12 +68,13 @@ private[instances] sealed trait Function1Instances extends Function1Instances0 { | |
| } | ||
| } | ||
|
|
||
| implicit val catsStdInstancesForFunction1: ArrowChoice[Function1] with CommutativeArrow[Function1] = | ||
| new ArrowChoice[Function1] with CommutativeArrow[Function1] { | ||
| def choose[A, B, C, D](f: A => C)(g: B => D): Either[A, B] => Either[C, D] = | ||
| _.fold( | ||
|
There was a problem hiding this comment. using pattern match rather than There was a problem hiding this comment. Yup, can do. I tend to forget that end of things. |
||
| Left.apply[C, D] _ compose f, | ||
| Right.apply[C, D] _ compose g | ||
| ) | ||
|
|
||
| def lift[A, B](f: A => B): A => B = f | ||
|
|
||
|
|
||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,6 @@ | ||
| package cats | ||
| package syntax | ||
|
|
||
| import cats.arrow.ArrowChoice | ||
|
|
||
| trait ArrowChoiceSyntax extends ArrowChoice.ToArrowChoiceOps |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,43 @@ | ||
| package cats | ||
| package laws | ||
|
|
||
| import cats.arrow.ArrowChoice | ||
| import cats.syntax.compose._ | ||
|
|
||
| /** | ||
| * Laws that must be obeyed by any `cats.arrow.ArrowChoice`. | ||
| */ | ||
| trait ArrowChoiceLaws[F[_, _]] extends ArrowLaws[F] with ChoiceLaws[F] { | ||
| implicit override def F: ArrowChoice[F] | ||
| implicit def Function: ArrowChoice[Function1] | ||
|
There was a problem hiding this comment. Are these laws based on the ones defined in Control-ArrowChoice? There was a problem hiding this comment. Hmm, they are meant to but interestingly the ones in the source and the ones in the Haskell doc do not quite look the same, I'll give them another pass tonight to make sure I transcribed the correct set. There was a problem hiding this comment. Yeah, I totally misread them, somehow. How embarrassing! Sorry about that. Fixing. |
||
|
|
||
| def leftLiftCommute[A, B, C](f: A => B): IsEq[F[Either[A, C], Either[B, C]]] = | ||
| F.left[A, B, C](F.lift[A, B](f)) <-> F.lift[Either[A, C], Either[B, C]](Function.left[A, B, C](f)) | ||
|
|
||
| def rightLiftCommute[A, B, C](f: A => B): IsEq[F[Either[C, A], Either[C, B]]] = | ||
| F.right[A, B, C](F.lift[A, B](f)) <-> F.lift[Either[C, A], Either[C, B]](Function.right[A, B, C](f)) | ||
|
|
||
| def chooseLiftCommute[A, B, C, D](f: A => C, g: B => D): IsEq[F[Either[A, B], Either[C, D]]] = | ||
| F.lift[Either[A, B], Either[C, D]](Function.choose(f)(g)) <-> F.choose[A, B, C, D](F.lift(f))(F.lift(g)) | ||
|
|
||
| def choiceLiftCommute[A, B, C](f: A => C, g: B => C): IsEq[F[Either[A, B], C]] = | ||
| F.lift[Either[A, B], C](Function.choice[A, B, C](f, g)) <-> F.choice[A, B, C](F.lift[A, C](f), F.lift[B, C](g)) | ||
|
|
||
| def leftComposeCommute[A, B, C, D](f: A => B, g: B => C): IsEq[F[Either[A, D], Either[C, D]]] = | ||
| F.left[A, C, D](F.lift(g compose f)) <-> | ||
| (F.lift[Either[B, D], Either[C, D]](Function.left(g)) <<< | ||
| F.lift[Either[A, D], Either[B, D]](Function.left(f))) | ||
|
|
||
| def rightComposeCommute[A, B, C, D](f: A => B, g: B => C): IsEq[F[Either[D, A], Either[D, C]]] = | ||
| F.right(F.lift(g compose f)) <-> | ||
| (F.lift[Either[D, B], Either[D, C]](Function.right(g)) <<< | ||
| F.lift[Either[D, A], Either[D, B]](Function.right(f))) | ||
| } | ||
|
|
||
| object ArrowChoiceLaws { | ||
| def apply[F[_, _]](implicit ev: ArrowChoice[F], f: ArrowChoice[Function1]): ArrowChoiceLaws[F] = | ||
| new ArrowChoiceLaws[F] { | ||
| def F: ArrowChoice[F] = ev | ||
| def Function: ArrowChoice[Function1] = f | ||
| } | ||
| } | ||
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
This is never tested by law as I noticed from the law set defined in Haskell. Thus it doesn't have any test coverage.
Shall we add a law for this something like
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I actually added symmetric versions for all the laws last night for that reason, but it takes the method well over 50 lines. Something like that sounds like a more reasonable way to get similar effect. I'll try it out today, it certainly should work.