Product (cyclops-reactor 9.0.0-FINAL API)

java.lang.Object
- cyclops.typeclasses.Product<W1,W2,T>

All Implemented Interfaces:

Convert<Higher<Higher<Higher<Witness.product,W1>,W2>,T>>, Higher<Higher<Higher<Witness.product,W1>,W2>,T>, Higher2<Higher<Witness.product,W1>,W2,T>, Higher3<Witness.product,W1,W2,T>, Filters<T>, To<Product<W1,W2,T>>, Transformable<T>
```
public class Product<W1,W2,T>
extends java.lang.Object
implements Filters<T>, Higher3<Witness.product,W1,W2,T>, Transformable<T>, To<Product<W1,W2,T>>
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Product.Instances<W1,W2>

class Product.Plus

class Product.Unfolds

Nested Classes
Modifier and Type	Class and Description
`static class`	`Product.Instances<W1,W2>`
`class`	`Product.Plus`
`class`	`Product.Unfolds`

Constructor Summary

Constructors
Constructor and Description

Product()

Constructors
Constructor and Description
`Product()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Active<W1,T>`	`activeFirst(SemigroupK<W1,T> sg, Higher<W1,T> concat)`
`Active<W2,T>`	`activeSecond(SemigroupK<W2,T> sg, Higher<W2,T> concat)`
`Active<Higher<Higher<Witness.product,W1>,W2>,T>`	`allTypeClasses()`
`org.jooq.lambda.tuple.Tuple2<Active<W1,T>,Active<W2,T>>`	`asActiveTuple()`
`org.jooq.lambda.tuple.Tuple2<Higher<W1,T>,Higher<W2,T>>`	`asTuple()`
`<U> Product<W1,W2,U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a reactiveStream to a given type, possibly throwing a `ClassCastException`.
`Coproduct<W1,W2,T>`	`coproduct(java.util.function.BiPredicate<Higher<W1,T>,Higher<W2,T>> test)`
`Product<W1,W2,T>`	`filter(java.util.function.Predicate<? super T> test)` Keep only elements for which the supplied predicates hold e.g.
`Product<W1,W2,T>`	`filterNot(java.util.function.Predicate<? super T> predicate)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R> Product<W1,W2,R>`	`flatMap(java.util.function.Function<? super T,? extends Product<W1,W2,R>> fn)`
`<C2,T> Higher<C2,Product<W1,W2,T>>`	`flatSequenceA(Applicative<C2> applicative, Product<W1,W2,Higher<C2,Product<W1,W2,T>>> fgfa)`
`<C2,R> Higher<C2,Product<W1,W2,R>>`	`flatTraverseA(Applicative<C2> applicative, java.util.function.Function<? super T,? extends Higher<C2,Product<W1,W2,R>>> f)`
`T`	`foldLeft(Monoid<T> monoid)`
`T`	`foldLeft(T identity, java.util.function.BinaryOperator<T> semigroup)`
`org.jooq.lambda.tuple.Tuple2<T,T>`	`foldLeftTuple(Monoid<T> monoid)`
`org.jooq.lambda.tuple.Tuple2<T,T>`	`foldLeftTuple(T identity, java.util.function.BinaryOperator<T> semigroup)`
`<R> R`	`foldMap(Monoid<R> mb, java.util.function.Function<? super T,? extends R> fn)`
`<R> org.jooq.lambda.tuple.Tuple2<R,R>`	`foldMapTuple(Monoid<R> mb, java.util.function.Function<? super T,? extends R> fn)`
`T`	`foldRight(Monoid<T> monoid)`
`T`	`foldRight(T identity, java.util.function.BinaryOperator<T> semigroup)`
`org.jooq.lambda.tuple.Tuple2<T,T>`	`foldRightTuple(Monoid<T> monoid)`
`org.jooq.lambda.tuple.Tuple2<T,T>`	`foldRightTuple(T identity, java.util.function.BinaryOperator<T> semigroup)`
`<R1,R> Product<W1,W2,R>`	`forEach2(java.util.function.Function<? super T,? extends Product<W1,W2,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<T2,R1,R2,R> Product<W1,W2,R>`	`forEach3(java.util.function.Function<? super T,? extends Product<W1,W2,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends Product<W1,W2,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<T2,R1,R2,R3,R> Product<W1,W2,R>`	`forEach4(java.util.function.Function<? super T,? extends Product<W1,W2,R1>> value1, java.util.function.BiFunction<? super T,? super R1,? extends Product<W1,W2,R2>> value2, Fn3<? super T,? super R1,? super R2,? extends Product<W1,W2,R3>> value3, Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`<R> Product<W1,W2,R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> Product<W1,W2,R>`	`mapWithIndex(java.util.function.BiFunction<? super T,java.lang.Long,? extends R> f)`
`static <W1,W2,T> Product<W1,W2,T>`	`narrowK(Higher<Higher<Higher<Witness.product,W1>,W2>,T> ds)`
`Product<W1,W2,T>`	`notNull()` Filter elements retaining only values which are not null
`static <W1,W2,T> Product<W1,W2,T>`	`of(Active<W1,T> a1, Active<W2,T> a2)`
`static <W1,W2,T> Product<W1,W2,T>`	`of(org.jooq.lambda.tuple.Tuple2<Higher<W1,T>,Higher<W2,T>> run, InstanceDefinitions<W1> def1, InstanceDefinitions<W2> def2)`
`<U> Product<W1,W2,U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a reactiveStream that are of a given type.
`Product<W1,W2,T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`Maybe<Product.Plus>`	`plus()`
`Product<W1,W2,T>`	`plusFirst(SemigroupK<W1,T> semigroupK, Higher<W1,T> add)`
`Product<W1,W2,T>`	`plusSecond(SemigroupK<W2,T> semigroupK, Higher<W2,T> add)`
`Product.Plus`	`plusUnsafe()`
`<R> Product<W1,W2,R>`	`retry(java.util.function.Function<? super T,? extends R> fn)` Retry a transformation if it fails.
`<R> Product<W1,W2,R>`	`retry(java.util.function.Function<? super T,? extends R> fn, int retries, long delay, java.util.concurrent.TimeUnit timeUnit)` Retry a transformation if it fails.
`Product<W1,W2,T>`	`reverse()`
`<C2,T> Higher<C2,Product<W1,W2,T>>`	`sequenceA(Applicative<C2> applicative, Product<W1,W2,Higher<C2,T>> ds)`
`org.jooq.lambda.tuple.Tuple2<java.lang.Long,java.lang.Long>`	`size()`
`org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>>`	`stream()`
`ReactiveSeq<T>`	`streamBoth()`
`Product<W2,W1,T>`	`swap()`
`<R> Active<W1,R>`	`tailRec1(T initial, java.util.function.Function<? super T,? extends Higher<W1,? extends Xor<T,R>>> fn)`
`<R> Active<W2,R>`	`tailRec2(T initial, java.util.function.Function<? super T,? extends Higher<W2,? extends Xor<T,R>>> fn)`
`org.jooq.lambda.tuple.Tuple2<ListX<T>,ListX<T>>`	`toListX()`
`ListX<T>`	`toListXBoth()`
`java.lang.String`	`toString()`
`long`	`totalSize()`
`<R> Product<W1,W2,R>`	`trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`<C2,R> Higher<C2,Product<W1,W2,R>>`	`traverseA(Applicative<C2> applicative, java.util.function.Function<? super T,? extends Higher<C2,R>> fn)`
`static <W1,W2,T,C2,R> Higher<C2,Product<W1,W2,R>>`	`traverseA(Applicative<C2> applicative, java.util.function.Function<? super T,? extends Higher<C2,R>> fn, Product<W1,W2,T> n)`
`Maybe<Product.Unfolds>`	`unfolds()`
`Product.Unfolds`	`unfoldsDefault()`
`Active<W1,T>`	`v1()`
`Active<W2,T>`	`v2()`
`<R> R`	`visit(java.util.function.BiFunction<? super Higher<W1,? super T>,? super Higher<W2,? super T>,? extends R> visitor)`
`<R> R`	`visitA(java.util.function.BiFunction<? super Active<W1,? super T>,? super Active<W2,? super T>,? extends R> visitor)`
`Product<W1,W2,org.jooq.lambda.tuple.Tuple2<T,T>>`	`zip(Product<W1,W2,T> p2)`
`<R> Product<W1,W2,R>`	`zip(Product<W1,W2,T> p2, java.util.function.BiFunction<? super T,? super T,? extends R> zipper)`
`Product<W1,W2,org.jooq.lambda.tuple.Tuple3<T,T,T>>`	`zip(Product<W1,W2,T> p2, Product<W1,W2,T> p3)`
`<R> Product<W1,W2,R>`	`zip(Product<W1,W2,T> p2, Product<W1,W2,T> p3, Fn3<? super T,? super T,? super T,? extends R> zipper)`
`<R> Product<W1,W2,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()`
`<W2,T2,R> Active<W1,R>`	`zipWithSecond(java.util.function.BiFunction<? super T,? super Maybe<T>,? extends R> f)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.aol.cyclops2.hkt.Higher
applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.aol.cyclops2.hkt.Convert
convert

Methods inherited from interface com.aol.cyclops2.types.foldable.To
to

Constructor Detail
- Product
```
public Product()
```

Method Detail

asTuple

public org.jooq.lambda.tuple.Tuple2<Higher<W1,T>,Higher<W2,T>> asTuple()

asActiveTuple

public org.jooq.lambda.tuple.Tuple2<Active<W1,T>,Active<W2,T>> asActiveTuple()

v1
```
public Active<W1,T> v1()
```

v2
```
public Active<W2,T> v2()
```

of

public static <W1,W2,T> Product<W1,W2,T> of(org.jooq.lambda.tuple.Tuple2<Higher<W1,T>,Higher<W2,T>> run,
                                            InstanceDefinitions<W1> def1,
                                            InstanceDefinitions<W2> def2)

of

public static <W1,W2,T> Product<W1,W2,T> of(Active<W1,T> a1,
                                            Active<W2,T> a2)

coproduct

public Coproduct<W1,W2,T> coproduct(java.util.function.BiPredicate<Higher<W1,T>,Higher<W2,T>> test)

filter
```
public Product<W1,W2,T> filter(java.util.function.Predicate<? super T> test)
```
Description copied from interface: Filters
Keep only elements for which the supplied predicates hold e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[3]
   
 
 
```
Specified by:

