Copyright 2008 - 2009 Tony Morris, Runar Bjarnason, Tom Adams, Brad Clow, Ricky Clarkson

This software is released under an open source BSD licence.

fj
Class P2<A,B>

java.lang.Object
  extended by fj.P2<A,B>

public abstract class P2<A,B>
extends Object

A product-2.

Version:
2.20

Constructor Summary
P2()
           
 
Method Summary
static
<A,B> F<P2<A,B>,A>
__1()
          Returns a function that returns the first element of a product.
static
<A,B> F<P2<A,B>,B>
__2()
          Returns a function that returns the second element of a product.
abstract  A _1()
          Access the first element of the product.
abstract  B _2()
          Access the second element of the product.
<C> P2<C,B>
cobind(F<P2<A,B>,C> k)
          Duplicates this product on the first element, and maps the given function across the duplicate (Comonad pattern).
 P2<P2<A,B>,B> duplicate()
          Duplicates this product into the first element (Comonad pattern).
static
<B,C,D> P2<C,D>
fanout(F<B,C> f, F<B,D> g, B b)
          Sends the given input value to both argument functions and combines their output.
<C> P2<C,B>
inject(C c)
          Replaces the first element of this product with the given value.
static
<A,B> P2<B,B>
map(F<A,B> f, P2<A,A> p)
          Maps the given function across both the elements of the given product.
static
<A,B,X> F<P2<A,B>,P2<X,B>>
map1_(F<A,X> f)
          Promotes a function so that it maps the first element of a product.
<X> P2<X,B>
map1(F<A,X> f)
          Map the first element of the product.
static
<A,B,X> F<P2<A,B>,P2<A,X>>
map2_(F<B,X> f)
          Promotes a function so that it maps the second element of a product.
<X> P2<A,X>
map2(F<B,X> f)
          Map the second element of the product.
<C> List<C>
sequenceW(List<F<P2<A,B>,C>> fs)
          Applies a list of comonadic functions to this product, returning a list of values.
<C> Stream<C>
sequenceW(Stream<F<P2<A,B>,C>> fs)
          Applies a stream of comonadic functions to this product, returning a stream of values.
static
<A,B,C,D> F<P2<A,B>,P2<C,D>>
split_(F<A,C> f, F<B,D> g)
          A first-class version of the split function.
<C,D> P2<C,D>
split(F<A,C> f, F<B,D> g)
          Split this product between two argument functions and combine their output.
static
<A,B> F<P2<A,B>,P2<B,A>>
swap_()
          Returns a curried form of swap().
 P2<B,A> swap()
          Swaps the elements around in this product.
static
<A,B,C> F<P2<A,B>,C>
tuple(F<A,F<B,C>> f)
          Transforms a curried function of arity-2 to a function of a product-2
static
<A,B,C> F<P2<A,B>,C>
tuple(F2<A,B,C> f)
          Transforms an uncurried function of arity-2 to a function of a product-2
static
<A,B,C> F2<A,B,C>
untuple(F<P2<A,B>,C> f)
          Transforms a function of a product-2 to an uncurried function or arity-2.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

P2

public P2()
Method Detail

_1

public abstract A _1()
Access the first element of the product.

Returns:
The first element of the product.

_2

public abstract B _2()
Access the second element of the product.

Returns:
The second element of the product.

swap

public P2<B,A> swap()
Swaps the elements around in this product.

Returns:
A new product-2 with the elements swapped.

map1

public <X> P2<X,B> map1(F<A,X> f)
Map the first element of the product.

Parameters:
f - The function to map with.
Returns:
A product with the given function applied.

map2

public <X> P2<A,X> map2(F<B,X> f)
Map the second element of the product.

Parameters:
f - The function to map with.
Returns:
A product with the given function applied.

split

public <C,D> P2<C,D> split(F<A,C> f,
                           F<B,D> g)
Split this product between two argument functions and combine their output.

Parameters:
f - A function that will map the first element of this product.
g - A function that will map the second element of this product.
Returns:
A new product with the first function applied to the second element and the second function applied to the second element.

cobind

