Added some failing examples.

Author: joneshf

examples/At.purs

@@ -11,7 +11,19 @@ module Examples.Control.Lens.At where
   foo = SM.fromList ["foo" ~ 2, "bar" ~ 3]
 
   main = do
+    print "Starting with:"
+    print foo
     print "Removing `foo`"
+    -- This doesn't compile, as it can't infer the `Maybe Number`.
+    -- print (foo # at "foo" .~ Nothing)
     print (foo # at "foo" .~ (Nothing :: Maybe Number))
     print "Inserting `baz`"
     print (foo # at "baz" ?~ 5)
+    print "Inserting `baz` and incrementing"
+    -- Neither of these compile.
+    -- This one has an `occurs check` failure.
+    -- print (foo # at "baz" ?~ 5 # ix "baz" +~ 12)
+    -- This one doesn't infer the type variable for `MonadState` properly.
+    -- print (foo #~ do
+    --   at "baz" ?= 5
+    --   ix "baz" += 12)

examples/Extend.purs

@@ -1,19 +1,21 @@
 module Control.Lens.Examples.Extend where
 
-  import Control.Lens ((.~), (^.), lens, Lens(), Setter())
+  import Control.Lens ((.~), (^.), (<#>), lens, Lens(), Setter())
 
   import Data.Foreign.EasyFFI (unsafeForeignFunction)
   import Debug.Trace (trace)
 
   ffi = unsafeForeignFunction
 
   fooExt :: forall a r. Setter { | r} {foo :: a | r} Unit a
-  fooExt = lens (const unit) (ffi ["obj", "x"] "obj.foo = x, obj")
+  fooExt f o = ffi ["obj", "x"] "obj.foo = x, obj" o <$> f unit
 
   foo :: forall a b r. Lens {foo :: a | r} {foo :: b | r} a b
-  foo = lens (\o -> o.foo) (\o x -> o{foo = x})
+  foo f o@{foo = a} = f a <#> \b -> o{foo = b}
 
   main = do
-    trace $ (fooExt.~"wat") {bar: 3} ^. foo
-    trace $ ((fooExt.~"wat") {bar: 3}). foo
-    trace $ {bar: 3}^.fooExt
+    let bar = {bar: 3}
+    trace ((bar # fooExt.~"one")^.foo)
+    trace ((bar # fooExt.~"two").foo)
+    -- This will not compile.
+    -- trace $ {bar: 3}^.fooExt

src/Control/Lens/At.purs

@@ -88,7 +88,7 @@ module Control.Lens.At
   instance atSetKKUnit :: (Ord k) => At (S.Set k) k Unit where
     at k a2fa setK = go <$> a2fa setK'
       where
-        setK' = if S.member k setK then Just unit else (Nothing :: Maybe Unit)
+        setK' = if S.member k setK then Just unit else Nothing
         go Nothing  = maybe setK (const $ S.delete k setK) setK'
         go (Just _) = S.insert k setK