microlens-pro 0.1.0 → 0.2.0

raw patch · 5 files changed

+26/−39 lines, 5 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

- Lens.Micro.ProCompat: (%=) :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()

- Lens.Micro.ProCompat: (%~) :: ASetter s t a b -> (a -> b) -> s -> t

- Lens.Micro.ProCompat: (&) :: a -> (a -> b) -> b

- Lens.Micro.ProCompat: (&~) :: s -> State s a -> s

- Lens.Micro.ProCompat: (*=) :: (MonadState s m, Num a) => ASetter s s a a -> a -> m ()

- Lens.Micro.ProCompat: (+=) :: (MonadState s m, Num a) => ASetter s s a a -> a -> m ()

- Lens.Micro.ProCompat: (+~) :: Num a => ASetter s t a a -> a -> s -> t

- Lens.Micro.ProCompat: (-=) :: (MonadState s m, Num a) => ASetter s s a a -> a -> m ()

- Lens.Micro.ProCompat: (-~) :: Num a => ASetter s t a a -> a -> s -> t

- Lens.Micro.ProCompat: (.=) :: MonadState s m => ASetter s s a b -> b -> m ()

- Lens.Micro.ProCompat: (.~) :: ASetter s t a b -> b -> s -> t

- Lens.Micro.ProCompat: (//=) :: (MonadState s m, Fractional a) => ASetter s s a a -> a -> m ()

- Lens.Micro.ProCompat: (<%=) :: MonadState s m => LensLike ((,) b) s s a b -> (a -> b) -> m b

- Lens.Micro.ProCompat: (<%~) :: LensLike ((,) b) s t a b -> (a -> b) -> s -> (b, t)

- Lens.Micro.ProCompat: (<&>) :: Functor f => f a -> (a -> b) -> f b

- Lens.Micro.ProCompat: (<.=) :: MonadState s m => LensLike ((,) b) s s a b -> b -> m b

- Lens.Micro.ProCompat: (<<%=) :: MonadState s m => LensLike ((,) a) s s a b -> (a -> b) -> m a

- Lens.Micro.ProCompat: (<<%~) :: LensLike ((,) a) s t a b -> (a -> b) -> s -> (a, t)

- Lens.Micro.ProCompat: (<<.=) :: MonadState s m => LensLike ((,) a) s s a b -> b -> m a

- Lens.Micro.ProCompat: (<<.~) :: LensLike ((,) a) s t a b -> b -> s -> (a, t)

- Lens.Micro.ProCompat: (<>~) :: Monoid a => ASetter s t a a -> a -> s -> t

- Lens.Micro.ProCompat: (<?=) :: MonadState s m => LensLike ((,) b) s s a (Maybe b) -> b -> m b

- Lens.Micro.ProCompat: (<~) :: MonadState s m => ASetter s s a b -> m b -> m ()

- Lens.Micro.ProCompat: (?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m ()

- Lens.Micro.ProCompat: (?~) :: ASetter s t a (Maybe b) -> b -> s -> t

- Lens.Micro.ProCompat: (^.) :: s -> Getting a s a -> a

- Lens.Micro.ProCompat: (^..) :: s -> Getting (Endo [a]) s a -> [a]

- Lens.Micro.ProCompat: (^?!) :: HasCallStack => s -> Getting (Endo a) s a -> a

- Lens.Micro.ProCompat: (^?) :: s -> Getting (First a) s a -> Maybe a

- Lens.Micro.ProCompat: MethodName :: Name -> Name -> DefName

- Lens.Micro.ProCompat: TopName :: Name -> DefName

- Lens.Micro.ProCompat: _1 :: Field1 s t a b => Lens s t a b

- Lens.Micro.ProCompat: _2 :: Field2 s t a b => Lens s t a b

- Lens.Micro.ProCompat: _3 :: Field3 s t a b => Lens s t a b

- Lens.Micro.ProCompat: _4 :: Field4 s t a b => Lens s t a b

- Lens.Micro.ProCompat: _5 :: Field5 s t a b => Lens s t a b

- Lens.Micro.ProCompat: _head :: Cons s s a a => Traversal' s a

- Lens.Micro.ProCompat: _init :: Snoc s s a a => Traversal' s s

- Lens.Micro.ProCompat: _last :: Snoc s s a a => Traversal' s a

- Lens.Micro.ProCompat: _tail :: Cons s s a a => Traversal' s s

- Lens.Micro.ProCompat: abbreviatedFields :: LensRules

- Lens.Micro.ProCompat: assign :: MonadState s m => ASetter s s a b -> b -> m ()

- Lens.Micro.ProCompat: at :: At m => Index m -> Lens' m (Maybe (IxValue m))

- Lens.Micro.ProCompat: both :: forall a b f. Applicative f => (a -> f b) -> (a, a) -> f (b, b)

- Lens.Micro.ProCompat: camelCaseFields :: LensRules

- Lens.Micro.ProCompat: chars :: IsByteString t => Traversal' t Char

- Lens.Micro.ProCompat: classyRules :: LensRules

- Lens.Micro.ProCompat: createClass :: Lens' LensRules Bool

- Lens.Micro.ProCompat: data () => DefName

- Lens.Micro.ProCompat: data () => LensRules

- Lens.Micro.ProCompat: each :: Each s t a b => Traversal s t a b

- Lens.Micro.ProCompat: failing :: Traversal s t a b -> Traversal s t a b -> Traversal s t a b

- Lens.Micro.ProCompat: filtered :: (a -> Bool) -> Traversal' a a

- Lens.Micro.ProCompat: folded :: forall (f :: Type -> Type) a. Foldable f => SimpleFold (f a) a

- Lens.Micro.ProCompat: folding :: Foldable f => (s -> f a) -> SimpleFold s a

- Lens.Micro.ProCompat: forOf :: LensLike f s t a b -> s -> (a -> f b) -> f t

- Lens.Micro.ProCompat: forOf_ :: Functor f => Getting (Traversed r f) s a -> s -> (a -> f r) -> f ()

- Lens.Micro.ProCompat: generateLazyPatterns :: Lens' LensRules Bool

- Lens.Micro.ProCompat: generateSignatures :: Lens' LensRules Bool

- Lens.Micro.ProCompat: generateUpdateableOptics :: Lens' LensRules Bool

- Lens.Micro.ProCompat: has :: Getting Any s a -> s -> Bool

- Lens.Micro.ProCompat: infix 4 <?=

- Lens.Micro.ProCompat: infixl 1 &~

- Lens.Micro.ProCompat: infixl 5 `failing`

- Lens.Micro.ProCompat: infixl 8 ^?!

- Lens.Micro.ProCompat: infixr 2 <~

- Lens.Micro.ProCompat: infixr 4 <<.~

- Lens.Micro.ProCompat: ix :: Ixed m => Index m -> Traversal' m (IxValue m)

- Lens.Micro.ProCompat: lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b

- Lens.Micro.ProCompat: lensClass :: Lens' LensRules (Name -> Maybe (Name, Name))

- Lens.Micro.ProCompat: lensField :: Lens' LensRules (Name -> [Name] -> Name -> [DefName])

- Lens.Micro.ProCompat: lensRules :: LensRules

- Lens.Micro.ProCompat: lensRulesFor :: [(String, String)] -> LensRules

- Lens.Micro.ProCompat: lined :: Traversal' String String

- Lens.Micro.ProCompat: magnify :: Magnify m n b a => LensLike' (Magnified m c) a b -> m c -> n c

- Lens.Micro.ProCompat: makeClassy :: Name -> DecsQ

- Lens.Micro.ProCompat: makeFields :: Name -> DecsQ

- Lens.Micro.ProCompat: makeLenses :: Name -> DecsQ

- Lens.Micro.ProCompat: makeLensesFor :: [(String, String)] -> Name -> DecsQ

- Lens.Micro.ProCompat: makeLensesWith :: LensRules -> Name -> DecsQ

- Lens.Micro.ProCompat: mapAccumLOf :: LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

- Lens.Micro.ProCompat: mapped :: Functor f => ASetter (f a) (f b) a b

- Lens.Micro.ProCompat: modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()

- Lens.Micro.ProCompat: over :: ASetter s t a b -> (a -> b) -> s -> t

- Lens.Micro.ProCompat: packedBytes :: IsByteString t => Lens' [Word8] t

- Lens.Micro.ProCompat: packedChars :: IsByteString t => Lens' String t

- Lens.Micro.ProCompat: preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a)

- Lens.Micro.ProCompat: preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)

