Add Extend and Comonad instances (#3)

* Implement Extend and Comonad instances for the zipper

* Add Arbitrary instance for ArrayZipper

* Implement coarbitrary instance for ArrayZipper

* Verify type class instance laws via quickcheck-laws

* Fix one bug in implementation

* Fix Arbitrary instance to ensure array is not empty

* Fix extend instance: focus all elements with other other changes

* Remove unuesd imports

Author: JordanMartinez

spago.dhall

@@ -3,7 +3,14 @@ Welcome to a Spago project!
 You can edit this file as you like.
 -}
 { name = "my-project"
-, dependencies = [ "arrays", "psci-support", "spec" ]
+, dependencies =
+  [ "arrays"
+  , "psci-support"
+  , "quickcheck"
+  , "quickcheck-laws"
+  , "spec"
+  , "transformers"
+  ]
 , packages = ./packages.dhall
 , sources = [ "src/**/*.purs", "test/**/*.purs" ]
 , license = "MIT"

src/Data/Zipper/ArrayZipper.purs

@@ -38,14 +38,19 @@ module Data.Zipper.ArrayZipper
 
 import Prelude
 
+import Control.Comonad (class Comonad)
+import Control.Extend (class Extend)
+import Control.Monad.Gen (chooseInt)
 import Data.Array (findIndex, length, mapWithIndex, unsafeIndex)
+import Data.Array.NonEmpty as NEA
 import Data.Foldable (class Foldable, foldMapDefaultL, foldl, foldr)
 import Data.FoldableWithIndex (class FoldableWithIndex, foldMapWithIndex, foldlWithIndex, foldrWithIndex)
 import Data.FunctorWithIndex (class FunctorWithIndex)
 import Data.Maybe (Maybe(..), fromMaybe)
 import Data.Traversable (class Traversable, sequenceDefault, traverse)
 import Data.TraversableWithIndex (class TraversableWithIndex, traverseWithIndex)
 import Partial.Unsafe (unsafePartial)
+import Test.QuickCheck.Arbitrary (class Arbitrary, class Coarbitrary, arbitrary, coarbitrary)
 
 -- | An immutable Zipper for an Array. Modifications are `O(n)` due to creating
 -- | a new array rather than mutating the underlying array. Navigating to a
@@ -89,6 +94,16 @@ instance traversableWithIndex :: TraversableWithIndex Int ArrayZipper where
     ar <- traverseWithIndex f r.array
     in (ArrayZipper r { array = ar })
 
+instance extendArrayZipper :: Extend ArrayZipper where
+  extend :: forall b a. (ArrayZipper a -> b) -> ArrayZipper a -> ArrayZipper b
+  extend f (ArrayZipper rec) =
+    let allFoci idx _ = f (ArrayZipper rec { focusIndex = idx })
+    in ArrayZipper (rec { array = mapWithIndex allFoci rec.array})
+
+instance comonadArrayZipper :: Comonad ArrayZipper where
+  extract :: forall a. ArrayZipper a -> a
+  extract = getFocus
+
 -- | Creates an Array Zipper from a single element. This will be stored
 -- | internally as a 1-element array. To further build upon this array,
 -- | see `push*` functions.
@@ -281,3 +296,17 @@ pushNextRefocus a (ArrayZipper r) =
                   , maxIndex = r.maxIndex + 1
                   , array = unsafeInsertAt (r.focusIndex + 1) a r.array
                   }
+
+-- Test-related items
+instance arbitraryArrayZipper :: Arbitrary a => Arbitrary (ArrayZipper a) where
+  arbitrary = do
+    array <- NEA.toArray <$> arbitrary
+    let maxIndex = length array - 1
+    focusIndex <- chooseInt 0 maxIndex
+    pure $ ArrayZipper { array, focusIndex, maxIndex }
+
+instance coarbitraryArrayZipper :: Coarbitrary a => Coarbitrary (ArrayZipper a) where
+  coarbitrary (ArrayZipper r) =
+    coarbitrary r.array >>>
+    coarbitrary r.maxIndex >>>
+    coarbitrary r.focusIndex

test/Data/Zipper/ArrayZipper.purs

@@ -4,9 +4,14 @@ import Prelude
 
 import Data.Maybe (Maybe(..), fromJust)
 import Data.Zipper.ArrayZipper (ArrayZipper, asArrayZipper, getFocus, modifyFocus, next, prev, pushNextRefocus, pushPrevRefocus, setFocus, shiftFocusBy, shiftFocusBy', shiftFocusByFind, shiftFocusByFind', shiftFocusTo, shiftFocusTo', shiftFocusFirst, shiftFocusLast, toArrayZipperAt, toArrayZipperAt', toArrayZipperFirst, toArrayZipperLast)
+import Effect.Class (liftEffect)
 import Partial.Unsafe (unsafePartial)
+import Test.QuickCheck.Laws as Laws
+import Test.QuickCheck.Laws.Control (checkComonad, checkExtend)
+import Test.QuickCheck.Laws.Data (checkEq, checkFoldable, checkFoldableFunctor, checkFunctor, checkFunctorWithIndex, checkOrd)
 import Test.Spec (Spec, describe, it)
 import Test.Spec.Assertions (shouldEqual)
+import Type.Proxy (Proxy(..), Proxy2(..))
 
 spec :: Spec Unit
 spec = describe "Array Zipper" do
@@ -138,6 +143,26 @@ spec = describe "Array Zipper" do
         pushNextRefocus 10 i0 `shouldEqual` mkZipper 1 [0, 10, 1, 2, 3, 4]
         pushNextRefocus 10 i4 `shouldEqual` mkZipper 5 [0, 1, 2, 3, 4, 10]
 
+  describe "Laws" do
+    it "Eq" do
+      liftEffect $ checkEq  proxy1
+    it "Ord" do
+      liftEffect $ checkOrd proxy1
+
+    it "Functor" do
+      liftEffect $ checkFunctor proxy2
+    it "FunctorWithIndex" do
+      liftEffect $ checkFunctorWithIndex proxy2
+    it "Foldable via foldl/foldr" do
+      liftEffect $ checkFoldable proxy2
+    it "Foldable via foldMap" do
+      liftEffect $ checkFoldableFunctor proxy2
+
+    it "Extend" do
+      liftEffect $ checkExtend proxy2
+    it "Comonad" do
+      liftEffect $ checkComonad proxy2
+
   where
     emptyArray :: Array Int
     emptyArray = []
@@ -156,3 +181,7 @@ spec = describe "Array Zipper" do
 
     i4 :: ArrayZipper Int
     i4 = unsafePartial $ fromJust $ toArrayZipperAt 4 a4
+
+    proxy1 = Proxy :: Proxy (ArrayZipper Laws.A)
+
+    proxy2 = Proxy2 :: Proxy2 ArrayZipper