Consistency

Author: paf31

README.md

@@ -3,7 +3,7 @@
 ## Module Control.Alt
 
 
-This module defines the `Alt` type class
+This module defines the `Alt` type class.
 
 #### `Alt`
 
@@ -140,15 +140,15 @@ This module defines helper functions for working with `Bind` instances.
 (=<<) :: forall a b m. (Bind m) => (a -> m b) -> m a -> m b
 ```
 
-A version of `(>>=)` with its arguments reversed
+A version of `(>>=)` with its arguments flipped.
 
 #### `(>=>)`
 
 ``` purescript
 (>=>) :: forall a b c m. (Bind m) => (a -> m b) -> (b -> m c) -> a -> m c
 ```
 
-Forwards Kleisli composition
+Forwards Kleisli composition.
 
 For example:
 
@@ -164,7 +164,7 @@ third = tail >=> tail >=> head
 (<=<) :: forall a b c m. (Bind m) => (b -> m c) -> (a -> m b) -> a -> m c
 ```
 
-Backwards Kleisli composition
+Backwards Kleisli composition.
 
 #### `join`
 
@@ -194,7 +194,7 @@ main = ifM ((< 0.5) <$> random)
 ## Module Control.Comonad
 
 
-This module defines the `Comonad` type class
+This module defines the `Comonad` type class.
 
 #### `Comonad`
 
@@ -218,7 +218,7 @@ Laws:
 ## Module Control.Extend
 
 
-This module defines the `Extend` type class and associated helper functions
+This module defines the `Extend` type class and associated helper functions.
 
 #### `Extend`
 
@@ -251,55 +251,55 @@ instance extendArr :: (Semigroup w) => Extend (Prim.Function w)
 (=>>) :: forall b a w. (Extend w) => w a -> (w a -> b) -> w b
 ```
 
-A version of `(<<=)` with its arguments reversed
+A version of `(<<=)` with its arguments flipped.
 
 #### `(=>=)`
 
 ``` purescript
 (=>=) :: forall b a w c. (Extend w) => (w a -> b) -> (w b -> c) -> w a -> c
 ```
 
-Forwards co-Kleisli composition
+Forwards co-Kleisli composition.
 
 #### `(=<=)`
 
 ``` purescript
 (=<=) :: forall b a w c. (Extend w) => (w b -> c) -> (w a -> b) -> w a -> c
 ```
 
-Backwards co-Kleisli composition
+Backwards co-Kleisli composition.
 
 #### `duplicate`
 
 ``` purescript
 duplicate :: forall a w. (Extend w) => w a -> w (w a)
 ```
 
-Duplicate a comonadic context
+Duplicate a comonadic context.
 
-`duplicate` is dual to `join`.
+`duplicate` is dual to `Control.Bind.join`.
 
 
 ## Module Control.Functor
 
 
-This module defines helper functions for working with `Functor` instances
+This module defines helper functions for working with `Functor` instances.
 
 #### `(<$)`
 
 ``` purescript
 (<$) :: forall f a b. (Functor f) => a -> f b -> f a
 ```
 
-Ignore the return value of a computation, using the specified return value instead
+Ignore the return value of a computation, using the specified return value instead.
 
 #### `($>)`
 
 ``` purescript
 ($>) :: forall f a b. (Functor f) => f a -> b -> f b
 ```
 
-A version of `(<$)` with its arguments flipped
+A version of `(<$)` with its arguments flipped.
 
 
 ## Module Control.Lazy
@@ -328,7 +328,7 @@ class Lazy1 l where
   defer1 :: forall a. (Unit -> l a) -> l a
 ```
 
-A version of `Lazy` for type constructors of one type argument
+A version of `Lazy` for type constructors of one type argument.
 
 #### `Lazy2`
 
