summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--README.md4
-rw-r--r--data-diverse-lens.cabal4
-rw-r--r--src/Data/Diverse/Lens/Many.hs85
-rw-r--r--src/Data/Diverse/Profunctor/Many.hs24
-rw-r--r--src/Data/Diverse/Profunctor/Which.hs45
-rw-r--r--test/Data/Diverse/Lens/ManySpec.hs80
6 files changed, 100 insertions, 142 deletions
diff --git a/README.md b/README.md
index f8f6c95..eaab1ac 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,10 @@ Refer to [ManySpec.hs](https://github.com/louispan/data-diverse-lens/blob/master
# Changelog
+* 4.3.0.0
+ - Replaced `piece'` with `hasLens`, `piece` with `hadLens`
+ - Replaced `pieceX'` with `hasX`, `pieceX` `hadX`
+
* 4.2.0.1
- Missed removing Semigroup constraint from `chooseWith`
diff --git a/data-diverse-lens.cabal b/data-diverse-lens.cabal
index 47ccd73..f2f1542 100644
--- a/data-diverse-lens.cabal
+++ b/data-diverse-lens.cabal
@@ -1,5 +1,5 @@
name: data-diverse-lens
-version: 4.2.0.1
+version: 4.3.0.0
synopsis: Isos & Lens for Data.Diverse.Many and Prisms for Data.Diverse.Which
description: Isos & Lens for Data.Diverse.Many and Prisms for Data.Diverse.Which
Refer to [ManySpec.hs](https://github.com/louispan/data-diverse-lens/blob/master/test/Data/Diverse/Lens/ManySpec.hs) and [WhichSpec.hs](https://github.com/louispan/data-diverse-lens/blob/master/test/Data/Diverse/Lens/WhichSpec.hs) for example usages.
@@ -29,7 +29,7 @@ library
, profunctors >= 5.2
, lens >= 4
, data-has >= 0.3
- ghc-options: -Wall
+ ghc-options: -Wall -Wredundant-constraints
default-language: Haskell2010
test-suite data-diverse-lens-test
diff --git a/src/Data/Diverse/Lens/Many.hs b/src/Data/Diverse/Lens/Many.hs
index ba37739..5a9263c 100644
--- a/src/Data/Diverse/Lens/Many.hs
+++ b/src/Data/Diverse/Lens/Many.hs
@@ -24,9 +24,8 @@ module Data.Diverse.Lens.Many (
-- * Single field
-- ** Lens for a single field
, Has(..)
- , piece'
- , pieceTag
- , pieceTag'
+ , hasTag
+ , hadTag
, Had(..)
, HasL(..)
, HadL(..)
@@ -69,97 +68,97 @@ _Many' = iso fromMany' toMany'
-----------------------------------------------------------------------
--- | Convient name for 'hasLens' to be consistent with 'Had' typeclass.
---
--- @
--- let x = (5 :: Int) './' False './' \'X' './' Just \'O' './' 'nil'
--- x '^.' 'piece'' \@Int \`shouldBe` 5
--- (x '&' 'piece'' \@Int .~ 6) \`shouldBe` (6 :: Int) './' False './' \'X' './' Just \'O' './' 'nil'
--- @
-piece' :: Has a s => Lens' s a
-piece' = hasLens
+-- -- | Convient name for 'hasLens' to be consistent with 'Had' typeclass.
+-- --
+-- -- @
+-- -- let x = (5 :: Int) './' False './' \'X' './' Just \'O' './' 'nil'
+-- -- x '^.' 'has'' \@Int \`shouldBe` 5
+-- -- (x '&' 'has'' \@Int .~ 6) \`shouldBe` (6 :: Int) './' False './' \'X' './' Just \'O' './' 'nil'
+-- -- @
+-- has' :: Has a s => Lens' s a
+-- has' = hasLens
instance UniqueMember x xs => Has x (Many xs) where
hasLens = lens grab replace'
--- | Polymorphic version of 'piece''
+-- | Polymorphic version of 'has''
class (Has a s, Replaced a a s ~ s) => Had a s where
type Replaced a b s
- piece :: Lens s (Replaced a b s) a b
+ hadLens :: Lens s (Replaced a b s) a b
instance (UniqueMember x xs) => Had x (Many xs) where
type Replaced x b (Many xs) = Many (Replace x b xs)
- piece = lens grab (replace @x)
+ hadLens = lens grab (replace @x)
-pieceTag' :: forall l a s. Has (Tagged l a) s => Lens' s a
-pieceTag' = piece' @(Tagged l a) . iso unTagged Tagged
+hasTag :: forall l a s. Has (Tagged l a) s => Lens' s a
+hasTag = hasLens @(Tagged l a) . iso unTagged Tagged
-pieceTag :: forall l a b s. Had (Tagged l a) s
+hadTag :: forall l a b s. Had (Tagged l a) s
=> Lens s (Replaced (Tagged l a) (Tagged l b) s) a b
-pieceTag = piece @(Tagged l a) . iso unTagged (Tagged @l)
+hadTag = hadLens @(Tagged l a) . iso unTagged (Tagged @l)
--- | 'grabL' ('view' 'pieceL') and 'replaceL' ('set' 'pieceL') in 'Lens'' form.
+-- | 'grabL' ('view' 'hasL') and 'replaceL' ('set' 'hasL') in 'Lens'' form.
--
-- @
-- let x = (5 :: Int) './' Tagged \@Foo False './' Tagged \@Bar \'X' './' 'nil'
--- x '^.' 'pieceL'' \@Foo \`shouldBe` Tagged \@Foo False
--- (x '&' 'pieceL'' \@Foo '.~' Tagged \@Foo True) \`shouldBe` (5 :: Int) './' Tagged \@Foo True './' Tagged \@Bar \'X' './' 'nil'
+-- x '^.' 'hasL'' \@Foo \`shouldBe` Tagged \@Foo False
+-- (x '&' 'hasL'' \@Foo '.~' Tagged \@Foo True) \`shouldBe` (5 :: Int) './' Tagged \@Foo True './' Tagged \@Bar \'X' './' 'nil'
-- @
--
-- A default implementation using generics is not provided as it make GHC think that @l@ must be type @Symbol@
-- when @l@ can actually be any kind.
-- Create instances of 'HasL' using "Data.Generics.Product.Fields" as follows:
-- @
--- instance HasField' l Foo a => pieceL' l a Foo where
--- pieceL' = field @l
--- default pieceL' :: forall (l :: Symbol) a s. (HasField' l s a) => Lens' s a
--- pieceL' = field @l
+-- instance HasField' l Foo a => hasL' l a Foo where
+-- hasL' = field @l
+-- default hasL' :: forall (l :: Symbol) a s. (HasField' l s a) => Lens' s a
+-- hasL' = field @l
class HasL (l :: k) a s | s l -> a where
- pieceL' :: Lens' s a
+ hasL :: Lens' s a
instance (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => HasL l x (Many xs) where
- pieceL' = lens (grabL @l) (replaceL' @l)
+ hasL = lens (grabL @l) (replaceL' @l)
--- | Polymorphic version of 'pieceL''
+-- | Polymorphic version of 'hasL''
--
-- @
-- let x = (5 :: Int) './' Tagged @Foo False './' Tagged \@Bar \'X' './' 'nil'
--- (x '&' 'pieceL' \@Foo '.~' \"foo") \`shouldBe` (5 :: Int) './' \"foo" './' Tagged \@Bar \'X' './' 'nil'
+-- (x '&' 'hasL' \@Foo '.~' \"foo") \`shouldBe` (5 :: Int) './' \"foo" './' Tagged \@Bar \'X' './' 'nil'
-- @
class (HasL (l :: k) a s, ReplacedL l a a s ~ s) => HadL (l :: k) a s | s l -> a where
type ReplacedL l a b s
- pieceL :: Lens s (ReplacedL l a b s) a b
+ hadL :: Lens s (ReplacedL l a b s) a b
instance (UniqueLabelMember l xs, x ~ KindAtLabel l xs) => HadL l x (Many xs) where
type ReplacedL l x b (Many xs) = Many (Replace (KindAtLabel l xs) b xs)
- pieceL = lens (grabL @l) (replaceL @l)
+ hadL = lens (grabL @l) (replaceL @l)
--- | 'grabN' ('view' 'piece') and 'replaceN'' ('set' 'piece'') in 'Lens'' form.
+-- | 'grabN' ('view' 'has') and 'replaceN'' ('set' 'has'') in 'Lens'' form.
--
-- @
-- let x = (5 :: Int) './' False './' \'X' './' Just \'O' './' (6 :: Int) './' Just \'A' ./ nil
--- x '^.' 'pieceN'' \@0 \`shouldBe` 5
--- (x '&' 'pieceN'' \@0 '.~' 6) \`shouldBe` (6 :: Int) './' False './' \'X' './' Just \'O' './' (6 :: Int) './' Just \'A' './' 'nil'
+-- x '^.' 'hasN'' \@0 \`shouldBe` 5
+-- (x '&' 'hasN'' \@0 '.~' 6) \`shouldBe` (6 :: Int) './' False './' \'X' './' Just \'O' './' (6 :: Int) './' Just \'A' './' 'nil'
-- @
class HasN (n :: Nat) a s | s n -> a where
- pieceN' :: Lens' s a
+ hasN :: Lens' s a
instance (MemberAt n x xs) => HasN n x (Many xs) where
- pieceN' = lens (grabN @n) (replaceN' @n)
+ hasN = lens (grabN @n) (replaceN' @n)
--- | Polymorphic version of 'pieceN''
+-- | Polymorphic version of 'hasN''
class (HasN (n :: Nat) a s, ReplacedN n a a s ~ s) => HadN (n :: Nat) a s | s n -> a where
type ReplacedN n a b s
- pieceN :: Lens s (ReplacedN n a b s) a b
+ hadN :: Lens s (ReplacedN n a b s) a b
- -- -- | Make it easy to create an instance of 'pieceN' using 'Data.Generics.Product.Positions'
- -- default pieceN :: (HasPosition n s (ReplacedN n a b s) a b) => Lens s (ReplacedN n a b s) a b
- -- pieceN = position @n
+ -- -- | Make it easy to create an instance of 'hasN' using 'Data.Generics.Product.Positions'
+ -- default hasN :: (HasPosition n s (ReplacedN n a b s) a b) => Lens s (ReplacedN n a b s) a b
+ -- hasN = position @n
instance (MemberAt n x xs)
=> HadN n x (Many xs) where
type ReplacedN n x b (Many xs) = Many (ReplaceIndex n x b xs)
- pieceN = lens (grabN @n) (replaceN @n)
+ hadN = lens (grabN @n) (replaceN @n)
-----------------------------------------------------------------------
diff --git a/src/Data/Diverse/Profunctor/Many.hs b/src/Data/Diverse/Profunctor/Many.hs
index e5dcaa3..cb6cd55 100644
--- a/src/Data/Diverse/Profunctor/Many.hs
+++ b/src/Data/Diverse/Profunctor/Many.hs
@@ -10,9 +10,9 @@
module Data.Diverse.Profunctor.Many (
-- * Combinators similar to Profunctor Strong
- Pieced
- , pieced
- , piecedK
+ Have
+ , have
+ , haveK
, Projected
, projected
, projectedK
@@ -32,30 +32,30 @@ import Data.Diverse.Many
import Data.Diverse.TypeLevel
import Data.Profunctor
--- | A friendlier constraint synonym for 'pieced'.
-type Pieced a b s t =
+-- | A friendlier constraint synonym for 'have'.
+type Have a b s t =
( Had a s
, t ~ Replaced a b s
)
-- | Like 'Strong' or 'Arrow' but lifting into 'Many'
-pieced ::
+have ::
forall w a b s t.
( Profunctor w
, Strong w
- , Pieced a b s t
+ , Have a b s t
)
=> w a b -> w s t
-pieced w = dimap (\c -> (view piece' c, c)) (\(b, c) -> set (piece @a) b c) (first' w)
+have w = dimap (\c -> (view hasLens c, c)) (\(b, c) -> set (hadLens @a) b c) (first' w)
--- | 'pieced' under 'Kleisli'
-piecedK ::
+-- | 'have' under 'Kleisli'
+haveK ::
forall m a b s t.
( Monad m
- , Pieced a b s t
+ , Have a b s t
)
=> (a -> m b) -> (s -> m t)
-piecedK f = runKleisli . pieced $ Kleisli f
+haveK f = runKleisli . have $ Kleisli f
-- | A friendlier constraint synonym for 'projected'.
type Projected a1 a2 b1 b2 =
diff --git a/src/Data/Diverse/Profunctor/Which.hs b/src/Data/Diverse/Profunctor/Which.hs
index d31c0e5..cee9f65 100644
--- a/src/Data/Diverse/Profunctor/Which.hs
+++ b/src/Data/Diverse/Profunctor/Which.hs
@@ -22,9 +22,6 @@ module Data.Diverse.Profunctor.Which (
, thenChoose
, thenChooseK
, chooseWith
- -- , (+||+)
- -- , (>||>)
- -- , (<||<)
) where
import Control.Arrow
@@ -93,17 +90,6 @@ type ChooseBoth b1 b2 b3 =
, b3 ~ AppendUnique b1 b2
)
--- chooseBoth ::
--- ( C.Category w
--- , Strong w
--- , ChooseBoth b1 b2 b3
--- )
--- => w a (Which b1)
--- -> w a (Which b2)
--- -> w a (Which b3, Which b3)
--- chooseBoth x y = lmap (\a -> (a, a)) (first' (rmap diversify x)) C.>>> (second' (rmap diversify y))
--- infixr 2 `chooseBoth` -- like +++
-
-- | A friendlier constraint synonym for 'chooseFrom'.
-- Redundant constraint: @a3 ~ Append a1 a2@ is redundant but narrows down @a3@
type ChooseFrom a1 a2 a3 =
@@ -112,12 +98,6 @@ type ChooseFrom a1 a2 a3 =
, a3 ~ Append a1 a2
)
--- -- | A friendlier constraint synonym for 'chooseBetween'.
--- type ChooseBetween a1 a2 a3 b1 b2 b3 =
--- ( ChooseFrom a1 a2 a3
--- , ChooseBoth b1 b2 b3
--- )
-
-- | Split the input between the two argument arrows, retagging and merging their outputs.
-- The output is merged into a 'Which' of unique types.
-- Analogous to a 'Which' combination of both 'Control.Arrow.+++' and 'Control.Arrow.|||'.
@@ -149,17 +129,6 @@ chooseBetweenK :: forall m a1 a2 a3 b1 b2 b3.
chooseBetweenK f g = runKleisli $ chooseBetween (Kleisli f) (Kleisli g)
infixr 2 `chooseBetweenK` -- like +++
--- (+||+) ::
--- ( C.Category w
--- , Choice w
--- , ChooseBetween a1 a2 a3 b1 b2 b3
--- )
--- => w (Which a1) (Which b1)
--- -> w (Which a2) (Which b2)
--- -> w (Which a3) (Which b3)
--- (+||+) = chooseBetween
--- infixr 2 +||+ -- like +++
-
-- | Left-to-right chaining of arrows one after another, where left over possibilities not handled
-- by the right arrow is forwarded to the output.
-- It is a compile error if the types are not distinct in each of the argument arrow inputs,
@@ -187,23 +156,9 @@ thenChooseK :: forall m a a2 b1 b2 b3.
thenChooseK f g = runKleisli $ thenChoose (Kleisli f) (Kleisli g)
infixr 2 `thenChooseK` -- like +++
--- -- | right-to-left version of '(>||>)'
--- (<||<)
--- :: forall w a a2 b1 b2 b3.
--- ( C.Category w
--- , Choice w
--- , Injected a2 b1 b2 b3
--- )
--- => w (Which a2) (Which b2)
--- -> w a (Which b1)
--- -> w a (Which b3)
--- (<||<) = flip (>||>)
--- infixr 2 <||< -- like >||>
-
------------------------------------------
chooseWith :: (Functor f, ChooseBoth a1 a2 a3)
=> (f (Which a3) -> f (Which a3) -> f (Which a3)) -> f (Which a1) -> f (Which a2) -> f (Which a3)
chooseWith f x y = (diversify <$> x) `f` (diversify <$> y)
infixr 6 `chooseWith` -- like mappend
-
diff --git a/test/Data/Diverse/Lens/ManySpec.hs b/test/Data/Diverse/Lens/ManySpec.hs
index f9032fd..ed7bf37 100644
--- a/test/Data/Diverse/Lens/ManySpec.hs
+++ b/test/Data/Diverse/Lens/ManySpec.hs
@@ -32,55 +32,55 @@ spec = do
x `shouldBe` review _Many' t
t `shouldBe` view _Many' x
- it "has getter/setter lens using 'piece''" $ do
+ it "has getter/setter lens using 'hasLens'" $ do
let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil
- x ^. piece' @Int `shouldBe` 5
- (x & piece' @Int .~ 6) `shouldBe` (6 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil
- x ^. piece' @Bool `shouldBe` False
- (x & piece' @Bool .~ True) `shouldBe` (5 :: Int) ./ True ./ 'X' ./ Just 'O' ./ nil
- x ^. piece' @Char `shouldBe` 'X'
- x ^. piece' @(Maybe Char) `shouldBe` Just 'O'
-
- it "has polymorphic getter/setter lens using 'piece'" $ do
+ x ^. hasLens @Int `shouldBe` 5
+ (x & hasLens @Int .~ 6) `shouldBe` (6 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil
+ x ^. hasLens @Bool `shouldBe` False
+ (x & hasLens @Bool .~ True) `shouldBe` (5 :: Int) ./ True ./ 'X' ./ Just 'O' ./ nil
+ x ^. hasLens @Char `shouldBe` 'X'
+ x ^. hasLens @(Maybe Char) `shouldBe` Just 'O'
+
+ it "has polymorphic getter/setter lens using 'hasLens" $ do
let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil
- (x & piece @(Maybe Char) .~ Just 'P') `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'P' ./ nil
- (x & piece @Int .~ 'Z') `shouldBe` 'Z' ./ False ./ 'X' ./ Just 'O' ./ nil
- (x & piece @Bool .~ 'Z') `shouldBe` (5 :: Int) ./ 'Z' ./ 'X' ./ Just 'O' ./ nil
- (x & piece @Char .~ True) `shouldBe` (5 :: Int) ./ False ./ True ./ Just 'O' ./ nil
- (x & piece @(Maybe Char) .~ 'P') `shouldBe` (5 :: Int) ./ False ./ 'X' ./ 'P' ./ nil
+ (x & hadLens @(Maybe Char) .~ Just 'P') `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'P' ./ nil
+ (x & hadLens @Int .~ 'Z') `shouldBe` 'Z' ./ False ./ 'X' ./ Just 'O' ./ nil
+ (x & hadLens @Bool .~ 'Z') `shouldBe` (5 :: Int) ./ 'Z' ./ 'X' ./ Just 'O' ./ nil
+ (x & hadLens @Char .~ True) `shouldBe` (5 :: Int) ./ False ./ True ./ Just 'O' ./ nil
+ (x & hadLens @(Maybe Char) .~ 'P') `shouldBe` (5 :: Int) ./ False ./ 'X' ./ 'P' ./ nil
- it "has getter/setter lens using 'pieceL''" $ do
+ it "has getter/setter lens using 'hasL'" $ do
let x = (5 :: Int) ./ Tagged @Foo False ./ Tagged @Bar 'X' ./ nil
- x ^. pieceL' @Foo `shouldBe` Tagged @Foo False
- (x & pieceL' @Foo .~ Tagged @Foo True) `shouldBe` (5 :: Int) ./ Tagged @Foo True ./ Tagged @Bar 'X' ./ nil
+ x ^. hasL @Foo `shouldBe` Tagged @Foo False
+ (x & hasL @Foo .~ Tagged @Foo True) `shouldBe` (5 :: Int) ./ Tagged @Foo True ./ Tagged @Bar 'X' ./ nil
- it "has polymorphic getter/setter lens using 'pieceL'" $ do
+ it "has polymorphic getter/setter lens using 'hasL" $ do
let x = (5 :: Int) ./ Tagged @Foo False ./ Tagged @Bar 'X' ./ nil
- (x & pieceL @Foo .~ "foo") `shouldBe` (5 :: Int) ./ "foo" ./ Tagged @Bar 'X' ./ nil
+ (x & hadL @Foo .~ "foo") `shouldBe` (5 :: Int) ./ "foo" ./ Tagged @Bar 'X' ./ nil
- it "has getter/setter lens for duplicate fields using 'pieceN''" $ do
+ it "has getter/setter lens for duplicate fields using 'hasN'" $ do
let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
- x ^. pieceN' @0 `shouldBe` 5
- (x & pieceN' @0 .~ 6) `shouldBe` (6 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
- x ^. pieceN' @1 `shouldBe` False
- (x & pieceN' @1 .~ True) `shouldBe` (5 :: Int) ./ True ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
- x ^. pieceN' @2 `shouldBe` 'X'
- (x & pieceN' @2 .~ 'O') `shouldBe` (5 :: Int) ./ False ./ 'O' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
- x ^. pieceN' @3 `shouldBe` Just 'O'
- (x & pieceN' @3 .~ Just 'P') `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'P' ./ (6 :: Int) ./ Just 'A' ./ nil
- x ^. pieceN' @4 `shouldBe` 6
- (x & pieceN' @4 .~ 7) `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (7 :: Int) ./ Just 'A' ./ nil
- x ^. pieceN' @5 `shouldBe` Just 'A'
- (x & pieceN' @5 .~ Just 'B') `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'B' ./ nil
-
- it "has polymorphic getter/setter lens for duplicate fields using 'pieceN'" $ do
+ x ^. hasN @0 `shouldBe` 5
+ (x & hasN @0 .~ 6) `shouldBe` (6 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
+ x ^. hasN @1 `shouldBe` False
+ (x & hasN @1 .~ True) `shouldBe` (5 :: Int) ./ True ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
+ x ^. hasN @2 `shouldBe` 'X'
+ (x & hasN @2 .~ 'O') `shouldBe` (5 :: Int) ./ False ./ 'O' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
+ x ^. hasN @3 `shouldBe` Just 'O'
+ (x & hasN @3 .~ Just 'P') `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'P' ./ (6 :: Int) ./ Just 'A' ./ nil
+ x ^. hasN @4 `shouldBe` 6
+ (x & hasN @4 .~ 7) `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (7 :: Int) ./ Just 'A' ./ nil
+ x ^. hasN @5 `shouldBe` Just 'A'
+ (x & hasN @5 .~ Just 'B') `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'B' ./ nil
+
+ it "has polymorphic getter/setter lens for duplicate fields using 'hasN" $ do
let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
- (x & pieceN @0 .~ "Foo") `shouldBe` "Foo" ./ False ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
- (x & pieceN @1 .~ "Foo") `shouldBe` (5 :: Int) ./ "Foo" ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
- (x & pieceN @2 .~ "Foo") `shouldBe` (5 :: Int) ./ False ./ "Foo" ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
- (x & pieceN @3 .~ "Foo") `shouldBe` (5 :: Int) ./ False ./ 'X' ./ "Foo" ./ (6 :: Int) ./ Just 'A' ./ nil
- (x & pieceN @4 .~ "Foo") `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ "Foo" ./ Just 'A' ./ nil
- (x & pieceN @5 .~ "Foo") `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ "Foo" ./ nil
+ (x & hadN @0 .~ "Foo") `shouldBe` "Foo" ./ False ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
+ (x & hadN @1 .~ "Foo") `shouldBe` (5 :: Int) ./ "Foo" ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
+ (x & hadN @2 .~ "Foo") `shouldBe` (5 :: Int) ./ False ./ "Foo" ./ Just 'O' ./ (6 :: Int) ./ Just 'A' ./ nil
+ (x & hadN @3 .~ "Foo") `shouldBe` (5 :: Int) ./ False ./ 'X' ./ "Foo" ./ (6 :: Int) ./ Just 'A' ./ nil
+ (x & hadN @4 .~ "Foo") `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ "Foo" ./ Just 'A' ./ nil
+ (x & hadN @5 .~ "Foo") `shouldBe` (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ (6 :: Int) ./ "Foo" ./ nil
it "has getter/setter lens for multiple fields using 'project''" $ do
let x = (5 :: Int) ./ False ./ 'X' ./ Just 'O' ./ nil