- Lens.Micro.ProCompat: rewriteOf :: ASetter a b a b -> (b -> Maybe a) -> a -> b

- Lens.Micro.ProCompat: set :: ASetter s t a b -> b -> s -> t

- Lens.Micro.ProCompat: sets :: ((a -> b) -> s -> t) -> ASetter s t a b

- Lens.Micro.ProCompat: simpleLenses :: Lens' LensRules Bool

- Lens.Micro.ProCompat: singular :: HasCallStack => Traversal s t a a -> Lens s t a a

- Lens.Micro.ProCompat: to :: (s -> a) -> SimpleGetter s a

- Lens.Micro.ProCompat: toListOf :: Getting (Endo [a]) s a -> s -> [a]

- Lens.Micro.ProCompat: transformOf :: ASetter a b a b -> (b -> b) -> a -> b

- Lens.Micro.ProCompat: traverseOf :: LensLike f s t a b -> (a -> f b) -> s -> f t

- Lens.Micro.ProCompat: traverseOf_ :: Functor f => Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()

- Lens.Micro.ProCompat: traversed :: forall (f :: Type -> Type) a b. Traversable f => Traversal (f a) (f b) a b

- Lens.Micro.ProCompat: type ASetter s t a b = a -> Identity b -> s -> Identity t

