Updates for 0.7

Author: garyb

bower.json

@@ -1,5 +1,7 @@
 {
   "name": "purescript-bifunctors",
+  "homepage": "https://github.com/purescript/purescript-bifunctors",
+  "description": "Bifunctors and biapplicatives",
   "keywords": [
     "purescript",
     "bifunctor",
@@ -11,11 +13,16 @@
     "Dylan Lukes <lukes.dylan@gmail.com>"
   ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/purescript/purescript-bifunctors.git"
+  },
   "ignore": [
     "**/.*",
     "bower_components",
     "node_modules",
     "output",
+    "test",
     "bower.json",
     "gulpfile.js",
     "package.json"

docs/Control.Biapplicative.md

@@ -1,5 +1,3 @@
-# Module Documentation
-
 ## Module Control.Biapplicative
 
 #### `Biapplicative`
@@ -13,4 +11,3 @@ class (Biapply w) <= Biapplicative w where
 functions of zero or more arguments, in the sense of `Applicative`.
 
 
-

docs/Control.Biapply.md

@@ -1,5 +1,3 @@
-# Module Documentation
-
 ## Module Control.Biapply
 
 #### `(<<$>>)`
@@ -15,14 +13,6 @@ the style of `Applicative`:
 bipure f g <<$>> x <<*>> y
 ```
 
-#### `(<<*>>)`
-
-``` purescript
-(<<*>>) :: forall w a b c d. (Biapply w) => w (a -> b) (c -> d) -> w a c -> w b d
-```
-
-An infix version of `biapply`.
-
 #### `Biapply`
 
 ``` purescript
@@ -33,6 +23,14 @@ class (Bifunctor w) <= Biapply w where
 `Biapply` captures type constructors of two arguments which support lifting of
 functions of one or more arguments, in the sense of `Apply`.
 
+#### `(<<*>>)`
+
+``` purescript
+(<<*>>) :: forall w a b c d. (Biapply w) => w (a -> b) (c -> d) -> w a c -> w b d
+```
+
+An infix version of `biapply`.
+
 #### `(*>>)`
 
 ``` purescript
@@ -66,4 +64,3 @@ bilift3 :: forall w a b c d e f g h. (Biapply w) => (a -> b -> c -> d) -> (e ->
 Lift a function of three arguments.
 
 
-

docs/Data.Bifunctor.Clown.md

@@ -1,5 +1,3 @@
-# Module Documentation
-
 ## Module Data.Bifunctor.Clown
 
 #### `Clown`
@@ -9,42 +7,20 @@ data Clown f a b
   = Clown (f a)
 ```
 
-Make a `Functor` over the first argument of a `Bifunctor`
-
-#### `runClown`
-
-``` purescript
-runClown :: forall f a b. Clown f a b -> f a
-```
-
-
-#### `clownBifunctor`
-
+##### Instances
 ``` purescript
 instance clownBifunctor :: (Functor f) => Bifunctor (Clown f)
-```
-
-
-#### `clownFunctor`
-
-``` purescript
 instance clownFunctor :: Functor (Clown f a)
-```
-
-
-#### `clownBiapply`
-
-``` purescript
 instance clownBiapply :: (Apply f) => Biapply (Clown f)
+instance clownBiapplicative :: (Applicative f) => Biapplicative (Clown f)
 ```
 
+Make a `Functor` over the first argument of a `Bifunctor`
 
-#### `clownBiapplicative`
+#### `runClown`
 
 ``` purescript
-instance clownBiapplicative :: (Applicative f) => Biapplicative (Clown f)
+runClown :: forall f a b. Clown f a b -> f a
 ```
 
 
-
-

docs/Data.Bifunctor.Flip.md

@@ -1,5 +1,3 @@
-# Module Documentation
-
 ## Module Data.Bifunctor.Flip
 
 #### `Flip`
@@ -9,43 +7,22 @@ data Flip p a b
   = Flip (p b a)
 ```
 
-Flips the order of the type arguments of a `Bifunctor`.
-
-#### `runFlip`
-
-``` purescript
-runFlip :: forall p a b. Flip p a b -> p b a
-```
-
-Remove the `Flip` constructor.
-
-#### `flipBifunctor`
-
+##### Instances
 ``` purescript
 instance flipBifunctor :: (Bifunctor p) => Bifunctor (Flip p)
-```
-
-
-#### `flipFunctor`
-
-``` purescript
 instance flipFunctor :: (Bifunctor p) => Functor (Flip p a)
-```
-
-
-#### `flipBiapply`
-
-``` purescript
 instance flipBiapply :: (Biapply p) => Biapply (Flip p)
+instance flipBiapplicative :: (Biapplicative p) => Biapplicative (Flip p)
 ```
 
+Flips the order of the type arguments of a `Bifunctor`.
 
-#### `flipBiapplicative`
+#### `runFlip`
 
 ``` purescript
-instance flipBiapplicative :: (Biapplicative p) => Biapplicative (Flip p)
+runFlip :: forall p a b. Flip p a b -> p b a
 ```
 
-
+Remove the `Flip` constructor.
 
 

docs/Data.Bifunctor.Join.md

@@ -1,5 +1,3 @@
-# Module Documentation
-
 ## Module Data.Bifunctor.Join
 
 #### `Join`
@@ -9,37 +7,22 @@ data Join p a
   = Join (p a a)
 ```
 
-`Join` turns a `Bifunctor` into a `Functor` by equating the
-two type arguments.
-
-#### `runJoin`
-
-``` purescript
-runJoin :: forall p a. Join p a -> p a a
-```
-
-Remove the `Join` constructor.
-
-#### `joinFunctor`
-
+##### Instances
 ``` purescript
 instance joinFunctor :: (Bifunctor p) => Functor (Join p)
-```
-
-
-#### `joinApply`
-
-``` purescript
 instance joinApply :: (Biapply p) => Apply (Join p)
+instance joinApplicative :: (Biapplicative p) => Applicative (Join p)
 ```
 
+`Join` turns a `Bifunctor` into a `Functor` by equating the
+two type arguments.
 
-#### `joinApplicative`
+#### `runJoin`
 
 ``` purescript
-instance joinApplicative :: (Biapplicative p) => Applicative (Join p)
+runJoin :: forall p a. Join p a -> p a a
 ```
 
-
+Remove the `Join` constructor.
 
 

docs/Data.Bifunctor.Joker.md

@@ -1,5 +1,3 @@
-# Module Documentation
-
 ## Module Data.Bifunctor.Joker
 
 #### `Joker`
@@ -9,42 +7,20 @@ data Joker g a b
   = Joker (g b)
 ```
 
-Make a `Functor` over the second argument of a `Bifunctor`
-
-#### `runJoker`
-
-``` purescript
-runJoker :: forall g a b. Joker g a b -> g b
-```
-
-
-#### `jokerBifunctor`
-
+##### Instances
 ``` purescript
 instance jokerBifunctor :: (Functor g) => Bifunctor (Joker g)
-```
-
-
-#### `jokerFunctor`
-
-``` purescript
 instance jokerFunctor :: (Functor g) => Functor (Joker g a)
-```
-
-
-#### `jokerBiapply`
-
-``` purescript
 instance jokerBiapply :: (Apply g) => Biapply (Joker g)
+instance jokerBiapplicative :: (Applicative g) => Biapplicative (Joker g)
 ```
 
+Make a `Functor` over the second argument of a `Bifunctor`
 
-#### `jokerBiapplicative`
+#### `runJoker`
 
 ``` purescript
-instance jokerBiapplicative :: (Applicative g) => Biapplicative (Joker g)
+runJoker :: forall g a b. Joker g a b -> g b
 ```
 
 
-
-

docs/Data.Bifunctor.Product.md

@@ -1,5 +1,3 @@
-# Module Documentation
-
 ## Module Data.Bifunctor.Product
 
 #### `Product`
@@ -9,28 +7,13 @@ data Product f g a b
   = Pair (f a b) (g a b)
 ```
 
-The product of two `Bifunctor`s.
-
-#### `productBifunctor`
-
+##### Instances
 ``` purescript
 instance productBifunctor :: (Bifunctor f, Bifunctor g) => Bifunctor (Product f g)
-```
-
-
-#### `productBiapply`
-
-``` purescript
 instance productBiapply :: (Biapply f, Biapply g) => Biapply (Product f g)
-```
-
-
-#### `productBiapplicative`
-
-``` purescript
 instance productBiapplicative :: (Biapplicative f, Biapplicative g) => Biapplicative (Product f g)
 ```
 
-
+The product of two `Bifunctor`s.
 
 

docs/Data.Bifunctor.Wrap.md

@@ -1,5 +1,3 @@
-# Module Documentation
-
 ## Module Data.Bifunctor.Wrap
 
 #### `Wrap`
@@ -9,44 +7,23 @@ data Wrap p a b
   = Wrap (p a b)
 ```
 
-A `newtype` wrapper which provides a `Functor` over the second argument of
-a `Bifunctor`
-
-#### `unwrap`
-
-``` purescript
-unwrap :: forall p a b. Wrap p a b -> p a b
-```
-
-Remove the `Wrap` constructor.
-
-#### `wrapBifunctor`
-
+##### Instances
 ``` purescript
 instance wrapBifunctor :: (Bifunctor p) => Bifunctor (Wrap p)
-```
-
-
-#### `wrapFunctor`
-
-``` purescript
 instance wrapFunctor :: (Bifunctor p) => Functor (Wrap p a)
-```
-
-
-#### `wrapBiapply`
-
-``` purescript
 instance wrapBiapply :: (Biapply p) => Biapply (Wrap p)
+instance wrapBiapplicative :: (Biapplicative p) => Biapplicative (Wrap p)
 ```
 
+A `newtype` wrapper which provides a `Functor` over the second argument of
+a `Bifunctor`
 
-#### `wrapBiapplicative`
+#### `unwrap`
 
 ``` purescript
-instance wrapBiapplicative :: (Biapplicative p) => Biapplicative (Wrap p)
+unwrap :: forall p a b. Wrap p a b -> p a b
 ```
 
-
+Remove the `Wrap` constructor.
 
 

docs/Data.Bifunctor.md

@@ -1,5 +1,3 @@
-# Module Documentation
-
 ## Module Data.Bifunctor
 
 #### `Bifunctor`
@@ -40,4 +38,3 @@ rmap :: forall f a b c. (Bifunctor f) => (b -> c) -> f a b -> f a c
 Map a function over the second type arguments of a `Bifunctor`.
 
 
-