Merge pull request #192 from LiamGoodacre/fix/minor-docs

Minor doc clean up

Author: garyb

src/Data/Monoid.purs

@@ -22,9 +22,8 @@ import Type.Data.RowList (RLProxy(..))
 -- | A `Monoid` is a `Semigroup` with a value `mempty`, which is both a
 -- | left and right unit for the associative operation `<>`:
 -- |
--- | ```
--- | forall x. mempty <> x = x <> mempty = x
--- | ```
+-- | - Left unit: `(mempty <> x) = x`
+-- | - Right unit: `(x <> mempty) = x`
 -- |
 -- | `Monoid`s are commonly used as the result of fold operations, where
 -- | `<>` is used to combine individual results, and `mempty` gives the result

src/Data/Monoid/Additive.purs

@@ -9,7 +9,7 @@ import Data.Ord (class Ord1)
 -- |
 -- | ``` purescript
 -- | Additive x <> Additive y == Additive (x + y)
--- | mempty :: Additive _ == Additive zero
+-- | (mempty :: Additive _) == Additive zero
 -- | ```
 newtype Additive a = Additive a
 

src/Data/Monoid/Conj.purs

@@ -10,7 +10,7 @@ import Data.Ord (class Ord1)
 -- |
 -- | ``` purescript
 -- | Conj x <> Conj y == Conj (x && y)
--- | mempty :: Conj _ == Conj tt
+-- | (mempty :: Conj _) == Conj tt
 -- | ```
 newtype Conj a = Conj a
 

src/Data/Monoid/Disj.purs

@@ -10,7 +10,7 @@ import Data.Ord (class Ord1)
 -- |
 -- | ``` purescript
 -- | Disj x <> Disj y == Disj (x || y)
--- | mempty :: Disj _ == Disj bottom
+-- | (mempty :: Disj _) == Disj bottom
 -- | ```
 newtype Disj a = Disj a
 

src/Data/Monoid/Dual.purs

@@ -9,7 +9,7 @@ import Data.Ord (class Ord1)
 -- |
 -- | ``` purescript
 -- | Dual x <> Dual y == Dual (y <> x)
--- | mempty :: Dual _ == Dual mempty
+-- | (mempty :: Dual _) == Dual mempty
 -- | ```
 newtype Dual a = Dual a
 

src/Data/Monoid/Endo.purs

@@ -9,7 +9,7 @@ import Prelude
 -- |
 -- | ``` purescript
 -- | Endo f <> Endo g == Endo (f <<< g)
--- | mempty :: Endo _ == Endo identity
+-- | (mempty :: Endo _) == Endo identity
 -- | ```
 newtype Endo c a = Endo (c a a)
 

src/Data/Monoid/Multiplicative.purs

@@ -9,7 +9,7 @@ import Data.Ord (class Ord1)
 -- |
 -- | ``` purescript
 -- | Multiplicative x <> Multiplicative y == Multiplicative (x * y)
--- | mempty :: Multiplicative _ == Multiplicative one
+-- | (mempty :: Multiplicative _) == Multiplicative one
 -- | ```
 newtype Multiplicative a = Multiplicative a
 

src/Data/NaturalTransformation.purs

@@ -3,7 +3,7 @@ module Data.NaturalTransformation where
 -- | A type for natural transformations.
 -- |
 -- | A natural transformation is a mapping between type constructors of kind
--- | `* -> *` where the mapping operation has no ability to manipulate the
+-- | `Type -> Type` where the mapping operation has no ability to manipulate the
 -- | inner values.
 -- |
 -- | An example of this is the `fromFoldable` function provided in
@@ -12,7 +12,7 @@ module Data.NaturalTransformation where
 -- |
 -- | The definition of a natural transformation in category theory states that
 -- | `f` and `g` should be functors, but the `Functor` constraint is not
--- | enforced here; that the types are of kind `* -> *` is enough for our
+-- | enforced here; that the types are of kind `Type -> Type` is enough for our
 -- | purposes.
 type NaturalTransformation f g = forall a. f a -> g a
 

src/Data/Unit.purs

@@ -6,8 +6,7 @@ import Data.Show (class Show)
 -- | values with no computational content.
 -- |
 -- | `Unit` is often used, wrapped in a monadic type constructor, as the
--- | return type of a computation where only
--- | the _effects_ are important.
+-- | return type of a computation where only the _effects_ are important.
 foreign import data Unit :: Type
 
 -- | `unit` is the sole inhabitant of the `Unit` type.

src/Data/Void.purs

@@ -12,6 +12,15 @@ newtype Void = Void Void
 instance showVoid :: Show Void where
   show = absurd
 
+-- | Eliminator for the `Void` type.
+-- | Useful for stating that some code branch is impossible because you've
+-- | "acquired" a value of type `Void` (which you can't).
+-- |
+-- | ```purescript
+-- | rightOnly :: forall t . Either Void t -> t
+-- | rightOnly (Left v) = absurd v
+-- | rightOnly (Right t) = t
+-- | ```
 absurd :: forall a. Void -> a
 absurd a = spin a
   where