- Lens.Micro.ProCompat: type ASetter' s a = ASetter s s a a

- Lens.Micro.ProCompat: type SimpleGetter s a = forall r. () => Getting r s a

- Lens.Micro.ProCompat: type Lens' s a = Lens s s a a

- Lens.Micro.ProCompat: type LensLike (f :: Type -> Type) s t a b = a -> f b -> s -> f t

- Lens.Micro.ProCompat: type LensLike' (f :: Type -> Type) s a = LensLike f s s a a

- Lens.Micro.ProCompat: type Traversal' s a = Traversal s s a a

- Lens.Micro.ProCompat: type Lens s t a b = forall (f :: Type -> Type). Functor f => a -> f b -> s -> f t

- Lens.Micro.ProCompat: unpackedBytes :: IsByteString t => Lens' t [Word8]

- Lens.Micro.ProCompat: unpackedChars :: IsByteString t => Lens' t String

- Lens.Micro.ProCompat: use :: MonadState s m => Getting a s a -> m a

- Lens.Micro.ProCompat: view :: MonadReader s m => Getting a s a -> m a

- Lens.Micro.ProCompat: worded :: Traversal' String String

- Lens.Micro.ProCompat: zoom :: Zoom m n s t => LensLike' (Zoomed m c) t s -> m c -> n c

+ Lens.Micro.Pro: (%=) :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()

+ Lens.Micro.Pro: (%~) :: ASetter s t a b -> (a -> b) -> s -> t

+ Lens.Micro.Pro: (&) :: a -> (a -> b) -> b

+ Lens.Micro.Pro: (&~) :: s -> State s a -> s

+ Lens.Micro.Pro: (*=) :: (MonadState s m, Num a) => ASetter s s a a -> a -> m ()

+ Lens.Micro.Pro: (+=) :: (MonadState s m, Num a) => ASetter s s a a -> a -> m ()

