Fix setR (#17)

* Added some Modify tests

* Remove only to allow all tests to run

* Stop setR from reversing its arguments

* Added documentation to setL and setR

* Moved docs out from Pivot.Modify to Pivot

src/Pivot.elm

@@ -441,13 +441,23 @@ setC =
 
 
 {-| Replace the left.
+
+    setL [ 1, 2, 3 ] [ 99 * 4 * 5 ] == [ 1 2 3 * 4 * 5 ]
+
+    getL >> setL == identity
+
 -}
 setL : List a -> Pivot a -> Pivot a
 setL =
     Modify.setL
 
 
 {-| Replace the right.
+
+    setR [ 3, 4, 5 ] [ 1 * 2 * 99 ] == [ 1 * 2 * 3 4 5 ]
+
+    getR >> setR == identity
+
 -}
 setR : List a -> Pivot a -> Pivot a
 setR =

src/Pivot/Modify.elm

@@ -18,8 +18,8 @@ setL l_ (Pivot c ( l, r )) =
 
 
 setR : List a -> Pivot a -> Pivot a
-setR r_ =
-    setL r_ |> mirror
+setR r_ (Pivot c ( l, r )) =
+    Pivot c ( l, r_ )
 
 
 switchL : Pivot a -> Maybe (Pivot a)

tests/Modify.elm

@@ -0,0 +1,39 @@
+module Modify exposing (..)
+
+import Common.Units as Fuzz exposing (pivot)
+import Expect
+import Fuzz
+import Pivot
+import Test exposing (Test, describe)
+
+
+setL : Test
+setL =
+    describe "setL"
+        [ Test.fuzz (Fuzz.pivot Fuzz.int) "setL (getL a) a == a" <|
+            \pivot ->
+                Pivot.setL (Pivot.getL pivot) pivot
+                    |> Expect.equal pivot
+        , Test.fuzz2 (Fuzz.list Fuzz.int) (Fuzz.pivot Fuzz.int) "getL (setL l a) == l" <|
+            \list pivot ->
+                Pivot.getL (Pivot.setL list pivot)
+                    |> Expect.equal list
+        ]
+
+
+setR : Test
+setR =
+    describe "setR"
+        [ Test.fuzz (Fuzz.pivot Fuzz.int) "setR (getR a) == a" <|
+            \pivot ->
+                Pivot.setR (Pivot.getR pivot) pivot
+                    |> Expect.equal pivot
+        , Test.fuzz2 (Fuzz.list Fuzz.int) (Fuzz.pivot Fuzz.int) "getR (setR l a) == l" <|
+            \list pivot ->
+                Pivot.getR (Pivot.setR list pivot)
+                    |> Expect.equal list
+        , Test.fuzz3 Fuzz.int (Fuzz.list Fuzz.int) (Fuzz.pivot Fuzz.int) "goR (setR (x :: xs) a) == Just (setR xs (appendGoR x a))" <|
+            \x xs pivot ->
+                Pivot.goR (Pivot.setR (x :: xs) pivot)
+                    |> Expect.equal (Just (Pivot.setR xs (Pivot.appendGoR x pivot)))
+        ]

tests/Position.elm

@@ -10,10 +10,9 @@ import Test exposing (Test, describe, fuzz, fuzz2, fuzz3, only, skip, test)
 
 goR : Test
 goR =
-    only <|
-        describe "goR" <|
-            [ test "goR [1 2 3 *4*] == Nothing" <|
-                \_ -> E.equal (P.goR p_1_2_3__4__) Nothing
-            , test "goR [1 *2* 3 4] == Just [1 2 *3* 4]" <|
-                \_ -> E.equal (P.goR p_1__2__3_4_) (Just p_1_2__3__4_)
-            ]
+    describe "goR" <|
+        [ test "goR [1 2 3 *4*] == Nothing" <|
+            \_ -> E.equal (P.goR p_1_2_3__4__) Nothing
+        , test "goR [1 *2* 3 4] == Just [1 2 *3* 4]" <|
+            \_ -> E.equal (P.goR p_1__2__3_4_) (Just p_1_2__3__4_)
+        ]