Skip to content
/ free Public

Combination of a free applicative functor and free monad

# safareli/free

## Folders and files

NameName
Last commit message
Last commit date

70 Commits

# Free

Combination of a Free applicative functor and Free monad.

## API

### Types

```data Par f a where
Pure :: a -> Par f a
Lift :: f a -> Par f a
Ap :: Par f (a -> b) -> Par f a -> Par f b

data Seq f a where
Pure :: a -> Seq f a
Lift :: f a -> Seq f a
Roll :: Seq f a -> (a -> Seq f b) -> Seq f b

data Concurrent f a where
Lift :: f a -> Concurrent f a
Seq  :: Seq (Concurrent f) a -> Concurrent f a
Par  :: Par (Concurrent f) a -> Concurrent f a

data Interpreter f g m = Interpreter
{ runSeq :: Ɐ x. f x -> m x
, runPar :: Ɐ x. f x -> g x
, seqToPar :: Ɐ x. m x -> g x
, parToSeq :: Ɐ x. g x -> m x
, Par :: TypeRep g
, Seq :: TypeRep m
}
```

### Asymptotic complexity

On all structures, complexity of:

• `chain`, `ap` and `map` is constant
• `fold`, `hoist`, `retract` and `graft` is linear

### Concurrent

Implements Functor, Applicative, ChainRec and Monad specifications.

It holds `Par`allel or `Seq`uential computations which are itself holding Concurrent computations. When operating on Concurrent structures it's behaving as Sequential. but in cases you want Parallel behaviour you can call `.par()` on it and it will return `Par` object which is only Applicative. then you can move back to `Concurrent` using `Concurrent.fromPar`.

#### Functor, Applicative, ChainRec and Monad functions:

• Concurrent.prototype.`map :: Concurrent f a ~> (a -> b) -> Concurrent f b`
• Concurrent.prototype.`ap :: Concurrent f a ~> Concurrent f (a -> b) -> Concurrent f b`
• Concurrent.prototype.`chain :: Concurrent f a ~> (a -> Concurrent f b) -> Concurrent f b`
• Concurrent.`chainRec :: ((a -> c, b -> c, a) -> Concurrent f c, a) -> Concurrent f b`
• Concurrent.`of :: a -> Concurrent f a`

#### other functions:

• Concurrent.`lift :: f a -> Concurrent f a`
• Concurrent.`fromSeq :: Seq (Concurrent f) a -> Concurrent f a`
• Concurrent.`fromPar :: Par (Concurrent f) a -> Concurrent f a`
• Concurrent.prototype.`seq :: Concurrent f a ~> Seq (Concurrent f) a`
• Concurrent.prototype.`par :: Concurrent f a ~> Par (Concurrent f) a`
• Concurrent.prototype.`interpret :: (Monad m, ChainRec m, Applicative g) => Concurrent f a ~> Interpreter f g m -> m a`
• Concurrent.prototype.`fold :: (Monad m, ChainRec m) => Concurrent f a ~> (Ɐ x. f x -> m x, TypeRep m) -> m a`
• Concurrent.prototype.`hoist :: Concurrent f a ~> (Ɐ x. f x -> g x) -> Concurrent g a`
• Concurrent.prototype.`retract :: (Monad m, ChainRec m) => Concurrent m a ~> TypeRep m -> m a`
• Concurrent.prototype.`graft :: Concurrent f a ~> (Ɐ x. f x -> Concurrent g x) -> Concurrent g a`

### Seq

Implements Functor, Applicative, ChainRec and Monad specifications.

#### Functor, Applicative, ChainRec and Monad functions:

• Seq.prototype.`map :: Seq f a ~> (a -> b) -> Seq f b`
• Seq.prototype.`ap :: Seq f a ~> Seq f (a -> b) -> Seq f b`
• Seq.prototype.`chain :: Seq f a ~> (a -> Seq f b) -> Seq f b`
• Seq.`chainRec :: ((a -> c, b -> c, a) -> Seq f c, a) -> Seq f b`
• Seq.`of :: a -> Seq f a`

#### other functions:

• Seq.`lift :: f a -> Seq f a`
• Seq.prototype.`foldSeq :: (Monad m, ChainRec m) => Seq f a ~> (Ɐ x. f x -> m x, TypeRep m) -> m a`
• Seq.prototype.`hoistSeq :: Seq f a ~> (Ɐ x. f x -> g x) -> Seq g a`
• Seq.prototype.`retractSeq :: (Monad m, ChainRec m) => Seq m a ~> TypeRep m -> m a`
• Seq.prototype.`graftSeq :: Seq f a ~> (Ɐ x. f x -> Seq g x) -> Seq g a`

### Par

Implements Functor and Applicative specifications.

#### Functor, Applicative, ChainRec and Monad functions:

• Par.prototype.`map :: Par f a ~> (a -> b) -> Par f b`
• Par.prototype.`ap :: Par f a ~> Par f (a -> b) -> Par f b`
• Par.`of :: a -> Par f a`

#### other functions:

• Par.`lift :: f a -> Par f a`
• Par.prototype.`foldPar :: (Applicative g) => Par f a ~> (Ɐ x. f x -> g x, TypeRep g) -> g a`
• Par.prototype.`hoistPar :: Par f a ~> (Ɐ x. f x -> g x) -> Par g a`
• Par.prototype.`retractPar :: (Applicative f) => Par f a ~> TypeRep f -> f a`
• Par.prototype.`graftPar :: Par f a ~> (Ɐ x. f x -> Par g x) -> Par g a`

### graft, hoist, retract and fold relations:

same for graftPar, graftSeq ... variations

• `a.graft(f) ≡ a.fold(f, a.constructor)`
• `a.hoist(f) ≡ a.fold(compose(a.constructor.lift, f), a.constructor)`
• `a.retract(M) ≡ a.fold(id, M)`
• `a.fold(f, M) ≡ compose(a.retract(M), a.hoist(f))`

This initial version of this module was based on a bit older version of srijs/haskell-free-concurrent, but it was not lawful, and from v2 it's based on more resent lawful version.

## About

Combination of a free applicative functor and free monad

v1.0.0 Latest
Oct 25, 2016

## Packages 0

No packages published

•
•