+ Lens.Micro.Pro: (+~) :: Num a => ASetter s t a a -> a -> s -> t

+ Lens.Micro.Pro: (-=) :: (MonadState s m, Num a) => ASetter s s a a -> a -> m ()

+ Lens.Micro.Pro: (-~) :: Num a => ASetter s t a a -> a -> s -> t

+ Lens.Micro.Pro: (.=) :: MonadState s m => ASetter s s a b -> b -> m ()

+ Lens.Micro.Pro: (.~) :: ASetter s t a b -> b -> s -> t

+ Lens.Micro.Pro: (//=) :: (MonadState s m, Fractional a) => ASetter s s a a -> a -> m ()

+ Lens.Micro.Pro: (<%=) :: MonadState s m => LensLike ((,) b) s s a b -> (a -> b) -> m b

+ Lens.Micro.Pro: (<%~) :: LensLike ((,) b) s t a b -> (a -> b) -> s -> (b, t)

+ Lens.Micro.Pro: (<&>) :: Functor f => f a -> (a -> b) -> f b

+ Lens.Micro.Pro: (<.=) :: MonadState s m => LensLike ((,) b) s s a b -> b -> m b

+ Lens.Micro.Pro: (<<%=) :: MonadState s m => LensLike ((,) a) s s a b -> (a -> b) -> m a

+ Lens.Micro.Pro: (<<%~) :: LensLike ((,) a) s t a b -> (a -> b) -> s -> (a, t)

+ Lens.Micro.Pro: (<<.=) :: MonadState s m => LensLike ((,) a) s s a b -> b -> m a

+ Lens.Micro.Pro: (<<.~) :: LensLike ((,) a) s t a b -> b -> s -> (a, t)

+ Lens.Micro.Pro: (<>~) :: Monoid a => ASetter s t a a -> a -> s -> t

+ Lens.Micro.Pro: (<?=) :: MonadState s m => LensLike ((,) b) s s a (Maybe b) -> b -> m b

+ Lens.Micro.Pro: (<~) :: MonadState s m => ASetter s s a b -> m b -> m ()

+ Lens.Micro.Pro: (?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m ()

+ Lens.Micro.Pro: (?~) :: ASetter s t a (Maybe b) -> b -> s -> t

+ Lens.Micro.Pro: (^.) :: s -> Getting a s a -> a

+ Lens.Micro.Pro: (^..) :: s -> Getting (Endo [a]) s a -> [a]

+ Lens.Micro.Pro: (^?!) :: HasCallStack => s -> Getting (Endo a) s a -> a

+ Lens.Micro.Pro: (^?) :: s -> Getting (First a) s a -> Maybe a

+ Lens.Micro.Pro: MethodName :: Name -> Name -> DefName

+ Lens.Micro.Pro: TopName :: Name -> DefName

+ Lens.Micro.Pro: _1 :: Field1 s t a b => Lens s t a b

+ Lens.Micro.Pro: _2 :: Field2 s t a b => Lens s t a b

+ Lens.Micro.Pro: _3 :: Field3 s t a b => Lens s t a b

+ Lens.Micro.Pro: _4 :: Field4 s t a b => Lens s t a b

+ Lens.Micro.Pro: _5 :: Field5 s t a b => Lens s t a b

+ Lens.Micro.Pro: _head :: Cons s s a a => Traversal' s a

+ Lens.Micro.Pro: _init :: Snoc s s a a => Traversal' s s

+ Lens.Micro.Pro: _last :: Snoc s s a a => Traversal' s a

+ Lens.Micro.Pro: _tail :: Cons s s a a => Traversal' s s

+ Lens.Micro.Pro: abbreviatedFields :: LensRules

+ Lens.Micro.Pro: assign :: MonadState s m => ASetter s s a b -> b -> m ()

+ Lens.Micro.Pro: at :: At m => Index m -> Lens' m (Maybe (IxValue m))

+ Lens.Micro.Pro: both :: forall a b f. Applicative f => (a -> f b) -> (a, a) -> f (b, b)

+ Lens.Micro.Pro: camelCaseFields :: LensRules

+ Lens.Micro.Pro: chars :: IsByteString t => Traversal' t Char

+ Lens.Micro.Pro: classyRules :: LensRules

+ Lens.Micro.Pro: createClass :: Lens' LensRules Bool

+ Lens.Micro.Pro: data () => DefName

+ Lens.Micro.Pro: data () => LensRules

+ Lens.Micro.Pro: each :: Each s t a b => Traversal s t a b

+ Lens.Micro.Pro: failing :: Traversal s t a b -> Traversal s t a b -> Traversal s t a b

+ Lens.Micro.Pro: filtered :: (a -> Bool) -> Traversal' a a

+ Lens.Micro.Pro: folded :: forall (f :: Type -> Type) a. Foldable f => SimpleFold (f a) a

+ Lens.Micro.Pro: folding :: Foldable f => (s -> f a) -> SimpleFold s a

+ Lens.Micro.Pro: forOf :: LensLike f s t a b -> s -> (a -> f b) -> f t

+ Lens.Micro.Pro: forOf_ :: Functor f => Getting (Traversed r f) s a -> s -> (a -> f r) -> f ()

+ Lens.Micro.Pro: generateLazyPatterns :: Lens' LensRules Bool

+ Lens.Micro.Pro: generateSignatures :: Lens' LensRules Bool

+ Lens.Micro.Pro: generateUpdateableOptics :: Lens' LensRules Bool

+ Lens.Micro.Pro: has :: Getting Any s a -> s -> Bool

+ Lens.Micro.Pro: infix 4 <?=

+ Lens.Micro.Pro: infixl 1 &~

+ Lens.Micro.Pro: infixl 5 `failing`

+ Lens.Micro.Pro: infixl 8 ^?!

+ Lens.Micro.Pro: infixr 2 <~

+ Lens.Micro.Pro: infixr 4 <<.~

+ Lens.Micro.Pro: ix :: Ixed m => Index m -> Traversal' m (IxValue m)

+ Lens.Micro.Pro: lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b

+ Lens.Micro.Pro: lensClass :: Lens' LensRules (Name -> Maybe (Name, Name))

+ Lens.Micro.Pro: lensField :: Lens' LensRules (Name -> [Name] -> Name -> [DefName])

+ Lens.Micro.Pro: lensRules :: LensRules

+ Lens.Micro.Pro: lensRulesFor :: [(String, String)] -> LensRules

+ Lens.Micro.Pro: lined :: Traversal' String String

+ Lens.Micro.Pro: magnify :: Magnify m n b a => LensLike' (Magnified m c) a b -> m c -> n c

+ Lens.Micro.Pro: makeClassy :: Name -> DecsQ

+ Lens.Micro.Pro: makeFields :: Name -> DecsQ

+ Lens.Micro.Pro: makeLenses :: Name -> DecsQ

+ Lens.Micro.Pro: makeLensesFor :: [(String, String)] -> Name -> DecsQ

+ Lens.Micro.Pro: makeLensesWith :: LensRules -> Name -> DecsQ

+ Lens.Micro.Pro: mapAccumLOf :: LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

+ Lens.Micro.Pro: mapped :: Functor f => ASetter (f a) (f b) a b

+ Lens.Micro.Pro: modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()

+ Lens.Micro.Pro: over :: ASetter s t a b -> (a -> b) -> s -> t

+ Lens.Micro.Pro: packedBytes :: IsByteString t => Lens' [Word8] t

+ Lens.Micro.Pro: packedChars :: IsByteString t => Lens' String t

+ Lens.Micro.Pro: preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a)

+ Lens.Micro.Pro: preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)

