Optics.Iso

Type synonym for a type-modifying iso.

Type synonym for a type-preserving iso.

Build an iso from a pair of inverse functions.

If you want to build an Iso from the van Laarhoven representation, use isoVL from the optics-vl package.

Capture type constraints as an isomorphism.

Note: This is the identity optic:

>>> :t view equalityview equality :: a -> a

Proof of reflexivity.

Data types that are representationally equal are isomorphic.

>>> view coerced 'x' :: Identity CharIdentity 'x'

Type-preserving version of coerced with type parameters rearranged for TypeApplications.

>>> newtype MkInt = MkInt Int deriving Show

>>> over (coercedTo @Int) (*3) (MkInt 2)MkInt 6

Special case of coerced for trivial newtype wrappers.

>>> over (coerced1 @Identity) (++ "bar") (Identity "foo")Identity "foobar"

If v is an element of a type a, and a' is a sans the element v, then non v is an isomorphism from Maybe a' to a.

non ≡ non' . only

Keep in mind this is only a real isomorphism if you treat the domain as being Maybe (a sans v).

This is practically quite useful when you want to have a Data.Map.Map where all the entries should have non-zero values.

>>> Map.fromList [("hello",1)] & at "hello" % non 0 %~ (+2)fromList [("hello",3)]

>>> Map.fromList [("hello",1)] & at "hello" % non 0 %~ (subtract 1)fromList []

>>> Map.fromList [("hello",1)] ^. at "hello" % non 01

>>> Map.fromList [] ^. at "hello" % non 00

This combinator is also particularly useful when working with nested maps.

e.g. When you want to create the nested Data.Map.Map when it is missing:

>>> Map.empty & at "hello" % non Map.empty % at "world" ?~ "!!!"fromList [("hello",fromList [("world","!!!")])]

and when have deleting the last entry from the nested Data.Map.Map mean that we should delete its entry from the surrounding one:

>>> Map.fromList [("hello", Map.fromList [("world","!!!")])] & at "hello" % non Map.empty % at "world" .~ NothingfromList []

It can also be used in reverse to exclude a given value:

>>> non 0 # rem 10 4Just 2

>>> non 0 # rem 10 5Nothing

non' p generalizes non (p # ()) to take any unit Prism

This function generates an isomorphism between Maybe (a | isn't p a) and a.

>>> Map.singleton "hello" Map.empty & at "hello" % non' _Empty % at "world" ?~ "!!!"fromList [("hello",fromList [("world","!!!")])]

>>> Map.fromList [("hello", Map.fromList [("world","!!!")])] & at "hello" % non' _Empty % at "world" .~ NothingfromList []

anon a p generalizes non a to take any value and a predicate.

anon a ≡ non' . nearly a

This function assumes that p a holds True and generates an isomorphism between Maybe (a | not (p a)) and a.

>>> Map.empty & at "hello" % anon Map.empty Map.null % at "world" ?~ "!!!"fromList [("hello",fromList [("world","!!!")])]

>>> Map.fromList [("hello", Map.fromList [("world","!!!")])] & at "hello" % anon Map.empty Map.null % at "world" .~ NothingfromList []

The canonical isomorphism for currying and uncurrying a function.

curried = iso curry uncurry

>>> view curried fst 3 43

The canonical isomorphism for uncurrying and currying a function.

uncurried = iso uncurry curry

uncurried = re curried

>>> (view uncurried (+)) (1,2)3

The isomorphism for flipping a function.

>>> (view flipped (,)) 1 2(2,1)

Given a function that is its own inverse, this gives you an Iso using it in both directions.

involuted ≡ join iso

>>> "live" ^. involuted reverse"evil"

>>> "live" & involuted reverse %~ ('d':)"lived"

This class provides for symmetric bifunctors.

Extract the two components of an isomorphism.

Based on ala from Conor McBride's work on Epigram.

This version is generalized to accept any Iso, not just a newtype.

>>> au (coerced1 @Sum) foldMap [1,2,3,4]10

You may want to think of this combinator as having the following, simpler type:

au :: Iso s t a b -> ((b -> t) -> e -> s) -> e -> a

The opposite of working over a Setter is working under an isomorphism.

under ≡ over . re

Tag for an iso.