`Applicative` functor type-class.

Allows application of a function in an Applicative context to a value in an `Applicative` context.

This structure is an intermediate between a functor and a monad (technically, a strong lax monoidal functor). Compared with monads, this interface lacks the full power of the binding operation (`chain`), but it has more instances and it is sufficient for many uses.

References:

- The Essence of the Iterator Pattern
- Applicative programming with effects

Note that having an `Applicative` instance implies Functor and Apply implementations are also available, which is why the `Applicative` interface is a subtype of `Functor` and `Apply`.

`Applicative` implementations must obey the following laws:

1. Identity: `A.ap(A.of(x => x), v) <-> v`
2. Homomorphism: `A.ap(A.of(f), A.of(x)) <-> A.of(f(x))`
3. Interchange: A.ap(u, A.of(y)) <-> A.ap(A.of(f => f(y)), u)
4. Functor's `map` (can be derived): `A.map(f, u) <-> A.ap(A.of(f), u)`

Equivalent with the `Chain` type-class in the Fantasy-Land and static-land specifications.

### Type parameters

- #### F

### Hierarchy

- Apply<F>
  - Applicative
    - Monad

## Index

### Methods

- ap
- map
- of

## Methods

### ap

- ap<A, B>(ff: HK<F, function>, fa: HK<F, A>): HK<F, B>

- Inherited from Apply.ap

  - Defined in apply.ts:31

  #### Type parameters

  - #### A

  - #### B

  #### Parameters

  - ##### ff: HK<F, function>

  - ##### fa: HK<F, A>

  #### Returns HK<F, B>

### map

- map<A, B>(f: function, fa: HK<F, A>): HK<F, B>

- Inherited from Functor.map

  - Defined in functor.ts:27

  #### Type parameters

  - #### A

  - #### B

  #### Parameters

  - ##### f: function

    - - (a: A): B

      - #### Parameters

        - ##### a: A

        #### Returns B

  - ##### fa: HK<F, A>

  #### Returns HK<F, B>

### of

- of<A>(a: A): HK<F, A>

- - Defined in applicative.ts:45

  #### Type parameters

  - #### A

  #### Parameters

  - ##### a: A

  #### Returns HK<F, A>

Generated using TypeDoc