+ Lens.Micro.Pro: rewriteOf :: ASetter a b a b -> (b -> Maybe a) -> a -> b

+ Lens.Micro.Pro: set :: ASetter s t a b -> b -> s -> t

+ Lens.Micro.Pro: sets :: ((a -> b) -> s -> t) -> ASetter s t a b

+ Lens.Micro.Pro: simpleLenses :: Lens' LensRules Bool

+ Lens.Micro.Pro: singular :: HasCallStack => Traversal s t a a -> Lens s t a a

+ Lens.Micro.Pro: to :: (s -> a) -> SimpleGetter s a

+ Lens.Micro.Pro: toListOf :: Getting (Endo [a]) s a -> s -> [a]

+ Lens.Micro.Pro: transformOf :: ASetter a b a b -> (b -> b) -> a -> b

+ Lens.Micro.Pro: traverseOf :: LensLike f s t a b -> (a -> f b) -> s -> f t

+ Lens.Micro.Pro: traverseOf_ :: Functor f => Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()

+ Lens.Micro.Pro: traversed :: forall (f :: Type -> Type) a b. Traversable f => Traversal (f a) (f b) a b

+ Lens.Micro.Pro: type ASetter s t a b = a -> Identity b -> s -> Identity t

+ Lens.Micro.Pro: type ASetter' s a = ASetter s s a a