filter in interface Filters<T>

Parameters:

test - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

ofType

public <U> Product<W1,W2,U> ofType(java.lang.Class<? extends U> type)

Description copied from interface: Filters

Keep only those elements in a reactiveStream that are of a given type.

  
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)

Specified by:: ofType in interface Filters<T>

filterNot
```
public Product<W1,W2,T> filterNot(java.util.function.Predicate<? super T> predicate)
```
Description copied from interface: Filters
Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
  
   
     of(1,2,3).filter(i->i>2);
     
     //[1,2]
   
 
 
```
Specified by:

filterNot in interface Filters<T>

Parameters:

predicate - to filter elements by, retaining matches

Returns:

Filters with elements removed where the predicate does not hold

notNull
```
public Product<W1,W2,T> notNull()
```
Description copied from interface: Filters
Filter elements retaining only values which are not null
```
  
 
   of(1,2,null,4).nonNull();
 
   //[1,2,4]
   
 
 
```
Specified by:

notNull in interface Filters<T>

Returns:

Filters with nulls removed

cast
```
public <U> Product<W1,W2,U> cast(java.lang.Class<? extends U> type)
```
Description copied from interface: Transformable

Cast all elements in a reactiveStream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)

Specified by:

cast in interface Transformable<T>

zipWithSecond

public <W2,T2,R> Active<W1,R> zipWithSecond(java.util.function.BiFunction<? super T,? super Maybe<T>,? extends R> f)

zip

public Product<W1,W2,org.jooq.lambda.tuple.Tuple2<T,T>> zip(Product<W1,W2,T> p2)

zip

public Product<W1,W2,org.jooq.lambda.tuple.Tuple3<T,T,T>> zip(Product<W1,W2,T> p2,
                                                              Product<W1,W2,T> p3)

zip

public <R> Product<W1,W2,R> zip(Product<W1,W2,T> p2,
                                java.util.function.BiFunction<? super T,? super T,? extends R> zipper)

zip

public <R> Product<W1,W2,R> zip(Product<W1,W2,T> p2,
                                Product<W1,W2,T> p3,
                                Fn3<? super T,? super T,? super T,? extends R> zipper)

mapWithIndex

public <R> Product<W1,W2,R> mapWithIndex(java.util.function.BiFunction<? super T,java.lang.Long,? extends R> f)

zipWithIndex

public <R> Product<W1,W2,org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()

map
```
public <R> Product<W1,W2,R> map(java.util.function.Function<? super T,? extends R> fn)
```
Description copied from interface: Transformable
Transform this functor using the supplied transformation function
```
 


    of(1,2,3).map(i->i*2)

    //[2,4,6]

 
 
