Bifoldable and Bitraversable

Author: garyb

README.md

@@ -14,3 +14,8 @@ bower install purescript-foldable-traversable
 
 - [Data.Foldable](docs/Data.Foldable.md)
 - [Data.Traversable](docs/Data.Traversable.md)
+
+## Bifunctors
+
+- [Data.Bifoldable](docs/Data.Bifoldable.md)
+- [Data.Bitraversable](docs/Data.Bitraversable.md)

docs/Data.Bifoldable.md

@@ -0,0 +1,85 @@
+# Module Documentation
+
+## Module Data.Bifoldable
+
+#### `Bifoldable`
+
+``` purescript
+class Bifoldable p where
+  bifoldr :: forall a b c. (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
+  bifoldl :: forall a b c. (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c
+  bifoldMap :: forall m a b. (Monoid m) => (a -> m) -> (b -> m) -> p a b -> m
+```
+
+`Bifoldable` represents data structures with two type arguments which can be
+folded.
+
+A fold for such a structure requires two step functions, one for each type
+argument. Type class instances should choose the appropriate step function based
+on the type of the element encountered at each point of the fold.
+
+
+#### `bifoldableTuple`
+
+``` purescript
+instance bifoldableTuple :: Bifoldable Tuple
+```
+
+
+#### `bifoldableEither`
+
+``` purescript
+instance bifoldableEither :: Bifoldable Either
+```
+
+
+#### `bifold`
+
+``` purescript
+bifold :: forall t m. (Bifoldable t, Monoid m) => t m m -> m
+```
+
+Fold a data structure, accumulating values in a monoidal type.
+
+#### `bitraverse_`
+
+``` purescript
+bitraverse_ :: forall t f a b c d. (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f Unit
+```
+
+Traverse a data structure, accumulating effects using an `Applicative` functor,
+ignoring the final result.
+
+#### `bifor_`
+
+``` purescript
+bifor_ :: forall t f a b c d. (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f Unit
+```
+
+A version of `bitraverse_` with the data structure as the first argument.
+
+#### `bisequence_`
+
+``` purescript
+bisequence_ :: forall t f a b. (Bifoldable t, Applicative f) => t (f a) (f b) -> f Unit
+```
+
+Collapse a data structure, collecting effects using an `Applicative` functor,
+ignoring the final result.
+
+#### `biany`
+
+``` purescript
+biany :: forall t a b c. (Bifoldable t, BoundedLattice c) => (a -> c) -> (b -> c) -> t a b -> c
+```
+
+Test whether a predicate holds at any position in a data structure.
+
+#### `biall`
+
+``` purescript
+biall :: forall t a b c. (Bifoldable t, BoundedLattice c) => (a -> c) -> (b -> c) -> t a b -> c
+```
+
+
+

docs/Data.Bitraversable.md

@@ -0,0 +1,44 @@
+# Module Documentation
+
+## Module Data.Bitraversable
+
+#### `Bitraversable`
+
+``` purescript
+class (Bifunctor t, Bifoldable t) <= Bitraversable t where
+  bitraverse :: forall f a b c d. (Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
+  bisequence :: forall f a b. (Applicative f) => t (f a) (f b) -> f (t a b)
+```
+
+`Bitraversable` represents data structures with two type arguments which can be
+traversed.
+
+A traversal for such a structure requires two functions, one for each type
+argument. Type class instances should choose the appropriate function based
+on the type of the element encountered at each point of the traversal.
+
+
+#### `bitraversableTuple`
+
+``` purescript
+instance bitraversableTuple :: Bitraversable Tuple
+```
+
+
+#### `bitraversableEither`
+
+``` purescript
+instance bitraversableEither :: Bitraversable Either
+```
+
+
+#### `bifor`
+
+``` purescript
+bifor :: forall t f a b c d. (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
+```
+
+Traverse a data structure, accumulating effects and results using an `Applicative` functor.
+
+
+

gulpfile.js

@@ -37,7 +37,7 @@ var docTask = function(name) {
   docTasks.push(taskName);
 };
 
-["Data.Foldable", "Data.Traversable"].forEach(docTask);
+["Data.Foldable", "Data.Traversable", "Data.Bifoldable", "Data.Bitraversable"].forEach(docTask);
 
 gulp.task("docs", docTasks);
 

src/Data/Bifoldable.purs