@@ -337,7 +337,7 @@ class Lazy2 l where
   defer2 :: forall a b. (Unit -> l a b) -> l a b
 ```
 
-A version of `Lazy` for type constructors of two type arguments
+A version of `Lazy` for type constructors of two type arguments.
 
 #### `fix`
 
@@ -355,37 +355,37 @@ The `Lazy` instance allows us to generate the result lazily.
 fix1 :: forall l a. (Lazy1 l) => (l a -> l a) -> l a
 ```
 
-A version of `fix` for type constructors of one type argument
+A version of `fix` for type constructors of one type argument.
 
 #### `fix2`
 
 ``` purescript
 fix2 :: forall l a b. (Lazy2 l) => (l a b -> l a b) -> l a b
 ```
 
-A version of `fix` for type constructors of two type arguments
+A version of `fix` for type constructors of two type arguments.
 
 
 ## Module Control.Monad
 
 
-This module defines helper functions for working with `Monad` instances
+This module defines helper functions for working with `Monad` instances.
 
 #### `replicateM`
 
 ``` purescript
 replicateM :: forall m a. (Monad m) => Number -> m a -> m [a]
 ```
 
-Perform a monadic action `n` times collecting all of the results
+Perform a monadic action `n` times collecting all of the results.
 
 #### `foldM`
 
 ``` purescript
 foldM :: forall m a b. (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
 ```
 
-Perform a fold using a monadic step function
+Perform a fold using a monadic step function.
 
 #### `when`
 
@@ -476,6 +476,7 @@ class (Alt f) <= Plus f where
 
 The `Plus` type class extends the `Alt` type class with a value that
 should be the left and right identity for `(<|>)`.
+
 It is similar to `Monoid`, except that it applies to types of
 kind `* -> *`, like `Array` or `List`, rather than concrete types like
 `String` or `Number`.

src/Control/Alt.purs

@@ -1,4 +1,4 @@
--- | This module defines the `Alt` type class
+-- | This module defines the `Alt` type class.
 
 module Control.Alt where
 

src/Control/Bind.purs

@@ -6,11 +6,11 @@ module Control.Bind where
   infixr 1 >=>
   infixr 1 <=<
 
-  -- | A version of `(>>=)` with its arguments reversed
+  -- | A version of `(>>=)` with its arguments flipped.
   (=<<) :: forall a b m. (Bind m) => (a -> m b) -> m a -> m b
   (=<<) f m = m >>= f
 
-  -- | Forwards Kleisli composition
+  -- | Forwards Kleisli composition.
   -- |
   -- | For example:
   -- | 
@@ -22,7 +22,7 @@ module Control.Bind where
   (>=>) :: forall a b c m. (Bind m) => (a -> m b) -> (b -> m c) -> a -> m c
   (>=>) f g a = f a >>= g
 
-  -- | Backwards Kleisli composition
+  -- | Backwards Kleisli composition.
   (<=<) :: forall a b c m. (Bind m) => (b -> m c) -> (a -> m b) -> a -> m c
   (<=<) f g a = f =<< g a
 

src/Control/Comonad.purs

@@ -1,4 +1,4 @@
--- | This module defines the `Comonad` type class
+-- | This module defines the `Comonad` type class.
 
 module Control.Comonad where
 

src/Control/Extend.purs

@@ -1,4 +1,4 @@
--- | This module defines the `Extend` type class and associated helper functions
+-- | This module defines the `Extend` type class and associated helper functions.
 
 module Control.Extend where
 
@@ -23,20 +23,20 @@ class (Functor w) <= Extend w where
 instance extendArr :: (Semigroup w) => Extend ((->) w) where
   (<<=) f g w = f \w' -> g (w <> w')
 
--- | A version of `(<<=)` with its arguments reversed
+-- | A version of `(<<=)` with its arguments flipped.
 (=>>) :: forall b a w. (Extend w) => w a -> (w a -> b) -> w b
 (=>>) w f = f <<= w
 
--- | Forwards co-Kleisli composition
+-- | Forwards co-Kleisli composition.
 (=>=) :: forall b a w c. (Extend w) => (w a -> b) -> (w b -> c) -> w a -> c
 (=>=) f g w = g (f <<= w)
 
