Get tests running

Also started laws.
We need to do `Prism` laws as well.
I'm not sure how to formulate them without using functions from
`purescript-optic`.
This will require some thinking.

Author: joneshf

bower.json

@@ -29,6 +29,7 @@
     "purescript-either": "~0.2.0",
     "purescript-identity": "~0.4.0",
     "purescript-maybe": "~0.3.2",
-    "purescript-profunctor": "~0.3.0"
+    "purescript-profunctor": "~0.3.0",
+    "purescript-console": "~0.1.0"
   }
 }

docs/Optic/Laws/Lens.md

@@ -0,0 +1,31 @@
+## Module Optic.Laws.Lens
+
+Valid `Lens`es should satisfy three laws.
+
+#### `getSet`
+
+``` purescript
+getSet :: forall s a. (Eq s) => LensP s a -> s -> Boolean
+```
+
+If you get a value out, and then set it immediately back,
+nothing should change.
+
+#### `setGet`
+
+``` purescript
+setGet :: forall s a. (Eq a) => LensP s a -> s -> a -> Boolean
+```
+
+If you set a value, and them get it immediately out,
+you should get the value you set.
+
+#### `setSet`
+
+``` purescript
+setSet :: forall s a b. (Eq s) => Lens s s a b -> s -> b -> b -> Boolean
+```
+
+If you set two values, the last set is the one that matters.
+
+

gulpfile.js

@@ -21,16 +21,18 @@ var paths =
               , 'Optic.Getter': 'docs/Optic/Getter.md'
               , 'Optic.Internal.Prism': 'docs/Optic/Internal/Prism.md'
               , 'Optic.Internal.Setter': 'docs/Optic/Internal/Setter.md'
+              , 'Optic.Laws.Lens': 'docs/Optic/Laws/Lens.md'
               , 'Optic.Lens': 'docs/Optic/Lens.md'
               , 'Optic.Prism': 'docs/Optic/Prism.md'
               , 'Optic.Setter': 'docs/Optic/Setter.md'
               , 'Optic.Types': 'docs/Optic/Types.md'
               }
+    , outputJs: 'output/**/*.js'
     , test: 'test/**/*.purs'
     };
 
 var options =
-    { test: { main: 'Test.Optic'
+    { test: { main: 'Test.Main'
             }
     };
 
@@ -72,8 +74,22 @@ gulp.task('docs', function() {
     });
 });
 
+gulp.task('test-compile', function() {
+    return purescript.psc({
+        src: paths.bowerSrc.concat(paths.src, paths.test),
+        ffi: paths.bowerFFIJs
+    });
+});
+
+gulp.task('test', ['test-compile'], function() {
+    return purescript.pscBundle({
+        src: paths.outputJs,
+        main: options.test.main
+    }).pipe(run('node'));
+});
+
 gulp.task('watch', function() {
-    gulp.watch(paths.src, function() {runSequence('psc', 'docs')});
+    gulp.watch([paths.src, paths.test], function() {runSequence('psc', 'test', 'docs')});
 });
 
-gulp.task('default', function() {runSequence('psc', 'docs')});
+gulp.task('default', function() {runSequence('psc', 'test', 'docs')});

src/Optic/Laws/Lens.purs

@@ -0,0 +1,22 @@
+-- | Valid `Lens`es should satisfy three laws.
+module Optic.Laws.Lens where
+
+  import Optic.Getter (view)
+  import Optic.Setter (set)
+  import Optic.Types (Lens(), LensP())
+
+  import Prelude (Eq, (==))
+
+  -- | If you get a value out, and then set it immediately back,
+  -- | nothing should change.
+  getSet :: forall s a. (Eq s) => LensP s a -> s -> Boolean
+  getSet l s = set l (view l s) s == s
+
+  -- | If you set a value, and them get it immediately out,
+  -- | you should get the value you set.
+  setGet :: forall s a. (Eq a) => LensP s a -> s -> a -> Boolean
+  setGet l s x = view l (set l x s) == x
+
+  -- | If you set two values, the last set is the one that matters.
+  setSet :: forall s a b. (Eq s) => Lens s s a b -> s -> b -> b -> Boolean
+  setSet l s x y = set l y (set l x s) == set l y s

test/Main.purs

@@ -1,51 +1,51 @@
 module Test.Main where
 
