Merge master

Author: jacereda

.eslintrc.json

@@ -0,0 +1,28 @@
+{
+  "parserOptions": {
+    "ecmaVersion": 5
+  },
+  "extends": "eslint:recommended",
+  "env": {
+    "commonjs": true
+  },
+  "rules": {
+    "strict": [2, "global"],
+    "block-scoped-var": 2,
+    "consistent-return": 2,
+    "eqeqeq": [2, "smart"],
+    "guard-for-in": 2,
+    "no-caller": 2,
+    "no-extend-native": 2,
+    "no-loop-func": 2,
+    "no-new": 2,
+    "no-param-reassign": 2,
+    "no-return-assign": 2,
+    "no-unused-expressions": 2,
+    "no-use-before-define": 2,
+    "radix": [2, "always"],
+    "indent": [2, 2],
+    "quotes": [2, "double"],
+    "semi": [2, "always"]
+  }
+}

.gitignore

@@ -1,7 +1,6 @@
 /.*
 !/.gitignore
-!/.jscsrc
-!/.jshintrc
+!/.eslintrc.json
 !/.travis.yml
 /bower_components/
 /node_modules/

.jscsrc

@@ -1,7 +1,7 @@
 language: node_js
 dist: trusty
 sudo: required
-node_js: 6
+node_js: stable
 env:
   - PATH=$HOME/purescript:$PATH
 install:

.jshintrc

@@ -1,8 +1,7 @@
 # purescript-foldable-traversable
 