public <C> P2<C,B> cobind(F<P2<A,B>,C> k)
Duplicates this product on the first element, and maps the given function across the duplicate (Comonad pattern).

Parameters:
k - A function to map over the duplicated product.
Returns:
A new product with the result of the given function applied to this product as the first element, and with the second element intact.

duplicate

public P2<P2<A,B>,B> duplicate()
Duplicates this product into the first element (Comonad pattern).

Returns:
A new product with this product in its first element and with the second element intact.

inject

public <C> P2<C,B> inject(C c)
Replaces the first element of this product with the given value.

Parameters:
c - The value with which to replace the first element of this product.
Returns:
A new product with the first element replaced with the given value.

sequenceW

public <C> List<C> sequenceW(List<F<P2<A,B>,C>> fs)
Applies a list of comonadic functions to this product, returning a list of values.

Parameters:
fs - A list of functions to apply to this product.
Returns:
A list of the results of applying the given list of functions to this product.

sequenceW

public <C> Stream<C> sequenceW(Stream<F<P2<A,B>,C>> fs)
Applies a stream of comonadic functions to this product, returning a stream of values.

Parameters:
fs - A stream of functions to apply to this product.
Returns:
A stream of the results of applying the given stream of functions to this product.

split_

public static <A,B,C,D> F<P2<A,B>,P2<C,D>> split_(F<A,C> f,
                                                  F<B,D> g)
A first-class version of the split function.

Parameters:
f - A function that will map the first element of the given product.
g - A function that will map the second element of the given product.
Returns:
A function that splits a given product between the two given functions and combines their output.

map1_

public static <A,B,X> F<P2<A,B>,P2<X,B>> map1_(F<A,X> f)
Promotes a function so that it maps the first element of a product.

Parameters:
f - The function to promote.
Returns:
The given function, promoted to map the first element of products.

map2_

public static <A,B,X> F<P2<A,B>,P2<A,X>> map2_(F<B,X> f)
Promotes a function so that it maps the second element of a product.

Parameters:
f - The function to promote.
Returns:
The given function, promoted to map the second element of products.

fanout

public static <B,C,D> P2<C,D> fanout(F<B,C> f,
                                     F<B,D> g,
                                     B b)
Sends the given input value to both argument functions and combines their output.

Parameters:
f - A function to receive an input value.
g - A function to receive an input value.
b - An input value to send to both functions.
Returns:
The product of the two functions applied to the input value.

map

public static <A,B> P2<B,B> map(F<A,B> f,
                                P2<A,A> p)
Maps the given function across both the elements of the given product.

Parameters:
f - A function to map over a product.
p - A product over which to map.
Returns:
A new product with the given function applied to both elements.

swap_

public static <A,B> F<P2<A,B>,P2<B,A>> swap_()
Returns a curried form of swap().

Returns:
A curried form of swap().

__1

public static <A,B> F<P2<A,B>,A> __1()
Returns a function that returns the first element of a product.

Returns:
A function that returns the first element of a product.

__2

public static <A,B> F<P2<A,B>,B> __2()
Returns a function that returns the second element of a product.

Returns:
A function that returns the second element of a product.

tuple

public static <A,B,C> F<P2<A,B>,C> tuple(F<A,F<B,C>> f)
Transforms a curried function of arity-2 to a function of a product-2

Parameters:
f - a curried function of arity-2 to transform into a function of a product-2
Returns:
The function, transformed to operate on on a product-2

tuple

public static <A,B,C> F<P2<A,B>,C> tuple(F2<A,B,C> f)
Transforms an uncurried function of arity-2 to a function of a product-2

Parameters:
f - an uncurried function of arity-2 to transform into a function of a product-2
Returns:
The function, transformed to operate on on a product-2

untuple

public static <A,B,C> F2<A,B,C> untuple(F<P2<A,B>,C> f)
Transforms a function of a product-2 to an uncurried function or arity-2.

Parameters:
f - A function of a product-2 to transform into an uncurried function.
Returns:
The function, transformed to an uncurried function of arity-2.

Copyright 2008 - 2009 Tony Morris, Runar Bjarnason, Tom Adams, Brad Clow, Ricky Clarkson

This software is released under an open source BSD licence.