+ Lens.Micro.Pro: type SimpleGetter s a = forall r. () => Getting r s a

+ Lens.Micro.Pro: type Lens' s a = Lens s s a a

+ Lens.Micro.Pro: type LensLike (f :: Type -> Type) s t a b = a -> f b -> s -> f t

+ Lens.Micro.Pro: type LensLike' (f :: Type -> Type) s a = LensLike f s s a a

+ Lens.Micro.Pro: type Traversal' s a = Traversal s s a a

+ Lens.Micro.Pro: type Lens s t a b = forall (f :: Type -> Type). Functor f => a -> f b -> s -> f t

+ Lens.Micro.Pro: unpackedBytes :: IsByteString t => Lens' t [Word8]

+ Lens.Micro.Pro: unpackedChars :: IsByteString t => Lens' t String

+ Lens.Micro.Pro: use :: MonadState s m => Getting a s a -> m a

+ Lens.Micro.Pro: view :: MonadReader s m => Getting a s a -> m a

+ Lens.Micro.Pro: worded :: Traversal' String String

+ Lens.Micro.Pro: zoom :: Zoom m n s t => LensLike' (Zoomed m c) t s -> m c -> n c

Files

CHANGELOG.md +7/−2
microlens-pro.cabal +1/−2
src/Lens/Micro/Pro.hs +18/−10
src/Lens/Micro/Pro/TH.hs +0/−2
src/Lens/Micro/ProCompat.hs +0/−23

CHANGELOG.md view

@@ -1,3 +1,8 @@-# 0.1.0.0+# 0.2.0 -[#105](https://github.com/stevenfontanella/microlens/issues/105) microlens-pro initial release, with `Prism`s and `Iso`s.+* New major release.+* [#177](https://github.com/stevenfontanella/microlens/issues/177) Moves `Lens.Micro.ProCompat` into `Lens.Micro.Pro`.++# 0.1.0++* [#105](https://github.com/stevenfontanella/microlens/issues/105) microlens-pro initial release, with `Prism`s and `Iso`s.

microlens-pro.cabal view

@@ -1,5 +1,5 @@ name:                   microlens-pro-version:                0.1.0+version:                0.2.0 synopsis:               Prisms and isomorphisms for microlens description:   This package provides lens-compatible 'Prism' and 'Iso'. Consequently, it@@ -47,7 +47,6 @@  library   exposed-modules:      Lens.Micro.Pro-                        Lens.Micro.ProCompat                         Lens.Micro.Pro.TH                         Lens.Micro.Pro.Internal                         Lens.Micro.Pro.Type

src/Lens/Micro/Pro.hs view