-import Prelude
-import Optic.Core
-import Control.Monad.Eff.Console
-
-newtype Foo bar baz = Foo
-  { foo :: { bar :: bar }
-  , baz :: baz
-  }
-  
-instance showFoo :: (Show bar, Show baz) => Show (Foo bar baz) where
-  show (Foo x) = "(Foo " ++ show x.foo.bar ++ " " ++ show x.baz ++ ")"
-
-_Foo :: forall bar1 baz1 bar2 baz2. 
-          Lens (Foo bar1 baz1) 
-               (Foo bar2 baz2) 
-               { baz :: baz1, foo :: { bar :: bar1 } } 
-               { baz :: baz2, foo :: { bar :: bar2 } }
-_Foo = lens (\(Foo x) -> x) (const Foo)
-
-foo :: forall a b r. Lens { foo :: a | r } { foo :: b | r } a b
-foo = lens _.foo (_ { foo = _ })
-
-foo' :: forall a b r. Lens { foo :: a | r } { foo :: b | r } a b
-foo' = foo
-
-bar :: forall a b r. Lens { bar :: a | r } { bar :: b | r } a b
-bar = lens _.bar (_ { bar = _ })
-
-baz :: forall a b r. Lens { baz :: a | r } { baz :: b | r } a b
-baz = lens _.baz (_ { baz = _ })
-
-fooBar :: forall a b r r'. Lens { foo :: { bar :: a | r } | r' } { foo :: { bar :: b | r } | r' } a b
-fooBar = foo..bar
-
-obj :: Foo Int Boolean
-obj = Foo { foo: { bar: 0 }, baz: true }
-
-succ :: Int -> Int
-succ x = x + 1
-
-main = do
-  print obj                                 -- (Foo 0 true)
-  print $ _Foo..baz .~ 10 $ obj             -- (Foo 0 10)
-  print $ _Foo..baz .~ "wat" $ obj          -- (Foo 0 "wat")
-  print $ _Foo..foo'..bar .~ 10 $ obj       -- (Foo 10 true)
-  print $ _Foo..fooBar +~ 40 $ obj          -- (Foo 40 true)
-  print $ obj ^. _Foo..fooBar               -- 0
-  print $ obj # _Foo..fooBar %~ succ        -- (Foo 1 true)
-  print $ over (_Foo..fooBar) succ obj      -- (Foo 1 true)
+  import Prelude (Show, (#), ($), (+), (++), bind, const, show)
+  import Optic.Core
+  import Control.Monad.Eff.Console (print)
+
+  newtype Foo bar baz = Foo
+    { foo :: { bar :: bar }
+    , baz :: baz
+    }
+
+  instance showFoo :: (Show bar, Show baz) => Show (Foo bar baz) where
+    show (Foo x) = "(Foo " ++ show x.foo.bar ++ " " ++ show x.baz ++ ")"
+
+  _Foo :: forall bar1 baz1 bar2 baz2.
+            Lens (Foo bar1 baz1)
+                 (Foo bar2 baz2)
+                 { baz :: baz1, foo :: { bar :: bar1 } }
+                 { baz :: baz2, foo :: { bar :: bar2 } }
+  _Foo = lens (\(Foo x) -> x) (const Foo)
+
+  foo :: forall a b r. Lens { foo :: a | r } { foo :: b | r } a b
+  foo = lens _.foo (_ { foo = _ })
+
+  foo' :: forall a b r. Lens { foo :: a | r } { foo :: b | r } a b
+  foo' = foo
+
+  bar :: forall a b r. Lens { bar :: a | r } { bar :: b | r } a b
+  bar = lens _.bar (_ { bar = _ })
+
+  baz :: forall a b r. Lens { baz :: a | r } { baz :: b | r } a b
+  baz = lens _.baz (_ { baz = _ })
+
+  fooBar :: forall a b r r'. Lens { foo :: { bar :: a | r } | r' } { foo :: { bar :: b | r } | r' } a b
+  fooBar = foo..bar
+
+  obj :: Foo Int Boolean
+  obj = Foo { foo: { bar: 0 }, baz: true }
+
+  succ :: Int -> Int
+  succ x = x + 1
+
+  main = do
+    print obj                                 -- (Foo 0 true)
+    print $ _Foo..baz .~ 10 $ obj             -- (Foo 0 10)
+    print $ _Foo..baz .~ "wat" $ obj          -- (Foo 0 "wat")
+    print $ _Foo..foo'..bar .~ 10 $ obj       -- (Foo 10 true)
+    print $ _Foo..fooBar +~ 40 $ obj          -- (Foo 40 true)
+    print $ obj ^. _Foo..fooBar               -- 0
+    print $ obj # _Foo..fooBar %~ succ        -- (Foo 1 true)
+    print $ over (_Foo..fooBar) succ obj      -- (Foo 1 true)