```
Specified by:

map in interface Transformable<T>

Parameters:

fn - Transformation function

Returns:

Transformed Transformable

flatMap

public <R> Product<W1,W2,R> flatMap(java.util.function.Function<? super T,? extends Product<W1,W2,R>> fn)

peek
```
public Product<W1,W2,T> peek(java.util.function.Consumer<? super T> c)
```
Description copied from interface: Transformable
Peek at the current value of this Transformable, without transforming it
```
 


    of(1,2,3).map(System.out::println)

    1
    2
    3

 
 
```
Specified by:

peek in interface Transformable<T>

Parameters:

c - Consumer that recieves each element from this Transformable

Returns:

Transformable that will peek at each value

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

trampoline

public <R> Product<W1,W2,R> trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)

Description copied from interface: Transformable

Performs a map operation that can call a recursive method without running out of stack space

 
 ReactiveSeq.of(10,20,30,40)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);

    	Trampoline<Long> fibonacci(int i){
    		return fibonacci(i,1,0);
    	}
    	Trampoline<Long> fibonacci(int n, long a, long b) {
        	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
    	}

 55
    	6765
    	832040
    	102334155


 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
    			 .trampoline(i-> fibonacci(i))
    			 .forEach(System.out::println);


 completes successfully

Specified by:: trampoline in interface Transformable<T>
Parameters:: mapper - TCO Transformation function
Returns:: Transformable transformed by the supplied transformation function

retry

public <R> Product<W1,W2,R> retry(java.util.function.Function<? super T,? extends R> fn)

Description copied from interface: Transformable

Retry a transformation if it fails. Default settings are to retry up to 7 times, with an doubling backoff period starting @ 2 seconds delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock)
 				.firstValue();

 		//result = 42

Specified by:: retry in interface Transformable<T>
Parameters:: fn - Function to retry if fails

retry

public <R> Product<W1,W2,R> retry(java.util.function.Function<? super T,? extends R> fn,
                                  int retries,
                                  long delay,
                                  java.util.concurrent.TimeUnit timeUnit)

Description copied from interface: Transformable

Retry a transformation if it fails. Retries up to retries times, with an doubling backoff period starting @ delay TimeUnits delay before retry.

 
 given(serviceMock.applyHKT(anyInt())).willThrow(
 				new RuntimeException(new SocketException("First")),
 				new RuntimeException(new IOException("Second"))).willReturn(
 				"42");


 		String result = ReactiveSeq.of( 1,  2, 3)
 				.retry(serviceMock, 7, 2, TimeUnit.SECONDS)
 				.firstValue();

 		//result = 42

Specified by:: retry in interface Transformable<T>
Parameters:: fn - Function to retry if fails; retries - Number of retries; delay - Delay in TimeUnits; timeUnit - TimeUnit to use for delay

tailRec1

public <R> Active<W1,R> tailRec1(T initial,
                                 java.util.function.Function<? super T,? extends Higher<W1,? extends Xor<T,R>>> fn)

tailRec2

public <R> Active<W2,R> tailRec2(T initial,
                                 java.util.function.Function<? super T,? extends Higher<W2,? extends Xor<T,R>>> fn)

activeFirst

public Active<W1,T> activeFirst(SemigroupK<W1,T> sg,
                                Higher<W1,T> concat)

activeSecond

public Active<W2,T> activeSecond(SemigroupK<W2,T> sg,
                                 Higher<W2,T> concat)

visit

public <R> R visit(java.util.function.BiFunction<? super Higher<W1,? super T>,? super Higher<W2,? super T>,? extends R> visitor)

visitA

public <R> R visitA(java.util.function.BiFunction<? super Active<W1,? super T>,? super Active<W2,? super T>,? extends R> visitor)

plusFirst

public Product<W1,W2,T> plusFirst(SemigroupK<W1,T> semigroupK,
                                  Higher<W1,T> add)

plusSecond

public Product<W1,W2,T> plusSecond(SemigroupK<W2,T> semigroupK,
                                   Higher<W2,T> add)

swap
```
public Product<W2,W1,T> swap()
```

unfoldsDefault

public Product.Unfolds unfoldsDefault()

unfolds

public Maybe<Product.Unfolds> unfolds()

plusUnsafe
```
public Product.Plus plusUnsafe()
```

plus
```
public Maybe<Product.Plus> plus()
```

foldMap

public <R> R foldMap(Monoid<R> mb,
                     java.util.function.Function<? super T,? extends R> fn)

foldRight
```
public T foldRight(Monoid<T> monoid)
```

foldRight

public T foldRight(T identity,
                   java.util.function.BinaryOperator<T> semigroup)

toListX

public org.jooq.lambda.tuple.Tuple2<ListX<T>,ListX<T>> toListX()

toListXBoth
```
public ListX<T> toListXBoth()
```

stream

public org.jooq.lambda.tuple.Tuple2<ReactiveSeq<T>,ReactiveSeq<T>> stream()

streamBoth
```
public ReactiveSeq<T> streamBoth()
```

reverse
```
public Product<W1,W2,T> reverse()
```

size

public org.jooq.lambda.tuple.Tuple2<java.lang.Long,java.lang.Long> size()

totalSize
```
public long totalSize()
```

foldLeft
```
public T foldLeft(Monoid<T> monoid)
```

foldLeft

public T foldLeft(T identity,
                  java.util.function.BinaryOperator<T> semigroup)

foldMapTuple

public <R> org.jooq.lambda.tuple.Tuple2<R,R> foldMapTuple(Monoid<R> mb,
                                                          java.util.function.Function<? super T,? extends R> fn)

foldRightTuple

public org.jooq.lambda.tuple.Tuple2<T,T> foldRightTuple(Monoid<T> monoid)

foldRightTuple

public org.jooq.lambda.tuple.Tuple2<T,T> foldRightTuple(T identity,
                                                        java.util.function.BinaryOperator<T> semigroup)

foldLeftTuple

public org.jooq.lambda.tuple.Tuple2<T,T> foldLeftTuple(Monoid<T> monoid)

foldLeftTuple

public org.jooq.lambda.tuple.Tuple2<T,T> foldLeftTuple(T identity,
                                                       java.util.function.BinaryOperator<T> semigroup)

forEach2

public <R1,R> Product<W1,W2,R> forEach2(java.util.function.Function<? super T,? extends Product<W1,W2,R1>> value1,
                                        java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

forEach3

public <T2,R1,R2,R> Product<W1,W2,R> forEach3(java.util.function.Function<? super T,? extends Product<W1,W2,R1>> value1,
                                              java.util.function.BiFunction<? super T,? super R1,? extends Product<W1,W2,R2>> value2,
                                              Fn3<? super T,? super R1,? super R2,? extends R> yieldingFunction)

forEach4

public <T2,R1,R2,R3,R> Product<W1,W2,R> forEach4(java.util.function.Function<? super T,? extends Product<W1,W2,R1>> value1,
                                                 java.util.function.BiFunction<? super T,? super R1,? extends Product<W1,W2,R2>> value2,
                                                 Fn3<? super T,? super R1,? super R2,? extends Product<W1,W2,R3>> value3,
                                                 Fn4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

narrowK

public static <W1,W2,T> Product<W1,W2,T> narrowK(Higher<Higher<Higher<Witness.product,W1>,W2>,T> ds)

allTypeClasses

public Active<Higher<Higher<Witness.product,W1>,W2>,T> allTypeClasses()

traverseA

public <C2,R> Higher<C2,Product<W1,W2,R>> traverseA(Applicative<C2> applicative,
                                                    java.util.function.Function<? super T,? extends Higher<C2,R>> fn)

traverseA

public static <W1,W2,T,C2,R> Higher<C2,Product<W1,W2,R>> traverseA(Applicative<C2> applicative,
                                                                   java.util.function.Function<? super T,? extends Higher<C2,R>> fn,
                                                                   Product<W1,W2,T> n)

sequenceA

public <C2,T> Higher<C2,Product<W1,W2,T>> sequenceA(Applicative<C2> applicative,
                                                    Product<W1,W2,Higher<C2,T>> ds)

flatTraverseA

public <C2,R> Higher<C2,Product<W1,W2,R>> flatTraverseA(Applicative<C2> applicative,
                                                        java.util.function.Function<? super T,? extends Higher<C2,Product<W1,W2,R>>> f)

flatSequenceA

public <C2,T> Higher<C2,Product<W1,W2,T>> flatSequenceA(Applicative<C2> applicative,
                                                        Product<W1,W2,Higher<C2,Product<W1,W2,T>>> fgfa)

Class Product<W1,W2,T>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops2.hkt.Higher

Methods inherited from interface com.aol.cyclops2.hkt.Convert

Methods inherited from interface com.aol.cyclops2.types.foldable.To

Constructor Detail

Product

Method Detail

asTuple

asActiveTuple

v1

v2

of

of

coproduct

filter

ofType

filterNot

notNull

cast

zipWithSecond

zip

zip

zip

zip

mapWithIndex

zipWithIndex

map

flatMap

peek

toString

trampoline

retry

retry

tailRec1

tailRec2

activeFirst

activeSecond

visit

visitA

plusFirst

plusSecond

swap

unfoldsDefault

unfolds

plusUnsafe

plus

foldMap

foldRight

foldRight

toListX

toListXBoth

stream

streamBoth

reverse

size

totalSize

foldLeft

foldLeft

foldMapTuple

foldRightTuple

foldRightTuple

foldLeftTuple

foldLeftTuple

forEach2

forEach3

forEach4

narrowK

allTypeClasses

traverseA

traverseA

sequenceA

flatTraverseA

flatSequenceA