@@ -7,9 +7,9 @@ [profunctors](https://hackage.haskell.org/package/profunctors), most notably 'Iso' and 'Prism'. Depending on 'profunctors' is quite the to bear — one that includes all dependencies of @microlens-platform@. For this reason,-@microlens-pro@ ships with a compatiblity module "Lens.Micro.ProCompat" which-re-exports the entirety of "Lens.Micro.Platform", but with the profunctor-less-definitions hidden and overridden with profunctor'd definitions from this module.+@microlens-pro@ re-exports the entirety of "Lens.Micro.Platform", but+with the profunctor-less definitions hidden and overridden with profunctor'd+definitions from this module. -}  {-# LANGUAGE DefaultSignatures #-}@@ -66,10 +66,11 @@     , review     , (#)     , unto++    , module Lens.Micro.Platform     )     where ---------------------------------------------------------------------------------import Lens.Micro                   (has) import Lens.Micro.Contra import Lens.Micro.Pro.Type import Lens.Micro.Pro.Internal@@ -89,6 +90,12 @@ import GHC.Exts                     (TYPE) #endif +-- For re-export hiding conflicting names+import Lens.Micro.Platform hiding+    ( _Left, _Right, _Just, _Nothing, _Show+    , strict, lazy, packed, unpacked, non+    )+ -- implement instances import qualified Data.Text                as Text import qualified Data.Text.Lazy           as Text.Lazy@@ -154,8 +161,8 @@ [Lens.Micro](https://hackage.haskell.org/package/microlens-0.4.13.1/docs/Lens-Micro.html#g:5) and [Lens.Micro.Platform](https://hackage.haskell.org/package/microlens-platform-0.4.3.4/docs/Lens-Micro-Platform.html).-For convenience, we provide a module "Lens.Micro.ProCompat" which emulates-Lens.Micro.Platform, but uses the lens-compatible isos.+For convenience, we re-export Lens.Micro.Platform, but with non-lens-compatible+isos hidden and replaced with lens-compatbile ones.  -} @@ -664,7 +671,7 @@ -}  re :: AReview t b -> Getter b t-re p = to (runIdentity #. unTagged #. p .# Tagged .# Identity)+re p = toInternal (runIdentity #. unTagged #. p .# Tagged .# Identity)  {-# INLINE re #-} @@ -675,16 +682,17 @@ infixr 8 # {-# INLINE (#) #-} +-- Not exported -- TODO: `to` is temporarily defined here. This should be in microlens-contra, -- or better yet, microlens as Contravariant has been in base since at least ghc -- 8.6.5. This definition isn't perfect either -- the version from lens is: -- -- to :: (Profunctor p, Contravariant f) => (s -> a) -> Optic' p f s a -to :: (s -> a) -> Getter s a-to k = dimap k (contramap k)+toInternal :: (s -> a) -> Getter s a+toInternal k = dimap k (contramap k) -{-# INLINE to #-}+{-# INLINE toInternal #-}  {- | Construct a 'Review' out of a constructor. Consider this more pleasant type

src/Lens/Micro/Pro/TH.hs view

@@ -25,8 +25,6 @@ ) where -import Lens.Micro-import Lens.Micro.Extras import Lens.Micro.Pro import Lens.Micro.TH.Internal   (HasTypeVars(..), typeVars, substTypeVars, newNames, conAppsT, inlinePragma)

− src/Lens/Micro/ProCompat.hs

@@ -1,23 +0,0 @@-{- |-Module      : Lens.Micro.ProCompat-Copyright   : (C) 2013-2016 Edward Kmett, 2018 Monadfix-License     : BSD-style (see the file LICENSE)--This module re-exports "Lens.Micro.Platform", overriding definitions where-necesarry.--}-module Lens.Micro.ProCompat-    ( module Lens.Micro.Platform-    , module Lens.Micro.Pro-    )-    where------------------------------------------------------------------------------------- everything hidden here is redefined in 'Lens.Micro.Pro'-import Lens.Micro.Platform hiding-    ( _Left, _Right, _Just, _Nothing, _Show-    , strict, lazy, packed, unpacked-    , non-    )-import Lens.Micro.Pro-