Struct Coend 

pub struct Coend<P, A>
where
    P: HKT2,
{
    pub value: <P as HKT2>::P<A, A>,
}

A Coend for profunctor P: represents ∫^A P(A, A), i.e., exists A. P(A, A).

In category theory, the coend of a profunctor P: C^op × C -> Set is the universal cowedge — a value P(A, A) for SOME (existentially hidden) type A.

Since Rust lacks first-class existential types, the type parameter A is exposed (following the same pragmatic approach as Lan<G, H, A, B> in karpal-free). Users should treat A as opaque when consuming coend values.

Construction

use karpal_core::coend::Coend;
use karpal_core::hkt::TupleF;

// A coend value: exists some A such that we have (A, A)
let c: Coend<TupleF, i32> = Coend::new((42, 42));
assert_eq!(c.value, (42, 42));

Fields

value: <P as HKT2>::P<A, A>

The diagonal value P(A, A) for the existentially quantified A.

Implementations

impl<P, A> Coend<P, A>

where P: HKT2,

pub fn new(value: <P as HKT2>::P<A, A>) -> Coend<P, A>

Construct a coend value from a diagonal element.

pub fn elim<R>(self, f: impl FnOnce(<P as HKT2>::P<A, A>) -> R) -> R

Eliminate the coend by applying a function to the diagonal value.

Given a function P(A, A) -> R, extract a result. This is the concrete elimination form — in category theory, the eliminator would be a dinatural transformation, but here the type parameter A is exposed rather than existentially hidden.

Trait Implementations

impl<P, A> Clone for Coend<P, A>

where P: HKT2, A: Clone, <P as HKT2>::P<A, A>: Clone,

fn clone(&self) -> Coend<P, A>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P, A> Debug for Coend<P, A>

where P: HKT2, A: Debug, <P as HKT2>::P<A, A>: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<P, A> Eq for Coend<P, A>

where P: HKT2, A: Eq, <P as HKT2>::P<A, A>: Eq,

impl<P, A> PartialEq for Coend<P, A>

where P: HKT2, A: PartialEq, <P as HKT2>::P<A, A>: PartialEq,

fn eq(&self, other: &Coend<P, A>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.