-[![Latest release](http://img.shields.io/bower/v/purescript-foldable-traversable.svg)](https://github.com/purescript/purescript-foldable-traversable/releases)
-[![Build Status](https://travis-ci.org/purescript/purescript-foldable-traversable.svg?branch=master)](https://travis-ci.org/purescript/purescript-foldable-traversable)
-[![Dependency Status](https://www.versioneye.com/user/projects/55848b2536386100150003cf/badge.svg?style=flat)](https://www.versioneye.com/user/projects/55848b2536386100150003cf)
+[![Latest release](http://img.shields.io/github/release/purescript/purescript-foldable-traversable.svg)](https://github.com/purescript/purescript-foldable-traversable/releases)
+[![Build status](https://travis-ci.org/purescript/purescript-foldable-traversable.svg?branch=master)](https://travis-ci.org/purescript/purescript-foldable-traversable)
 
 Classes for foldable and traversable data structures.
 

.travis.yml

@@ -17,8 +17,8 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-bifunctors": "^2.0.0",
-    "purescript-maybe": "^2.0.0"
+    "purescript-bifunctors": "^3.0.0",
+    "purescript-maybe": "^3.0.0"
   },
   "devDependencies": {
     "purescript-assert": "^2.0.0",

README.md

@@ -2,14 +2,13 @@
   "private": true,
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
-    "build": "jshint src && jscs src && psa \"src/**/*.purs\" \"bower_components/purescript-*/**/*.purs\" --censor-lib --strict",
-    "test": "psc \"src/**/*.purs\" \"bower_components/purescript-*/**/*.purs\" \"test/**/*.purs\" && psc-bundle \"output/**/*.js\" --module Test.Main --main Test.Main | node"
+    "build": "eslint src && pulp build -- --censor-lib --strict",
+    "test": "pulp test"
   },
   "devDependencies": {
-    "jscs": "^2.8.0",
-    "jshint": "^2.9.1",
-    "pulp": "^8.2.0",
-    "purescript-psa": "^0.3.8",
-    "rimraf": "^2.5.0"
+    "eslint": "^3.17.1",
+    "pulp": "^10.0.4",
+    "purescript-psa": "^0.5.0-rc.1",
+    "rimraf": "^2.6.1"
   }
 }

bower.json

@@ -10,6 +10,12 @@ import Data.Monoid.Disj (Disj(..))
 import Data.Monoid.Dual (Dual(..))
 import Data.Monoid.Endo (Endo(..))
 import Data.Newtype (unwrap)
+import Data.Foldable (class Foldable, foldr, foldl, foldMap)
+import Data.Bifunctor.Clown (Clown(..))
+import Data.Bifunctor.Joker (Joker(..))
+import Data.Bifunctor.Flip (Flip(..))
+import Data.Bifunctor.Product (Product(..))
+import Data.Bifunctor.Wrap (Wrap(..))
 
 -- | `Bifoldable` represents data structures with two type arguments which can be
 -- | folded.
@@ -33,6 +39,31 @@ class Bifoldable p where
   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 bifoldableClown :: Foldable f => Bifoldable (Clown f) where
+  bifoldr l _ u (Clown f) = foldr l u f
+  bifoldl l _ u (Clown f) = foldl l u f
+  bifoldMap l _ (Clown f) = foldMap l f
+
+instance bifoldableJoker :: Foldable f => Bifoldable (Joker f) where
+  bifoldr _ r u (Joker f) = foldr r u f
+  bifoldl _ r u (Joker f) = foldl r u f
+  bifoldMap _ r (Joker f) = foldMap r f
+
+instance bifoldableFlip :: Bifoldable p => Bifoldable (Flip p) where
+  bifoldr r l u (Flip p) = bifoldr l r u p
+  bifoldl r l u (Flip p) = bifoldl l r u p
+  bifoldMap r l (Flip p) = bifoldMap l r p
+
+instance bifoldableProduct :: (Bifoldable f, Bifoldable g) => Bifoldable (Product f g) where
+  bifoldr l r u m = bifoldrDefault l r u m
+  bifoldl l r u m = bifoldlDefault l r u m
+  bifoldMap l r (Product f g) = bifoldMap l r f <> bifoldMap l r g
+
+instance bifoldableWrap :: Bifoldable p => Bifoldable (Wrap p) where
+  bifoldr l r u (Wrap p) = bifoldr l r u p
+  bifoldl l r u (Wrap p) = bifoldl l r u p
+  bifoldMap l r (Wrap p) = bifoldMap l r p
+
 -- | A default implementation of `bifoldr` using `bifoldMap`.
 -- |
 -- | Note: when defining a `Bifoldable` instance, this function is unsafe to
@@ -71,36 +102,39 @@ bifoldlDefault f g z p =
 -- | use in combination with `bifoldrDefault`.
 bifoldMapDefaultR
   :: forall p m a b
-   . (Bifoldable p, Monoid m)
+   . Bifoldable p
+  => Monoid m
   => (a -> m)
   -> (b -> m)
   -> p a b
   -> m
-bifoldMapDefaultR f g p = bifoldr (append <<< f) (append <<< g) mempty p
+bifoldMapDefaultR f g = bifoldr (append <<< f) (append <<< g) mempty
 
 -- | A default implementation of `bifoldMap` using `bifoldl`.
 -- |
 -- | Note: when defining a `Bifoldable` instance, this function is unsafe to
 -- | use in combination with `bifoldlDefault`.
 bifoldMapDefaultL
   :: forall p m a b
-   . (Bifoldable p, Monoid m)
+   . Bifoldable p
+  => Monoid m
   => (a -> m)
   -> (b -> m)
   -> p a b
   -> m
-bifoldMapDefaultL f g p = bifoldl (\m a -> m <> f a) (\m b -> m <> g b) mempty p
+bifoldMapDefaultL f g = bifoldl (\m a -> m <> f a) (\m b -> m <> g b) mempty
 
 
 -- | Fold a data structure, accumulating values in a monoidal type.
-bifold :: forall t m. (Bifoldable t, Monoid m) => t m m -> m
+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)
+   . Bifoldable t
+  => Applicative f
   => (a -> f c)
   -> (b -> f d)
   -> t a b
@@ -110,7 +144,8 @@ bitraverse_ f g = bifoldr (applySecond <<< f) (applySecond <<< 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)
+   . Bifoldable t
+  => Applicative f
   => t a b
   -> (a -> f c)
   -> (b -> f d)
@@ -121,15 +156,17 @@ bifor_ t f g = bitraverse_ f g t
 -- | ignoring the final result.
 bisequence_
   :: forall t f a b
-   . (Bifoldable t, Applicative f)
+   . 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, BooleanAlgebra c)
+   . Bifoldable t
+  => BooleanAlgebra c
   => (a -> c)
   -> (b -> c)
   -> t a b
@@ -139,7 +176,8 @@ biany p q = unwrap <<< bifoldMap (Disj <<< p) (Disj <<< q)
 -- | Test whether a predicate holds at all positions in a data structure.
 biall
   :: forall t a b c
-   . (Bifoldable t, BooleanAlgebra c)
+   . Bifoldable t
+  => BooleanAlgebra c
   => (a -> c)
   -> (b -> c)
   -> t a b

package.json

@@ -2,14 +2,24 @@ module Data.Bitraversable
   ( class Bitraversable, bitraverse, bisequence
   , bitraverseDefault
   , bisequenceDefault
+  , ltraverse
+  , rtraverse
   , bifor
+  , lfor
+  , rfor
   , module Data.Bifoldable
   ) where
 
 import Prelude
 
 import Data.Bifoldable (class Bifoldable, biall, biany, bifold, bifoldMap, bifoldMapDefaultL, bifoldMapDefaultR, bifoldl, bifoldlDefault, bifoldr, bifoldrDefault, bifor_, bisequence_, bitraverse_)
+import Data.Traversable (class Traversable, traverse, sequence)
 import Data.Bifunctor (class Bifunctor, bimap)
+import Data.Bifunctor.Clown (Clown(..))
+import Data.Bifunctor.Joker (Joker(..))
+import Data.Bifunctor.Flip (Flip(..))
+import Data.Bifunctor.Product (Product(..))
+import Data.Bifunctor.Wrap (Wrap(..))
 
 -- | `Bitraversable` represents data structures with two type arguments which can be
 -- | traversed.
@@ -26,10 +36,49 @@ 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 bitraversableClown :: Traversable f => Bitraversable (Clown f) where
+  bitraverse l _ (Clown f) = Clown <$> traverse l f
+  bisequence (Clown f) = Clown <$> sequence f
+
+instance bitraversableJoker :: Traversable f => Bitraversable (Joker f) where
+  bitraverse _ r (Joker f) = Joker <$> traverse r f
+  bisequence (Joker f) = Joker <$> sequence f
+
+instance bitraversableFlip :: Bitraversable p => Bitraversable (Flip p) where
+  bitraverse r l (Flip p) = Flip <$> bitraverse l r p
+  bisequence (Flip p) = Flip <$> bisequence p
+
+instance bitraversableProduct :: (Bitraversable f, Bitraversable g) => Bitraversable (Product f g) where
+  bitraverse l r (Product f g) = Product <$> bitraverse l r f <*> bitraverse l r g
+  bisequence (Product f g) = Product <$> bisequence f <*> bisequence g
+
+instance bitraversableWrap :: Bitraversable p => Bitraversable (Wrap p) where
+  bitraverse l r (Wrap p) = Wrap <$> bitraverse l r p
+  bisequence (Wrap p) = Wrap <$> bisequence p
+
+ltraverse
+  :: forall t b c a f
+   . Bitraversable t
+  => Applicative f
+  => (a -> f c)
+  -> t a b
+  -> f (t c b)
+ltraverse f = bitraverse f pure
+
+rtraverse
+  :: forall t b c a f
+   . Bitraversable t
+  => Applicative f
+  => (b -> f c)
+  -> t a b
+  -> f (t a c)
+rtraverse = bitraverse pure
+
 -- | A default implementation of `bitraverse` using `bisequence` and `bimap`.
 bitraverseDefault
   :: forall t f a b c d
-   . (Bitraversable t, Applicative f)
+   . Bitraversable t
+  => Applicative f
   => (a -> f c)
   -> (b -> f d)
   -> t a b
@@ -39,17 +88,37 @@ bitraverseDefault f g t = bisequence (bimap f g t)
 -- | A default implementation of `bisequence` using `bitraverse`.
 bisequenceDefault
   :: forall t f a b
-   . (Bitraversable t, Applicative f)
+   . Bitraversable t
+  => Applicative f
   => t (f a) (f b)
   -> f (t a b)
-bisequenceDefault t = bitraverse id id t
+bisequenceDefault = bitraverse id id
 
 -- | Traverse a data structure, accumulating effects and results using an `Applicative` functor.
 bifor
   :: forall t f a b c d
-   . (Bitraversable t, Applicative f)
+   . 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
+
+lfor
+  :: forall t b c a f
+   . Bitraversable t
+  => Applicative f
+  => t a b
+  -> (a -> f c)
+  -> f (t c b)
+lfor t f = bitraverse f pure t
+
+rfor
+  :: forall t b c a f
+   . Bitraversable t
+  => Applicative f
+  => t a b
+  -> (b -> f c)
+  -> f (t a c)
+rfor t f = bitraverse pure f t