@@ -0,0 +1,59 @@
+module Data.Bifoldable where
+
+import Control.Apply ((*>))
+import Data.Either (Either(..))
+import Data.Monoid (Monoid)
+import Data.Monoid.Inf (Inf(..), runInf)
+import Data.Monoid.Sup (Sup(..), runSup)
+import Data.Tuple (Tuple(..))
+
+-- | `Bifoldable` represents data structures with two type arguments which can be
+-- | folded.
+-- |
+-- | A fold for such a structure requires two step functions, one for each type
+-- | argument. Type class instances should choose the appropriate step function based
+-- | on the type of the element encountered at each point of the fold.
+-- |
+class Bifoldable p where
+  bifoldr :: forall a b c. (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
+  bifoldl :: forall a b c. (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c
+  bifoldMap :: forall m a b. (Monoid m) => (a -> m) -> (b -> m) -> p a b -> m
+
+instance bifoldableTuple :: Bifoldable Tuple where
+  bifoldMap f g (Tuple a b) = f a <> g b
+  bifoldr f g z (Tuple a b) = f a (g b z)
+  bifoldl f g z (Tuple a b) = g (f z a) b
+
+instance bifoldableEither :: Bifoldable Either where
+  bifoldMap f _ (Left a) = f a
+  bifoldMap _ g (Right b) = g b
+  bifoldr f _ z (Left a) = f a z
+  bifoldr _ g z (Right b) = g b z
+  bifoldl f _ z (Left a) = f z a
+  bifoldl _ g z (Right b) = g z b
+
+-- | Fold a data structure, accumulating values in a monoidal type.
+bifold :: forall t m. (Bifoldable t, Monoid m) => t m m -> m
+bifold = bifoldMap id id
+
+-- | Traverse a data structure, accumulating effects using an `Applicative` functor,
+-- | ignoring the final result.
+bitraverse_ :: forall t f a b c d. (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f Unit
+bitraverse_ f g = bifoldr ((*>) <<< f) ((*>) <<< g) (pure unit)
+
+-- | A version of `bitraverse_` with the data structure as the first argument.
+bifor_ :: forall t f a b c d. (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f Unit
+bifor_ t f g = bitraverse_ f g t
+
+-- | Collapse a data structure, collecting effects using an `Applicative` functor,
+-- | ignoring the final result.
+bisequence_ :: forall t f a b. (Bifoldable t, Applicative f) => t (f a) (f b) -> f Unit
+bisequence_ = bitraverse_ id id
+
+-- | Test whether a predicate holds at any position in a data structure.
+biany :: forall t a b c. (Bifoldable t, BoundedLattice c) => (a -> c) -> (b -> c) -> t a b -> c
+biany p q = runSup <<< bifoldMap (Sup <<< p) (Sup <<< q)
+
+-- -- | Test whether a predicate holds at all positions in a data structure.
+biall :: forall t a b c. (Bifoldable t, BoundedLattice c) => (a -> c) -> (b -> c) -> t a b -> c
+biall p q = runInf <<< bifoldMap (Inf <<< p) (Inf <<< q)

src/Data/Bitraversable.purs

@@ -0,0 +1,31 @@
+module Data.Bitraversable where
+
+import Data.Bifoldable
+import Data.Bifunctor (Bifunctor)
+import Data.Either (Either(..))
+import Data.Tuple (Tuple(..))
+
+-- | `Bitraversable` represents data structures with two type arguments which can be
+-- | traversed.
+-- |
+-- | A traversal for such a structure requires two functions, one for each type
+-- | argument. Type class instances should choose the appropriate function based
+-- | on the type of the element encountered at each point of the traversal.
+-- |
+class (Bifunctor t, Bifoldable t) <= Bitraversable t where
+  bitraverse :: forall f a b c d. (Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
+  bisequence :: forall f a b. (Applicative f) => t (f a) (f b) -> f (t a b)
+
+instance bitraversableTuple :: Bitraversable Tuple where
+  bitraverse f g (Tuple a b) = Tuple <$> f a <*> g b
+  bisequence (Tuple a b) = Tuple <$> a <*> b
+
+instance bitraversableEither :: Bitraversable Either where
+  bitraverse f _ (Left a) = Left <$> f a
+  bitraverse _ g (Right b) = Right <$> g b
+  bisequence (Left a) = Left <$> a
+  bisequence (Right b) = Right <$> b
+
+-- | Traverse a data structure, accumulating effects and results using an `Applicative` functor.
+bifor :: forall t f a b c d. (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
+bifor t f g = bitraverse f g t