--- | Backwards co-Kleisli composition
+-- | Backwards co-Kleisli composition.
 (=<=) :: forall b a w c. (Extend w) => (w b -> c) -> (w a -> b) -> w a -> c
 (=<=) f g w = f (g <<= w)
 
--- | Duplicate a comonadic context
+-- | Duplicate a comonadic context.
 -- |
--- | `duplicate` is dual to `join`.
+-- | `duplicate` is dual to `Control.Bind.join`.
 duplicate :: forall a w. (Extend w) => w a -> w (w a)
 duplicate w = id <<= w

src/Control/Functor.purs

@@ -1,14 +1,14 @@
--- | This module defines helper functions for working with `Functor` instances
+-- | This module defines helper functions for working with `Functor` instances.
 
 module Control.Functor where
 
 infixl 4 <$
 infixl 4 $>
 
--- | Ignore the return value of a computation, using the specified return value instead
+-- | Ignore the return value of a computation, using the specified return value instead.
 (<$) :: forall f a b. (Functor f) => a -> f b -> f a
 (<$) x f = const x <$> f
 
--- | A version of `(<$)` with its arguments flipped
+-- | A version of `(<$)` with its arguments flipped.
 ($>) :: forall f a b. (Functor f) => f a -> b -> f b
 ($>) f x = const x <$> f

src/Control/Lazy.purs

@@ -11,11 +11,11 @@ module Control.Lazy where
 class Lazy l where
   defer :: (Unit -> l) -> l
 
--- | A version of `Lazy` for type constructors of one type argument
+-- | A version of `Lazy` for type constructors of one type argument.
 class Lazy1 l where
   defer1 :: forall a. (Unit -> l a) -> l a
 
--- | A version of `Lazy` for type constructors of two type arguments
+-- | A version of `Lazy` for type constructors of two type arguments.
 class Lazy2 l where
   defer2 :: forall a b. (Unit -> l a b) -> l a b
 
@@ -25,10 +25,10 @@ class Lazy2 l where
 fix :: forall l a. (Lazy l) => (l -> l) -> l
 fix f = defer (\_ -> f (fix f))
 
--- | A version of `fix` for type constructors of one type argument
+-- | A version of `fix` for type constructors of one type argument.
 fix1 :: forall l a. (Lazy1 l) => (l a -> l a) -> l a
 fix1 f = defer1 (\_ -> f (fix1 f))
 
--- | A version of `fix` for type constructors of two type arguments
+-- | A version of `fix` for type constructors of two type arguments.
 fix2 :: forall l a b. (Lazy2 l) => (l a b -> l a b) -> l a b
 fix2 f = defer2 (\_ -> f (fix2 f))

src/Control/Monad.purs

@@ -1,16 +1,16 @@
--- | This module defines helper functions for working with `Monad` instances
+-- | This module defines helper functions for working with `Monad` instances.
 
 module Control.Monad where
 
--- | Perform a monadic action `n` times collecting all of the results
+-- | Perform a monadic action `n` times collecting all of the results.
 replicateM :: forall m a. (Monad m) => Number -> m a -> m [a]
 replicateM 0 _ = return []
 replicateM n m = do
   a <- m
   as <- replicateM (n - 1) m
   return (a : as)
 
--- | Perform a fold using a monadic step function
+-- | Perform a fold using a monadic step function.
 foldM :: forall m a b. (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
 foldM _ a [] = return a
 foldM f a (b:bs) = f a b >>= \a' -> foldM f a' bs

src/Control/Plus.purs

@@ -6,6 +6,7 @@ import Control.Alt
 
 -- | The `Plus` type class extends the `Alt` type class with a value that
 -- | should be the left and right identity for `(<|>)`.
+-- |
 -- | It is similar to `Monoid`, except that it applies to types of
 -- | kind `* -> *`, like `Array` or `List`, rather than concrete types like
 -- | `String` or `Number`.