system-f / lets-lens Goto Github PK

From here:

setP :: Prism s t a b -> s -> Either t a
getP :: Prism s t a b -> b -> t

This seems backwards.

In the module Lets.Lens, there is a setter function and a type alias that goes with it.

type Set s t a b =
  (a -> Identity b)
  -> s
  -> Identity t

-- | Let's write an inverse to @over@ that does the @Identity@ wrapping &
-- unwrapping.
sets ::
  ((a -> b) -> s -> t)
  -> ( a -> Identity b)
  -> s
  -> Identity t
  -- -> Set s t a b
sets f idM = Identity . f (getIdentity . idM)

mapped ::
  Functor f =>
  Set (f a) (f b) a b
mapped = sets fmap

set ::
  Set s t a b
  -> s
  -> b
  -> t
set q s b = over q (const b) s

Later in the module, we can see the use of the data structure Set, which has nothing to do with the setter functions and therefore can be confusing.
It may be worth renaming the setter functions, perhaps to update or something else.

In Lets.Lens, modify has the following type signature:

modify :: Lens s t a b -> (a -> b) -> s -> t

This is fine until the final exercise, which seems to want me to use a Prism with modify:

intOrLengthEven :: IntOr [a] -> IntOr Bool
intOrLengthEven = modify intOrP (even . length)

This fails with the following type error:

src/Lets/Lens.hs:756:26: error:
    • Could not deduce (Applicative f) arising from a use of ‘intOrP’
      from the context: Functor f
        bound by a type expected by the context:
                   Lens (IntOr [a]) (IntOr Bool) [a] Bool
        at src/Lets/Lens.hs:756:19-47
      Possible fix:
        add (Applicative f) to the context of
          a type expected by the context:
            Lens (IntOr [a]) (IntOr Bool) [a] Bool
    • In the first argument of ‘modify’, namely ‘intOrP’
      In the expression: modify intOrP (even . length)
      In an equation for ‘intOrLengthEven’:
          intOrLengthEven = modify intOrP (even . length)
    |
756 | intOrLengthEven = modify intOrP (even . length)
    |                          ^^^^^^

Changing the type of modify to modify :: Set s t a b -> (a -> b) -> s -> t fixes this problem. I note that lens uses this type for over :: ASetter s t a b -> (a -> b) -> s -> t (because type ASetter s t a b = (a -> Identity b) -> s -> Identity t ).