cats-eo-api-docs
0.8.1-3-6c70289-SNAPSHOT
API
Generated with
cats-eo-api-docs/dev.constructive.eo/dev.constructive.eo.data/PSVec/pSVecTraverse

pSVecTraverse

dev.constructive.eo.data.PSVec.pSVecTraverse
object pSVecTraverse extends Traverse[PSVec]

cats.Traverse — the instance Traversal's .modifyA / .all route through when the carrier is MultiFocus[PSVec]. Effects run left-to-right in index order, results land in one pre-sized backing array threaded through G.map2 (no per-element vector rebuild).

Attributes

Source
PSVec.scala
Graph
Supertypes
trait Traverse[PSVec]
trait Foldable[PSVec]
trait Functor[PSVec]
trait Invariant[PSVec]
trait Serializable
class Object
trait Matchable
class Any
Show all
Self type

Members list

Grouped members

FoldableSlidingN

def sliding10[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding11[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding12[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding13[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding14[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding15[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding16[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding17[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding18[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding19[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding2[A](fa: PSVec[A]): List[(A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding20[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding21[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding22[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding3[A](fa: PSVec[A]): List[(A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding4[A](fa: PSVec[A]): List[(A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding5[A](fa: PSVec[A]): List[(A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding6[A](fa: PSVec[A]): List[(A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding7[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding8[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala
def sliding9[A](fa: PSVec[A]): List[(A, A, A, A, A, A, A, A, A)]

Attributes

Inherited from:
FoldableNFunctions
Source
FoldableNFunctions.scala

Value members

Concrete methods

def foldLeft[A, B](fa: PSVec[A], b: B)(f: (B, A) => B): B

Left associative fold on 'F' using the function 'f'.

Left associative fold on 'F' using the function 'f'.

Example:

scala> import cats.Foldable, cats.implicits._
scala> val fa = Option(1)

Folding by addition to zero:
scala> Foldable[Option].foldLeft(fa, Option(0))((a, n) => a.map(_ + n))
res0: Option[Int] = Some(1)

With syntax extensions, foldLeft can be used like:

Folding `Option` with addition from zero:
scala> fa.foldLeft(Option(0))((a, n) => a.map(_ + n))
res1: Option[Int] = Some(1)

There's also an alias `foldl` which is equivalent:
scala> fa.foldl(Option(0))((a, n) => a.map(_ + n))
res2: Option[Int] = Some(1)

Attributes

Source
PSVec.scala
def foldRight[A, B](fa: PSVec[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B]

Right associative lazy fold on F using the folding function 'f'.

Right associative lazy fold on F using the folding function 'f'.

This method evaluates lb lazily (in some cases it will not be needed), and returns a lazy value. We are using (A, Eval[B]) => Eval[B] to support laziness in a stack-safe way. Chained computation should be performed via .map and .flatMap.

For more detailed information about how this method works see the documentation for Eval[_].

Example:

scala> import cats.Foldable, cats.Eval, cats.implicits._
scala> val fa = Option(1)

Folding by addition to zero:
scala> val folded1 = Foldable[Option].foldRight(fa, Eval.now(0))((n, a) => a.map(_ + n))
Since `foldRight` yields a lazy computation, we need to force it to inspect the result:
scala> folded1.value
res0: Int = 1

With syntax extensions, we can write the same thing like this:
scala> val folded2 = fa.foldRight(Eval.now(0))((n, a) => a.map(_ + n))
scala> folded2.value
res1: Int = 1

Unfortunately, since `foldRight` is defined on many collections - this
extension clashes with the operation defined in `Foldable`.

To get past this and make sure you're getting the lazy `foldRight` defined
in `Foldable`, there's an alias `foldr`:
scala> val folded3 = fa.foldr(Eval.now(0))((n, a) => a.map(_ + n))
scala> folded3.value
res1: Int = 1

Attributes

Source
PSVec.scala
def traverse[G[_] : Applicative, A, B](fa: PSVec[A])(f: A => G[B]): G[PSVec[B]]

Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[B] in a G context.

Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[B] in a G context.

Example:

scala> import cats.syntax.all._
scala> def parseInt(s: String): Option[Int] = Either.catchOnly[NumberFormatException](s.toInt).toOption
scala> List("1", "2", "3").traverse(parseInt)
res0: Option[List[Int]] = Some(List(1, 2, 3))
scala> List("1", "two", "3").traverse(parseInt)
res1: Option[List[Int]] = None

Attributes

Source
PSVec.scala

Inherited methods

def as[A, B](fa: PSVec[A], b: B): PSVec[B]

Replaces the A value in F[A] with the supplied value.

Replaces the A value in F[A] with the supplied value.

Example:

scala> import cats.syntax.all._

scala> List(1,2,3).as("hello")
res0: List[String] = List(hello, hello, hello)

Attributes

Inherited from:
Functor
Source
Functor.scala
def collectFirst[A, B](fa: PSVec[A])(pf: PartialFunction[A, B]): Option[B]

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def collectFirstSome[A, B](fa: PSVec[A])(f: A => Option[B]): Option[B]

Like collectFirst from scala.collection.Traversable but takes A => Option[B] instead of PartialFunctions.

Like collectFirst from scala.collection.Traversable but takes A => Option[B] instead of PartialFunctions.

scala> import cats.syntax.all._
scala> val keys = List(1, 2, 4, 5)
scala> val map = Map(4 -> "Four", 5 -> "Five")
scala> keys.collectFirstSome(map.get)
res0: Option[String] = Some(Four)
scala> val map2 = Map(6 -> "Six", 7 -> "Seven")
scala> keys.collectFirstSome(map2.get)
res1: Option[String] = None

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def collectFirstSomeM[G[_], A, B](fa: PSVec[A])(f: A => G[Option[B]])(implicit G: Monad[G]): G[Option[B]]

Monadic version of collectFirstSome.

Monadic version of collectFirstSome.

If there are no elements, the result is None. collectFirstSomeM short-circuits, i.e. once a Some element is found, no further effects are produced.

For example:

scala> import cats.syntax.all._
scala> def parseInt(s: String): Either[String, Int] = Either.catchOnly[NumberFormatException](s.toInt).leftMap(_.getMessage)
scala> val keys1 = List("1", "2", "4", "5")
scala> val map1 = Map(4 -> "Four", 5 -> "Five")
scala> Foldable[List].collectFirstSomeM(keys1)(parseInt(_) map map1.get)
res0: scala.util.Either[String,Option[String]] = Right(Some(Four))

scala> val map2 = Map(6 -> "Six", 7 -> "Seven")
scala> Foldable[List].collectFirstSomeM(keys1)(parseInt(_) map map2.get)
res1: scala.util.Either[String,Option[String]] = Right(None)

scala> val keys2 = List("1", "x", "4", "5")
scala> Foldable[List].collectFirstSomeM(keys2)(parseInt(_) map map1.get)
res2: scala.util.Either[String,Option[String]] = Left(For input string: "x")

scala> val keys3 = List("1", "2", "4", "x")
scala> Foldable[List].collectFirstSomeM(keys3)(parseInt(_) map map1.get)
res3: scala.util.Either[String,Option[String]] = Right(Some(Four))

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def collectFold[A, B](fa: PSVec[A])(f: PartialFunction[A, B])(implicit B: Monoid[B]): B

Tear down a subset of this structure using a PartialFunction.

Tear down a subset of this structure using a PartialFunction.

scala> import cats.syntax.all._
scala> val xs = List(1, 2, 3, 4)
scala> Foldable[List].collectFold(xs) { case n if n % 2 == 0 => n }
res0: Int = 6

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def collectFoldSome[A, B](fa: PSVec[A])(f: A => Option[B])(implicit B: Monoid[B]): B

Tear down a subset of this structure using a A => Option[M].

Tear down a subset of this structure using a A => Option[M].

scala> import cats.syntax.all._
scala> val xs = List(1, 2, 3, 4)
scala> def f(n: Int): Option[Int] = if (n % 2 == 0) Some(n) else None
scala> Foldable[List].collectFoldSome(xs)(f)
res0: Int = 6

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def combineAll[A : Monoid](fa: PSVec[A]): A

Alias for fold.

Alias for fold.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def combineAllOption[A](fa: PSVec[A])(implicit ev: Semigroup[A]): Option[A]

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def compose[G[_] : Traverse]: Traverse[[α] =>> PSVec[G[α]]]

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def compose[G[_] : Foldable]: Foldable[[α] =>> PSVec[G[α]]]

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def compose[G[_] : Functor]: Functor[[α] =>> PSVec[G[α]]]

Attributes

Inherited from:
Functor
Source
Functor.scala
def compose[G[_] : Invariant]: Invariant[[α] =>> PSVec[G[α]]]

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

Compose Invariant F[_] and G[_] then produce Invariant[F[G[_]]] using their imap.

Example:

scala> import cats.syntax.all._
scala> import scala.concurrent.duration._

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
    | Invariant[Semigroup].compose[List].imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)

Attributes

Inherited from:
Invariant
Source
Invariant.scala
def composeBifunctor[G[_, _] : Bifunctor]: Bifunctor[[α, β] =>> PSVec[G[α, β]]]

Attributes

Inherited from:
Functor
Source
Functor.scala
override def composeContravariant[G[_] : Contravariant]: Contravariant[[α] =>> PSVec[G[α]]]

Compose Invariant F[_] and Contravariant G[_] then produce Invariant[F[G[_]]] using F's imap and G's contramap.

Compose Invariant F[_] and Contravariant G[_] then produce Invariant[F[G[_]]] using F's imap and G's contramap.

Example:

scala> import cats.syntax.all._
scala> import scala.concurrent.duration._

scala> type ToInt[T] = T => Int
scala> val durSemigroupToInt: Semigroup[ToInt[FiniteDuration]] =
    | Invariant[Semigroup]
    |   .composeContravariant[ToInt]
    |   .imap(Semigroup[ToInt[Long]])(Duration.fromNanos)(_.toNanos)
// semantically equal to (2.seconds.toSeconds.toInt + 1) + (2.seconds.toSeconds.toInt * 2) = 7
scala> durSemigroupToInt.combine(_.toSeconds.toInt + 1, _.toSeconds.toInt * 2)(2.seconds)
res1: Int = 7

Attributes

Definition Classes
Inherited from:
Functor
Source
Functor.scala
def composeFunctor[G[_] : Functor]: Invariant[[α] =>> PSVec[G[α]]]

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

Compose Invariant F[_] and Functor G[_] then produce Invariant[F[G[_]]] using F's imap and G's map.

Example:

scala> import cats.syntax.all._
scala> import scala.concurrent.duration._

scala> val durSemigroupList: Semigroup[List[FiniteDuration]] =
    | Invariant[Semigroup]
    |   .composeFunctor[List]
    |   .imap(Semigroup[List[Long]])(Duration.fromNanos)(_.toNanos)
scala> durSemigroupList.combine(List(2.seconds, 3.seconds), List(4.seconds))
res1: List[FiniteDuration] = List(2 seconds, 3 seconds, 4 seconds)

Attributes

Inherited from:
Invariant
Source
Invariant.scala
def contains_[A](fa: PSVec[A], v: A)(implicit ev: Eq[A]): Boolean

Tests if fa contains v using the Eq instance for A

Tests if fa contains v using the Eq instance for A

Attributes

Inherited from:
UnorderedFoldable
Source
UnorderedFoldable.scala
def count[A](fa: PSVec[A])(p: A => Boolean): Long

Count the number of elements in the structure that satisfy the given predicate.

Count the number of elements in the structure that satisfy the given predicate.

For example:

scala> import cats.syntax.all._
scala> val map1 = Map[Int, String]()
scala> val p1: String => Boolean = _.length > 0
scala> UnorderedFoldable[Map[Int, *]].count(map1)(p1)
res0: Long = 0

scala> val map2 = Map(1 -> "hello", 2 -> "world", 3 -> "!")
scala> val p2: String => Boolean = _.length > 1
scala> UnorderedFoldable[Map[Int, *]].count(map2)(p2)
res1: Long = 2

Attributes

Inherited from:
UnorderedFoldable
Source
UnorderedFoldable.scala
def dropWhile_[A](fa: PSVec[A])(p: A => Boolean): List[A]

Convert F[A] to a List[A], dropping all initial elements which match p.

Convert F[A] to a List[A], dropping all initial elements which match p.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
override def exists[A](fa: PSVec[A])(p: A => Boolean): Boolean

Check whether at least one element satisfies the predicate.

Check whether at least one element satisfies the predicate.

If there are no elements, the result is false.

Attributes

Definition Classes
Inherited from:
Foldable
Source
Foldable.scala
def existsM[G[_], A](fa: PSVec[A])(p: A => G[Boolean])(implicit G: Monad[G]): G[Boolean]

Check whether at least one element satisfies the effectful predicate.

Check whether at least one element satisfies the effectful predicate.

If there are no elements, the result is false. existsM short-circuits, i.e. once a true result is encountered, no further effects are produced.

For example:

scala> import cats.syntax.all._
scala> val F = Foldable[List]
scala> F.existsM(List(1,2,3,4))(n => Option(n  F.existsM(List(1,2,3,4))(n => Option(n > 4))
res1: Option[Boolean] = Some(false)

scala> F.existsM(List(1,2,3,4))(n => if (n  F.existsM(List(1,2,3,4))(n => if (n  F.existsM(List(1,2,3,4))(n => if (n <= 2) None else Option(true))
res4: Option[Boolean] = None

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def filter_[A](fa: PSVec[A])(p: A => Boolean): List[A]

Convert F[A] to a List[A], only including elements which match p.

Convert F[A] to a List[A], only including elements which match p.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def find[A](fa: PSVec[A])(f: A => Boolean): Option[A]

Find the first element matching the predicate, if one exists.

Find the first element matching the predicate, if one exists.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def findM[G[_], A](fa: PSVec[A])(p: A => G[Boolean])(implicit G: Monad[G]): G[Option[A]]

Find the first element matching the effectful predicate, if one exists.

Find the first element matching the effectful predicate, if one exists.

If there are no elements, the result is None. findM short-circuits, i.e. once an element is found, no further effects are produced.

For example:

scala> import cats.syntax.all._
scala> val list = List(1,2,3,4)
scala> Foldable[List].findM(list)(n => (n >= 2).asRight[String])
res0: Either[String,Option[Int]] = Right(Some(2))

scala> Foldable[List].findM(list)(n => (n > 4).asRight[String])
res1: Either[String,Option[Int]] = Right(None)

scala> Foldable[List].findM(list)(n => Either.cond(n < 3, n >= 2, "error"))
res2: Either[String,Option[Int]] = Right(Some(2))

scala> Foldable[List].findM(list)(n => Either.cond(n < 3, false, "error"))
res3: Either[String,Option[Int]] = Left(error)

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def flatSequence[G[_], A](fgfa: PSVec[G[PSVec[A]]])(implicit G: Applicative[G], F: FlatMap[PSVec]): G[PSVec[A]]

Thread all the G effects through the F structure and flatten to invert the structure from F[G[F[A]]] to G[F[A]].

Thread all the G effects through the F structure and flatten to invert the structure from F[G[F[A]]] to G[F[A]].

Example:

scala> import cats.syntax.all._
scala> val x: List[Option[List[Int]]] = List(Some(List(1, 2)), Some(List(3)))
scala> val y: List[Option[List[Int]]] = List(None, Some(List(3)))
scala> x.flatSequence
res0: Option[List[Int]] = Some(List(1, 2, 3))
scala> y.flatSequence
res1: Option[List[Int]] = None

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def flatTraverse[G[_], A, B](fa: PSVec[A])(f: A => G[PSVec[B]])(implicit G: Applicative[G], F: FlatMap[PSVec]): G[PSVec[B]]

A traverse followed by flattening the inner result.

A traverse followed by flattening the inner result.

Example:

scala> import cats.syntax.all._
scala> def parseInt(s: String): Option[Int] = Either.catchOnly[NumberFormatException](s.toInt).toOption
scala> val x = Option(List("1", "two", "3"))
scala> x.flatTraverse(_.map(parseInt))
res0: List[Option[Int]] = List(Some(1), None, Some(3))

Attributes

Inherited from:
Traverse
Source
Traverse.scala
final def fmap[A, B](fa: PSVec[A])(f: A => B): PSVec[B]

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in .map method.

Alias for map, since map can't be injected as syntax if the implementing type already had a built-in .map method.

Example:

scala> import cats.syntax.all._

scala> val m: Map[Int, String] = Map(1 -> "hi", 2 -> "there", 3 -> "you")

scala> m.fmap(_ ++ "!")
res0: Map[Int,String] = Map(1 -> hi!, 2 -> there!, 3 -> you!)

Attributes

Inherited from:
Functor
Source
Functor.scala
def fold[A](fa: PSVec[A])(implicit A: Monoid[A]): A

Fold implemented using the given Monoid[A] instance.

Fold implemented using the given Monoid[A] instance.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def foldA[G[_], A](fga: PSVec[G[A]])(implicit G: Applicative[G], A: Monoid[A]): G[A]

Fold implemented using the given Applicative[G] and Monoid[A] instance.

Fold implemented using the given Applicative[G] and Monoid[A] instance.

This method is similar to fold, but may short-circuit.

For example:

scala> import cats.syntax.all._
scala> val F = Foldable[List]
scala> F.foldA(List(Either.right[String, Int](1), Either.right[String, Int](2)))
res0: Either[String, Int] = Right(3)

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def foldK[G[_], A](fga: PSVec[G[A]])(implicit G: MonoidK[G]): G[A]

Fold implemented using the given MonoidK[G] instance.

Fold implemented using the given MonoidK[G] instance.

This method is identical to fold, except that we use the universal monoid (MonoidK[G]) to get a Monoid[G[A]] instance.

For example:

scala> import cats.syntax.all._
scala> val F = Foldable[List]
scala> F.foldK(List(1 :: 2 :: Nil, 3 :: 4 :: 5 :: Nil))
res0: List[Int] = List(1, 2, 3, 4, 5)

Attributes

Inherited from:
Foldable
Source
Foldable.scala
final def foldLeftM[G[_], A, B](fa: PSVec[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]

Alias for foldM.

Alias for foldM.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def foldM[G[_], A, B](fa: PSVec[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]

Perform a stack-safe monadic left fold from the source context F into the target monad G.

Perform a stack-safe monadic left fold from the source context F into the target monad G.

This method can express short-circuiting semantics. Even when fa is an infinite structure, this method can potentially terminate if the foldRight implementation for F and the tailRecM implementation for G are sufficiently lazy.

Instances for concrete structures (e.g. List) will often have a more efficient implementation than the default one in terms of foldRight.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def foldMap[A, B](fa: PSVec[A])(f: A => B)(implicit B: Monoid[B]): B

Fold implemented by mapping A values into B and then combining them using the given Monoid[B] instance.

Fold implemented by mapping A values into B and then combining them using the given Monoid[B] instance.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def foldMapA[G[_], A, B](fa: PSVec[A])(f: A => G[B])(implicit G: Applicative[G], B: Monoid[B]): G[B]

Fold in an Applicative context by mapping the A values to G[B]. combining the B values using the given Monoid[B] instance.

Fold in an Applicative context by mapping the A values to G[B]. combining the B values using the given Monoid[B] instance.

Similar to foldMapM, but will typically be less efficient.

scala> import cats.Foldable
scala> import cats.syntax.all._
scala> val evenNumbers = List(2,4,6,8,10)
scala> val evenOpt: Int => Option[Int] =
    |   i => if (i % 2 == 0) Some(i) else None
scala> Foldable[List].foldMapA(evenNumbers)(evenOpt)
res0: Option[Int] = Some(30)
scala> Foldable[List].foldMapA(evenNumbers :+ 11)(evenOpt)
res1: Option[Int] = None

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def foldMapK[G[_], A, B](fa: PSVec[A])(f: A => G[B])(implicit G: MonoidK[G]): G[B]

Fold implemented by mapping A values into B in a context G and then combining them using the MonoidK[G] instance.

Fold implemented by mapping A values into B in a context G and then combining them using the MonoidK[G] instance.

scala> import cats._, cats.implicits._
scala> val f: Int => Endo[String] = i => (s => s + i)
scala> val x: Endo[String] = Foldable[List].foldMapK(List(1, 2, 3))(f)
scala> val a = x("foo")
a: String = "foo321"

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def foldMapM[G[_], A, B](fa: PSVec[A])(f: A => G[B])(implicit G: Monad[G], B: Monoid[B]): G[B]

Monadic folding on F by mapping A values to G[B], combining the B values using the given Monoid[B] instance.

Monadic folding on F by mapping A values to G[B], combining the B values using the given Monoid[B] instance.

Similar to foldM, but using a Monoid[B]. Will typically be more efficient than foldMapA.

scala> import cats.Foldable
scala> import cats.syntax.all._
scala> val evenNumbers = List(2,4,6,8,10)
scala> val evenOpt: Int => Option[Int] =
    |   i => if (i % 2 == 0) Some(i) else None
scala> Foldable[List].foldMapM(evenNumbers)(evenOpt)
res0: Option[Int] = Some(30)
scala> Foldable[List].foldMapM(evenNumbers :+ 11)(evenOpt)
res1: Option[Int] = None

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def foldRightDefer[G[_] : Defer, A, B](fa: PSVec[A], gb: G[B])(fn: (A, G[B]) => G[B]): G[B]

Attributes

Inherited from:
Foldable
Source
Foldable.scala
override def forall[A](fa: PSVec[A])(p: A => Boolean): Boolean

Check whether all elements satisfy the predicate.

Check whether all elements satisfy the predicate.

If there are no elements, the result is true.

Attributes

Definition Classes
Inherited from:
Foldable
Source
Foldable.scala
def forallM[G[_], A](fa: PSVec[A])(p: A => G[Boolean])(implicit G: Monad[G]): G[Boolean]

Check whether all elements satisfy the effectful predicate.

Check whether all elements satisfy the effectful predicate.

If there are no elements, the result is true. forallM short-circuits, i.e. once a false result is encountered, no further effects are produced.

For example:

scala> import cats.syntax.all._
scala> val F = Foldable[List]
scala> F.forallM(List(1,2,3,4))(n => Option(n  F.forallM(List(1,2,3,4))(n => Option(n  F.forallM(List(1,2,3,4))(n => if (n  F.forallM(List(1,2,3,4))(n => if (n  F.forallM(List(1,2,3,4))(n => if (n <= 2) None else Option(false))
res4: Option[Boolean] = None

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def fproduct[A, B](fa: PSVec[A])(f: A => B): PSVec[(A, B)]

Tuple the values in fa with the result of applying a function with the value

Tuple the values in fa with the result of applying a function with the value

Example:

scala> import cats.syntax.all._

scala> Option(42).fproduct(_.toString)
res0: Option[(Int, String)] = Some((42,42))

Attributes

Inherited from:
Functor
Source
Functor.scala
def fproductLeft[A, B](fa: PSVec[A])(f: A => B): PSVec[(B, A)]

Pair the result of function application with A.

Pair the result of function application with A.

Example:

scala> import cats.syntax.all._

scala> Option(42).fproductLeft(_.toString)
res0: Option[(String, Int)] = Some((42,42))

Attributes

Inherited from:
Functor
Source
Functor.scala
def get[A](fa: PSVec[A])(idx: Long): Option[A]

Get the element at the index of the Foldable.

Get the element at the index of the Foldable.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def ifF[A](fb: PSVec[Boolean])(ifTrue: => A, ifFalse: => A): PSVec[A]

Lifts if to Functor

Lifts if to Functor

Example:

scala> import cats.Functor
scala> import cats.syntax.all._

scala> Functor[List].ifF(List(true, false, false))(1, 0)
res0: List[Int] = List(1, 0, 0)

Attributes

Inherited from:
Functor
Source
Functor.scala
override def imap[A, B](fa: PSVec[A])(f: A => B)(g: B => A): PSVec[B]

Transform an F[A] into an F[B] by providing a transformation from A to B and one from B to A.

Transform an F[A] into an F[B] by providing a transformation from A to B and one from B to A.

Example:

scala> import cats.syntax.all._
scala> import scala.concurrent.duration._

scala> val durSemigroup: Semigroup[FiniteDuration] =
    | Invariant[Semigroup].imap(Semigroup[Long])(Duration.fromNanos)(_.toNanos)
scala> durSemigroup.combine(2.seconds, 3.seconds)
res1: FiniteDuration = 5 seconds

Attributes

Definition Classes
Inherited from:
Functor
Source
Functor.scala
def intercalate[A](fa: PSVec[A], a: A)(implicit A: Monoid[A]): A

Intercalate/insert an element between the existing elements while folding.

Intercalate/insert an element between the existing elements while folding.

scala> import cats.syntax.all._
scala> Foldable[List].intercalate(List("a","b","c"), "-")
res0: String = a-b-c
scala> Foldable[List].intercalate(List("a"), "-")
res1: String = a
scala> Foldable[List].intercalate(List.empty[String], "-")
res2: String = ""
scala> Foldable[Vector].intercalate(Vector(1,2,3), 1)
res3: Int = 8

Attributes

Inherited from:
Foldable
Source
Foldable.scala
override def isEmpty[A](fa: PSVec[A]): Boolean

Returns true if there are no elements. Otherwise false.

Returns true if there are no elements. Otherwise false.

Attributes

Definition Classes
Inherited from:
Foldable
Source
Foldable.scala
def lift[A, B](f: A => B): PSVec[A] => PSVec[B]

Lift a function f to operate on Functors

Lift a function f to operate on Functors

Example:

scala> import cats.Functor
scala> import cats.syntax.all._

scala> val o = Option(42)
scala> Functor[Option].lift((x: Int) => x + 10)(o)
res0: Option[Int] = Some(52)

Attributes

Inherited from:
Functor
Source
Functor.scala
override def map[A, B](fa: PSVec[A])(f: A => B): PSVec[B]

Attributes

Definition Classes
Inherited from:
Traverse
Source
Traverse.scala
def mapAccumulate[S, A, B](init: S, fa: PSVec[A])(f: (S, A) => (S, B)): (S, PSVec[B])

Akin to map, but allows to keep track of a state value when calling the function.

Akin to map, but allows to keep track of a state value when calling the function.

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def mapOrKeep[A, A1 >: A](fa: PSVec[A])(pf: PartialFunction[A, A1]): PSVec[A1]

Modifies the A value in F[A] with the supplied function, if the function is defined for the value. Example:

Modifies the A value in F[A] with the supplied function, if the function is defined for the value. Example:

scala> import cats.syntax.all._

scala> List(1, 2, 3).mapOrKeep { case 2 => 42 }
res0: List[Int] = List(1, 42, 3)

Attributes

Inherited from:
Functor
Source
Functor.scala
def mapWithIndex[A, B](fa: PSVec[A])(f: (A, Int) => B): PSVec[B]

Akin to map, but also provides the value's index in structure F when calling the function.

Akin to map, but also provides the value's index in structure F when calling the function.

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def mapWithLongIndex[A, B](fa: PSVec[A])(f: (A, Long) => B): PSVec[B]

Same as mapWithIndex but the index type is Long instead of Int.

Same as mapWithIndex but the index type is Long instead of Int.

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def maximumByList[A, B : Order](fa: PSVec[A])(f: A => B): List[A]

Find all the maximum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the maximum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

Attributes

See also

Reducible#maximumByNel for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

minimumByList for minimum instead of maximum.

Inherited from:
Foldable
Source
Foldable.scala
def maximumByOption[A, B : Order](fa: PSVec[A])(f: A => B): Option[A]

Find the maximum A item in this structure according to an Order.by(f).

Find the maximum A item in this structure according to an Order.by(f).

Attributes

Returns

None if the structure is empty, otherwise the maximum element wrapped in a Some.

See also

Reducible#maximumBy for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

minimumByOption for minimum instead of maximum.

Inherited from:
Foldable
Source
Foldable.scala
def maximumList[A](fa: PSVec[A])(implicit A: Order[A]): List[A]

Find all the maximum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the maximum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

Attributes

See also

Reducible#maximumNel for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

minimumList for minimum instead of maximum.

Inherited from:
Foldable
Source
Foldable.scala
def maximumOption[A](fa: PSVec[A])(implicit A: Order[A]): Option[A]

Find the maximum A item in this structure according to the Order[A].

Find the maximum A item in this structure according to the Order[A].

Attributes

Returns

None if the structure is empty, otherwise the maximum element wrapped in a Some.

See also

Reducible#maximum for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

minimumOption for minimum instead of maximum.

Inherited from:
Foldable
Source
Foldable.scala
def minimumByList[A, B : Order](fa: PSVec[A])(f: A => B): List[A]

Find all the minimum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the minimum A items in this structure according to an Order.by(f). For all elements in the result Order.eqv(x, y) is true. Preserves order.

Attributes

See also

Reducible#minimumByNel for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

maximumByList for maximum instead of minimum.

Inherited from:
Foldable
Source
Foldable.scala
def minimumByOption[A, B : Order](fa: PSVec[A])(f: A => B): Option[A]

Find the minimum A item in this structure according to an Order.by(f).

Find the minimum A item in this structure according to an Order.by(f).

Attributes

Returns

None if the structure is empty, otherwise the minimum element wrapped in a Some.

See also

Reducible#minimumBy for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

maximumByOption for maximum instead of minimum.

Inherited from:
Foldable
Source
Foldable.scala
def minimumList[A](fa: PSVec[A])(implicit A: Order[A]): List[A]

Find all the minimum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

Find all the minimum A items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.

Attributes

See also

Reducible#minimumNel for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

maximumList for maximum instead of minimum.

Inherited from:
Foldable
Source
Foldable.scala
def minimumOption[A](fa: PSVec[A])(implicit A: Order[A]): Option[A]

Find the minimum A item in this structure according to the Order[A].

Find the minimum A item in this structure according to the Order[A].

Attributes

Returns

None if the structure is empty, otherwise the minimum element wrapped in a Some.

See also

Reducible#minimum for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty.

maximumOption for maximum instead of minimum.

Inherited from:
Foldable
Source
Foldable.scala
override def nonEmpty[A](fa: PSVec[A]): Boolean

Attributes

Definition Classes
Inherited from:
Foldable
Source
Foldable.scala
def partitionBifold[H[_, _], A, B, C](fa: PSVec[A])(f: A => H[B, C])(implicit A: Alternative[PSVec], H: Bifoldable[H]): (PSVec[B], PSVec[C])

Separate this Foldable into a Tuple by a separating function A => H[B, C] for some Bifoldable[H] Equivalent to Functor#map and then Alternative#separate.

Separate this Foldable into a Tuple by a separating function A => H[B, C] for some Bifoldable[H] Equivalent to Functor#map and then Alternative#separate.

scala> import cats.syntax.all._, cats.Foldable, cats.data.Const
scala> val list = List(1,2,3,4)
scala> Foldable[List].partitionBifold(list)(a => ("value " + a.toString(), if (a % 2 == 0) -a else a))
res0: (List[String], List[Int]) = (List(value 1, value 2, value 3, value 4),List(1, -2, 3, -4))
scala> Foldable[List].partitionBifold(list)(a => Const[Int, Nothing with Any](a))
res1: (List[Int], List[Nothing with Any]) = (List(1, 2, 3, 4),List())

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def partitionBifoldM[G[_], H[_, _], A, B, C](fa: PSVec[A])(f: A => G[H[B, C]])(implicit A: Alternative[PSVec], M: Monad[G], H: Bifoldable[H]): G[(PSVec[B], PSVec[C])]

Separate this Foldable into a Tuple by an effectful separating function A => G[H[B, C]] for some Bifoldable[H] Equivalent to Traverse#traverse over Alternative#separate

Separate this Foldable into a Tuple by an effectful separating function A => G[H[B, C]] for some Bifoldable[H] Equivalent to Traverse#traverse over Alternative#separate

scala> import cats.syntax.all._, cats.Foldable, cats.data.Const
scala> val list = List(1,2,3,4)
`Const`'s second parameter is never instantiated, so we can use an impossible type:
scala> Foldable[List].partitionBifoldM(list)(a => Option(Const[Int, Nothing with Any](a)))
res0: Option[(List[Int], List[Nothing with Any])] = Some((List(1, 2, 3, 4),List()))

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def partitionEither[A, B, C](fa: PSVec[A])(f: A => Either[B, C])(implicit A: Alternative[PSVec]): (PSVec[B], PSVec[C])

Separate this Foldable into a Tuple by a separating function A => Either[B, C] Equivalent to Functor#map and then Alternative#separate.

Separate this Foldable into a Tuple by a separating function A => Either[B, C] Equivalent to Functor#map and then Alternative#separate.

scala> import cats.syntax.all._
scala> val list = List(1,2,3,4)
scala> Foldable[List].partitionEither(list)(a => if (a % 2 == 0) Left(a.toString) else Right(a))
res0: (List[String], List[Int]) = (List(2, 4),List(1, 3))
scala> Foldable[List].partitionEither(list)(a => Right(a * 4))
res1: (List[Nothing], List[Int]) = (List(),List(4, 8, 12, 16))

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def partitionEitherM[G[_], A, B, C](fa: PSVec[A])(f: A => G[Either[B, C]])(implicit A: Alternative[PSVec], M: Monad[G]): G[(PSVec[B], PSVec[C])]

Separate this Foldable into a Tuple by an effectful separating function A => G[Either[B, C]] Equivalent to Traverse#traverse over Alternative#separate

Separate this Foldable into a Tuple by an effectful separating function A => G[Either[B, C]] Equivalent to Traverse#traverse over Alternative#separate

scala> import cats.syntax.all._, cats.Foldable, cats.Eval
scala> val list = List(1,2,3,4)
scala> val partitioned1 = Foldable[List].partitionEitherM(list)(a => if (a % 2 == 0) Eval.now(Either.left[String, Int](a.toString)) else Eval.now(Either.right[String, Int](a)))
Since `Eval.now` yields a lazy computation, we need to force it to inspect the result:
scala> partitioned1.value
res0: (List[String], List[Int]) = (List(2, 4),List(1, 3))
scala> val partitioned2 = Foldable[List].partitionEitherM(list)(a => Eval.later(Either.right(a * 4)))
scala> partitioned2.value
res1: (List[Nothing], List[Int]) = (List(),List(4, 8, 12, 16))

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def productAll[A](fa: PSVec[A])(implicit A: Numeric[A]): A

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def reduceLeftOption[A](fa: PSVec[A])(f: (A, A) => A): Option[A]

Reduce the elements of this structure down to a single value by applying the provided aggregation function in a left-associative manner.

Reduce the elements of this structure down to a single value by applying the provided aggregation function in a left-associative manner.

Attributes

Returns

None if the structure is empty, otherwise the result of combining the cumulative left-associative result of the f operation over all of the elements.

See also

reduceRightOption for a right-associative alternative.

Reducible#reduceLeft for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty. Example:

scala> import cats.syntax.all._
scala> val l = List(6, 3, 2)
This is equivalent to (6 - 3) - 2
scala> Foldable[List].reduceLeftOption(l)(_ - _)
res0: Option[Int] = Some(1)
scala> Foldable[List].reduceLeftOption(List.empty[Int])(_ - _)
res1: Option[Int] = None
Inherited from:
Foldable
Source
Foldable.scala
def reduceLeftToOption[A, B](fa: PSVec[A])(f: A => B)(g: (B, A) => B): Option[B]

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def reduceRightOption[A](fa: PSVec[A])(f: (A, Eval[A]) => Eval[A]): Eval[Option[A]]

Reduce the elements of this structure down to a single value by applying the provided aggregation function in a right-associative manner.

Reduce the elements of this structure down to a single value by applying the provided aggregation function in a right-associative manner.

Attributes

Returns

None if the structure is empty, otherwise the result of combining the cumulative right-associative result of the f operation over the A elements.

See also

reduceLeftOption for a left-associative alternative

Reducible#reduceRight for a version that doesn't need to return an Option for structures that are guaranteed to be non-empty. Example:

scala> import cats.syntax.all._
scala> val l = List(6, 3, 2)
This is equivalent to 6 - (3 - 2)
scala> Foldable[List].reduceRightOption(l)((current, rest) => rest.map(current - _)).value
res0: Option[Int] = Some(5)
scala> Foldable[List].reduceRightOption(List.empty[Int])((current, rest) => rest.map(current - _)).value
res1: Option[Int] = None
Inherited from:
Foldable
Source
Foldable.scala
def reduceRightToOption[A, B](fa: PSVec[A])(f: A => B)(g: (A, Eval[B]) => Eval[B]): Eval[Option[B]]

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def sequence[G[_] : Applicative, A](fga: PSVec[G[A]]): G[PSVec[A]]

Thread all the G effects through the F structure to invert the structure from F[G[A]] to G[F[A]].

Thread all the G effects through the F structure to invert the structure from F[G[A]] to G[F[A]].

Example:

scala> import cats.syntax.all._
scala> val x: List[Option[Int]] = List(Some(1), Some(2))
scala> val y: List[Option[Int]] = List(None, Some(2))
scala> x.sequence
res0: Option[List[Int]] = Some(List(1, 2))
scala> y.sequence
res1: Option[List[Int]] = None

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def sequenceVoid[G[_] : Applicative, A](fga: PSVec[G[A]]): G[Unit]

Sequence F[G[A]] using Applicative[G].

Sequence F[G[A]] using Applicative[G].

This is similar to traverseVoid except it operates on F[G[A]] values, so no additional functions are needed.

For example:

scala> import cats.syntax.all._
scala> val F = Foldable[List]
scala> F.sequenceVoid(List(Option(1), Option(2), Option(3)))
res0: Option[Unit] = Some(())
scala> F.sequenceVoid(List(Option(1), None, Option(3)))
res1: Option[Unit] = None

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def sequence_[G[_] : Applicative, A](fga: PSVec[G[A]]): G[Unit]

Alias for sequenceVoid.

Alias for sequenceVoid.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def size[A](fa: PSVec[A]): Long

The size of this UnorderedFoldable.

The size of this UnorderedFoldable.

This is overridden in structures that have more efficient size implementations (e.g. Vector, Set, Map).

Note: will not terminate for infinite-sized collections.

Attributes

Inherited from:
UnorderedFoldable
Source
UnorderedFoldable.scala
def sumAll[A](fa: PSVec[A])(implicit A: Numeric[A]): A

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def takeWhile_[A](fa: PSVec[A])(p: A => Boolean): List[A]

Convert F[A] to a List[A], retaining only initial elements which match p.

Convert F[A] to a List[A], retaining only initial elements which match p.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def toIterable[A](fa: PSVec[A]): Iterable[A]

Convert F[A] to an Iterable[A].

Convert F[A] to an Iterable[A].

This method may be overridden for the sake of performance, but implementers should take care not to force a full materialization of the collection.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def toList[A](fa: PSVec[A]): List[A]

Convert F[A] to a List[A].

Convert F[A] to a List[A].

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def traverseTap[G[_] : Applicative, A, B](fa: PSVec[A])(f: A => G[B]): G[PSVec[A]]

Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[A] in a G context, ignoring the values returned by provided function.

Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[A] in a G context, ignoring the values returned by provided function.

Example:

scala> import cats.syntax.all._
scala> import java.io.IOException
scala> type IO[A] = Either[IOException, A]
scala> def debug(msg: String): IO[Unit] = Right(())
scala> List("1", "2", "3").traverseTap(debug)
res1: IO[List[String]] = Right(List(1, 2, 3))

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def traverseVoid[G[_], A, B](fa: PSVec[A])(f: A => G[B])(implicit G: Applicative[G]): G[Unit]

Traverse F[A] using Applicative[G].

Traverse F[A] using Applicative[G].

A values will be mapped into G[B] and combined using Applicative#map2.

For example:

scala> import cats.syntax.all._
scala> def parseInt(s: String): Option[Int] = Either.catchOnly[NumberFormatException](s.toInt).toOption
scala> val F = Foldable[List]
scala> F.traverseVoid(List("333", "444"))(parseInt)
res0: Option[Unit] = Some(())
scala> F.traverseVoid(List("333", "zzz"))(parseInt)
res1: Option[Unit] = None

This method is primarily useful when G[_] represents an action or effect, and the specific A aspect of G[A] is not otherwise needed.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def traverseWithIndexM[G[_], A, B](fa: PSVec[A])(f: (A, Int) => G[B])(implicit G: Monad[G]): G[PSVec[B]]

Akin to traverse, but also provides the value's index in structure F when calling the function.

Akin to traverse, but also provides the value's index in structure F when calling the function.

This performs the traversal in a single pass but requires that effect G is monadic. An applicative traversal can be performed in two passes using zipWithIndex followed by traverse.

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def traverseWithLongIndexM[G[_], A, B](fa: PSVec[A])(f: (A, Long) => G[B])(implicit G: Monad[G]): G[PSVec[B]]

Same as traverseWithIndexM but the index type is Long instead of Int.

Same as traverseWithIndexM but the index type is Long instead of Int.

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def traverse_[G[_], A, B](fa: PSVec[A])(f: A => G[B])(implicit G: Applicative[G]): G[Unit]

Alias for traverseVoid.

Alias for traverseVoid.

Attributes

Inherited from:
Foldable
Source
Foldable.scala
def tupleLeft[A, B](fa: PSVec[A], b: B): PSVec[(B, A)]

Tuples the A value in F[A] with the supplied B value, with the B value on the left.

Tuples the A value in F[A] with the supplied B value, with the B value on the left.

Example:

scala> import scala.collection.immutable.Queue
scala> import cats.syntax.all._

scala> Queue("hello", "world").tupleLeft(42)
res0: scala.collection.immutable.Queue[(Int, String)] = Queue((42,hello), (42,world))

Attributes

Inherited from:
Functor
Source
Functor.scala
def tupleRight[A, B](fa: PSVec[A], b: B): PSVec[(A, B)]

Tuples the A value in F[A] with the supplied B value, with the B value on the right.

Tuples the A value in F[A] with the supplied B value, with the B value on the right.

Example:

scala> import scala.collection.immutable.Queue
scala> import cats.syntax.all._

scala> Queue("hello", "world").tupleRight(42)
res0: scala.collection.immutable.Queue[(String, Int)] = Queue((hello,42), (world,42))

Attributes

Inherited from:
Functor
Source
Functor.scala
override def unorderedFold[A : CommutativeMonoid](fa: PSVec[A]): A

Attributes

Definition Classes
Inherited from:
Foldable
Source
Foldable.scala
override def unorderedFoldMap[A, B : CommutativeMonoid](fa: PSVec[A])(f: A => B): B

Attributes

Definition Classes
Inherited from:
Foldable
Source
Foldable.scala
def unorderedFoldMapA[G[_], A, B](fa: PSVec[A])(f: A => G[B])(implicit G: CommutativeApplicative[G], B: CommutativeMonoid[B]): G[B]

Fold in a CommutativeApplicative context by mapping the A values to G[B]. combining the B values using the given CommutativeMonoid[B] instance.

Fold in a CommutativeApplicative context by mapping the A values to G[B]. combining the B values using the given CommutativeMonoid[B] instance.

scala> import cats.UnorderedFoldable
scala> import cats.syntax.all._
scala> val evenNumbers = Set(2,4,6,8,10)
scala> val evenOpt: Int => Option[Int] =
    |   i => if (i % 2 == 0) Some(i) else None
scala> UnorderedFoldable[Set].unorderedFoldMapA(evenNumbers)(evenOpt)
res0: Option[Int] = Some(30)
scala> UnorderedFoldable[Set].unorderedFoldMapA(evenNumbers + 11)(evenOpt)
res1: Option[Int] = None

Attributes

Inherited from:
UnorderedFoldable
Source
UnorderedFoldable.scala
override def unorderedSequence[G[_] : CommutativeApplicative, A](fga: PSVec[G[A]]): G[PSVec[A]]

Attributes

Definition Classes
Inherited from:
Traverse
Source
Traverse.scala
override def unorderedTraverse[G[_] : CommutativeApplicative, A, B](sa: PSVec[A])(f: A => G[B]): G[PSVec[B]]

Attributes

Definition Classes
Inherited from:
Traverse
Source
Traverse.scala
def unzip[A, B](fab: PSVec[(A, B)]): (PSVec[A], PSVec[B])

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

Un-zips an F[(A, B)] consisting of element pairs or Tuple2 into two separate F's tupled.

NOTE: Check for effect duplication, possibly memoize before

scala> import cats.Functor
scala> import cats.syntax.all._

scala> Functor[List].unzip(List((1,2), (3, 4)))
res0: (List[Int], List[Int]) = (List(1, 3),List(2, 4))

Attributes

Inherited from:
Functor
Source
Functor.scala
def updated_[A, B >: A](fa: PSVec[A], idx: Long, b: B): Option[PSVec[B]]

If fa contains the element at index idx, return the copy of fa where the element at idx is replaced with b. If there is no element with such an index, return None.

If fa contains the element at index idx, return the copy of fa where the element at idx is replaced with b. If there is no element with such an index, return None.

The behavior is consistent with the Scala collection library's updated for collections such as List.

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def void[A](fa: PSVec[A]): PSVec[Unit]

Empty the fa of the values, preserving the structure

Empty the fa of the values, preserving the structure

Example:

scala> import cats.syntax.all._

scala> List(1,2,3).void
res0: List[Unit] = List((), (), ())

Attributes

Inherited from:
Functor
Source
Functor.scala
def widen[A, B >: A](fa: PSVec[A]): PSVec[B]

Lifts natural subtyping covariance of covariant Functors.

Lifts natural subtyping covariance of covariant Functors.

NOTE: In certain (perhaps contrived) situations that rely on universal equality this can result in a ClassCastException, because it is implemented as a type cast. It could be implemented as map(identity), but according to the functor laws, that should be equal to fa, and a type cast is often much more performant. See this example of widen creating a ClassCastException.

Example:

scala> import cats.syntax.all._

scala> val l = List(Some(42))
scala> l.widen[Option[Int]]
res0: List[Option[Int]] = List(Some(42))

Attributes

Inherited from:
Functor
Source
Functor.scala
def zipWithIndex[A](fa: PSVec[A]): PSVec[(A, Int)]

Traverses through the structure F, pairing the values with assigned indices.

Traverses through the structure F, pairing the values with assigned indices.

The behavior is consistent with the Scala collection library's zipWithIndex for collections such as List.

Attributes

Inherited from:
Traverse
Source
Traverse.scala
def zipWithLongIndex[A](fa: PSVec[A]): PSVec[(A, Long)]

Same as zipWithIndex but the index type is Long instead of Int.

Same as zipWithIndex but the index type is Long instead of Int.

Attributes

Inherited from:
Traverse
Source
Traverse.scala
Generated with