Alphabetize imports.

Usually makes it easier to find the imports when you need to.

Author: joneshf

docs/Optic/Laws/Lens.md

@@ -2,6 +2,14 @@
 
 Valid `Lens`es should satisfy three laws.
 
+#### `validLens`
+
+``` purescript
+validLens :: forall s a b. (Eq a, Eq s) => LensP s a -> s -> a -> a -> a -> Boolean
+```
+
+A valid `Lens` satisfies all three of the following laws.
+
 #### `getSet`
 
 ``` purescript

src/Optic/Core.purs

@@ -7,14 +7,14 @@ module Optic.Core
   , (..)
   ) where
 
-  import Prelude (Semigroupoid, (<<<))
-
   import Optic.Getter
   import Optic.Lens
   import Optic.Prism
   import Optic.Setter
   import Optic.Types
 
+  import Prelude (Semigroupoid, (<<<))
+
   infixr 9 ..
 
   -- | `..` is a synonym for `<<<` for aesthetic reasons.

src/Optic/Getter.purs

@@ -6,13 +6,13 @@ module Optic.Getter
 
   infixl 8 ^.
 
-  import Prelude (Functor, (<$>))
+  import Data.Const (getConst, Const(..))
+  import Data.Functor.Contravariant ((>$<), Contravariant)
+  import Data.Profunctor (dimap, rmap, Profunctor)
 
   import Optic.Types (Getting())
 
-  import Data.Functor.Contravariant ((>$<), Contravariant)
-  import Data.Const (getConst, Const(..))
-  import Data.Profunctor (dimap, rmap, Profunctor)
+  import Prelude (Functor, (<$>))
 
   to :: forall a s f p. (Contravariant f, Functor f, Profunctor p) => (s -> a) -> p a (f a) -> p s (f s)
   to s2a = dimap s2a coerce

src/Optic/Internal/Prism.purs

@@ -1,11 +1,11 @@
 module Optic.Internal.Prism where
 
-  import Prelude (Functor, ($), (>>>))
-
   import Data.Profunctor (Profunctor)
   import Data.Profunctor.Choice (Choice)
   import Data.Either (either, Either(..))
 
+  import Prelude (Functor, ($), (>>>))
+
   data Market a b s t = Market (b -> t) (s -> Either t a)
   type MarketP a = Market a a
 

src/Optic/Internal/Setter.purs

@@ -1,12 +1,12 @@
 module Optic.Internal.Setter where
 
-  import Prelude (Applicative)
-
   import Data.Distributive (Distributive)
   import Data.Identity (runIdentity, Identity(..))
   import Data.Profunctor (rmap, Profunctor)
   import Data.Traversable (Traversable)
 
+  import Prelude (Applicative)
+
   class (Applicative f, Distributive f, Traversable f) <= Settable f where
     untainted :: forall a. f a -> a
     untaintedDot :: forall a b p. (Profunctor p) => p a (f b) -> p a b

src/Optic/Laws/Lens.purs

@@ -5,7 +5,13 @@ module Optic.Laws.Lens where
   import Optic.Setter (set)
   import Optic.Types (Lens(), LensP())
 
-  import Prelude (Eq, (==))
+  import Prelude (Eq, (&&), (==))
+
+  -- | A valid `Lens` satisfies all three of the following laws.
+  validLens :: forall s a b. (Eq a, Eq s) => LensP s a -> s -> a -> a -> a -> Boolean
+  validLens l s x y z = getSet l s
+                     && setGet l s x
+                     && setSet l s y z
 
   -- | If you get a value out, and then set it immediately back,
   -- | nothing should change.

src/Optic/Lens.purs

@@ -3,10 +3,10 @@ module Optic.Lens
   , lens
   ) where
 
-  import Prelude (Functor, (<$>))
-
   import Optic.Types (Lens())
 
+  import Prelude (Functor, (<$>))
+
   infixl 1 ??
 
   lens :: forall s t a b. (s -> a) -> (s -> b -> t) -> Lens s t a b

src/Optic/Prism.purs

@@ -10,21 +10,21 @@ module Optic.Prism
   , withPrism
   ) where
 
-  import Prelude ( Applicative, Eq
-                 , Unit()
-                 , ($), (==), (<<<), (<$>), (>>>)
-                 , const, not, pure, unit
-                 )
-
-  import Optic.Internal.Prism (Market(..))
-  import Optic.Types (APrism(), Prism(), PrismP())
-
   import Data.Either (either, Either(..))
   import Data.Identity (runIdentity, Identity(..))
   import Data.Maybe (maybe, Maybe(..))
   import Data.Profunctor (dimap)
   import Data.Profunctor.Choice (right, Choice)
 
+  import Optic.Internal.Prism (Market(..))
+  import Optic.Types (APrism(), Prism(), PrismP())
+
+  import Prelude ( Applicative, Eq
+                 , Unit()
+                 , ($), (==), (<<<), (<$>), (>>>)
+                 , const, not, pure, unit
+                 )
+
   clonePrism :: forall f p s t a b. (Applicative f, Choice p) => APrism  s t a b -> p a (f b) -> p s (f t)
   clonePrism stab = withPrism stab prism
 

src/Optic/Setter.purs

@@ -9,13 +9,6 @@ module Optic.Setter
   , sets
   ) where
 
-  import Prelude ( BooleanAlgebra, DivisionRing, Functor, Ring, Semigroup
-                 , Semiring
-                 , (+), (-), (*), (/), (||), (&&), (<>), (++), (<<<), (<$>)
-                 , (>>>)
-                 , const, flip
-                 )
-
   import Data.Functor.Contravariant ((>$<), Contravariant)
   import Data.Identity (runIdentity, Identity(..))
   import Data.Maybe (Maybe(..))
@@ -24,6 +17,13 @@ module Optic.Setter
   import Optic.Internal.Setter (taintedDot, untaintedDot, Settable)
   import Optic.Types (ASetter(), ASetterP(), Optical(), Setter(), Setting())
 
+  import Prelude ( BooleanAlgebra, DivisionRing, Functor, Ring, Semigroup
+                 , Semiring
+                 , (+), (-), (*), (/), (||), (&&), (<>), (++), (<<<), (<$>)
+                 , (>>>)
+                 , const, flip
+                 )
+
   infixr 4 %~
   infixr 4 .~
   infixr 4 +~

src/Optic/Types.purs

@@ -1,16 +1,16 @@
 module Optic.Types where
 
-  import Prelude
-
-  import Optic.Internal.Prism (Market())
-  import Optic.Internal.Setter (Settable)
-
   import Data.Const (Const())
   import Data.Functor.Contravariant (Contravariant)
   import Data.Identity (Identity())
   import Data.Profunctor (Profunctor)
   import Data.Profunctor.Choice (Choice)
 
+  import Optic.Internal.Prism (Market())
+  import Optic.Internal.Setter (Settable)
+
+  import Prelude (Applicative, Functor)
+
   type Accessing p m s a = p a (Const m a) -> s -> Const m s
 
   type APrism s t a b = Market a b a (Identity b) -> Market a b s (Identity t)