root/scalaz/Arrow

Arrow

trait Arrow[=>:[_, _]] extends Split[=>:] with Strong[=>:] with Category[=>:]

A scalaz.Category supporting all ordinary functions, as well as combining arrows product-wise. Every Arrow forms a scalaz.Contravariant in one type parameter, and a scalaz.Applicative in the other, just as with ordinary functions.

Companion
object
trait Category[=>:]
trait Strong[=>:]
trait Profunctor[=>:]
trait Split[=>:]
trait Compose[=>:]
class Object
trait Matchable
class Any
Arrow[=>:]

Type members

Inherited classlikes

trait CategoryLaw
Inherited from
Category
trait ComposeLaw
Inherited from
Compose
trait ProfunctorLaw
Inherited from
Profunctor
trait StrongLaws
Inherited from
Strong

Value members

Abstract methods

def arr[A, B](f: A => B): A =>: B

Lift an ordinary function.

Lift an ordinary function.

Concrete methods

final
def <<<[A, B, C](fbc: B =>: C, fab: A =>: B): A =>: C

Alias for compose.

Alias for compose.

def >>>[A, B, C](fab: A =>: B, fbc: B =>: C): A =>: C

Flipped <<<.

Flipped <<<.

def combine[A, B, C](fab: A =>: B, fac: A =>: C): A =>: (B, C)

Run fab and fac on the same A. Sometimes &&&.

Run fab and fac on the same A. Sometimes &&&.

override
def covariantInstance[C]: Applicative[[_] =>> C =>: _$3]
Definition Classes
def mapfst[A, B, C](fab: A =>: B)(f: C => A): C =>: B

Contramap on A.

Contramap on A.

def mapsnd[A, B, C](fab: A =>: B)(f: B => C): A =>: C

Functor map on B.

Functor map on B.

def product[A, B](fab: A =>: B): (A, A) =>: (B, B)

Run two fabs alongside each other.

Run two fabs alongside each other.

override
def second[A, B, C](f: A =>: B): (C, A) =>: (C, B)

Pass C through untouched.

Pass C through untouched.

Definition Classes
def split[A, B, C, D](f: A =>: B, g: C =>: D): (A, C) =>: (B, D)

Run fab and fcd alongside each other. Sometimes ***.

Run fab and fcd alongside each other. Sometimes ***.

final
def splitA[A, B, C, D](fab: A =>: B, fcd: C =>: D): (A, C) =>: (B, D)

Alias for split.

Alias for split.

def swap[X, Y]: (X, Y) =>: (Y, X)

Swaps a pair.

Swaps a pair.

Inherited methods

def categoryLaw: CategoryLaw
Inherited from
Category
def compose[A, B, C](f: B =>: C, g: A =>: B): A =>: C

Associative =>: binary operator.

Associative =>: binary operator.

Inherited from
Compose
def composeLaw: ComposeLaw
Inherited from
Compose
def dimap[A, B, C, D](fab: A =>: B)(f: C => A)(g: B => D): C =>: D

Functor map on A and B.

Functor map on A and B.

Inherited from
Profunctor
def empty: PlusEmpty[=>:]

monoid, but universally quantified.

monoid, but universally quantified.

Inherited from
Category
def first[A, B, C](fa: A =>: B): (A, C) =>: (B, C)
Inherited from
Strong
def id[A]: A =>: A

The left and right identity over compose.

The left and right identity over compose.

Inherited from
Category
def monoid[A]: Monoid[A =>: A]

The endomorphism monoid, where zero=id and append=compose.

The endomorphism monoid, where zero=id and append=compose.

Inherited from
Category
def plus: Plus[=>:]

semigroup, but universally quantified.

semigroup, but universally quantified.

Inherited from
Compose
def semigroup[A]: Semigroup[A =>: A]

The endomorphism semigroup, where append=compose.

The endomorphism semigroup, where append=compose.

Inherited from
Compose
def strongLaw: StrongLaws
Inherited from
Strong

Concrete fields

Inherited fields

val categorySyntax: CategorySyntax[=>:]
Inherited from
Category
val composeSyntax: ComposeSyntax[=>:]
Inherited from
Compose
val splitSyntax: SplitSyntax[=>:]
Inherited from
Split
val strongSyntax: StrongSyntax[=>:]
Inherited from
Strong