    {-| This module contains some useful utilities copy-and-pasted from the @lens@
        library to avoid a dependency which are used internally and also re-exported
        for convenience
    -}

    {-# LANGUAGE RankNTypes #-}

    module Dhall.Optics {-# DEPRECATED "Use the definitions from Lens.Micro of the microlens package directly." #-}
        ( Optic
        , Optic'
           -- * Utilities
        , anyOf
        , rewriteOf
        , transformOf
        , rewriteMOf
        , transformMOf
        , mapMOf
        , cosmosOf
        , to
        , foldOf
        ) where

    import Control.Applicative        (Const (..), WrappedMonad (..))
    import Data.Monoid                (Any (..))
    import Lens.Micro                 (ASetter, LensLike, Traversal, SimpleGetter)
    import Lens.Micro.Internal        ((#.))

    import qualified Lens.Micro

    -- | Identical to @"Control.Lens.Getter".`Control.Lens.Getter.Getting`@
    type Getting r s a = (a -> Const r a) -> s -> Const r s

    -- | Identical to @"Control.Lens.Type".`Control.Lens.Type.Optic`@
    type Optic p f s t a b = p a (f b) -> p s (f t)

    -- | Identical to @"Control.Lens.Type".`Control.Lens.Type.Optic'`@
    type Optic' p f s a = Optic p f s s a a

    -- | Identical to @"Control.Lens".`Control.Lens.anyOf`@
    anyOf :: Getting Any s a -> (a -> Bool) -> s -> Bool
    anyOf :: forall s a. Getting Any s a -> (a -> Bool) -> s -> Bool
    anyOf = Getting Any s a -> (a -> Bool) -> s -> Bool
    forall s a. Getting Any s a -> (a -> Bool) -> s -> Bool
    Lens.Micro.anyOf
    {-# INLINE anyOf #-}

    -- | Identical to @"Control.Lens".`Control.Lens.rewriteOf`@
    rewriteOf :: ASetter a b a b -> (b -> Maybe a) -> a -> b
    rewriteOf :: forall a b. ASetter a b a b -> (b -> Maybe a) -> a -> b
    rewriteOf = ASetter a b a b -> (b -> Maybe a) -> a -> b
    forall a b. ASetter a b a b -> (b -> Maybe a) -> a -> b
    Lens.Micro.rewriteOf
    {-# INLINE rewriteOf #-}

    -- | Identical to @"Control.Lens".`Control.Lens.transformOf`@
    transformOf :: ASetter a b a b -> (b -> b) -> a -> b
    transformOf :: forall a b. ASetter a b a b -> (b -> b) -> a -> b
    transformOf = ASetter a b a b -> (b -> b) -> a -> b
    forall a b. ASetter a b a b -> (b -> b) -> a -> b
    Lens.Micro.transformOf
    {-# INLINE transformOf #-}

    -- | Identical to @"Control.Lens".`Control.Lens.rewriteMOf`@
    rewriteMOf
        :: Monad m
        => LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> a -> m b
    rewriteMOf :: forall (m :: * -> *) a b.
    Monad m =>
    LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> a -> m b
    rewriteMOf = LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> a -> m b
    forall (m :: * -> *) a b.
    Monad m =>
    LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> a -> m b
    Lens.Micro.rewriteMOf
    {-# INLINE rewriteMOf #-}

    -- | Identical to @"Control.Lens".`Control.Lens.transformMOf`@
    transformMOf
        :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m b) -> a -> m b
    transformMOf :: forall (m :: * -> *) a b.
    Monad m =>
    LensLike (WrappedMonad m) a b a b -> (b -> m b) -> a -> m b
    transformMOf = LensLike (WrappedMonad m) a b a b -> (b -> m b) -> a -> m b
    forall (m :: * -> *) a b.
    Monad m =>
    LensLike (WrappedMonad m) a b a b -> (b -> m b) -> a -> m b
    Lens.Micro.transformMOf
    {-# INLINE transformMOf #-}

    -- | Identical to @"Control.Lens".`Control.Lens.mapMOf`@
    mapMOf :: LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
    mapMOf :: forall (m :: * -> *) s t a b.
    LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
    mapMOf = LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
    forall (m :: * -> *) s t a b.
    LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
    Lens.Micro.mapMOf
    {-# INLINE mapMOf #-}

    -- | Identical to @"Control.Lens.Plated".`Control.Lens.Plated.cosmosOf`@
    cosmosOf :: Traversal s t s t -> Traversal s t s b
    cosmosOf :: forall s t b. Traversal s t s t -> Traversal s t s b
    cosmosOf = Traversal s t s t -> (s -> f b) -> s -> f t
    Traversal s t s t -> Traversal s t s b
    forall s t b. Traversal s t s t -> Traversal s t s b
    Lens.Micro.cosmosOf
    {-# INLINE cosmosOf #-}

    -- | Identical to @"Control.Lens.Getter".`Control.Lens.Getter.to`@
    to :: (s -> a) -> SimpleGetter s a
    to :: forall s a. (s -> a) -> SimpleGetter s a
    to = (s -> a) -> Getting r s a
    (s -> a) -> SimpleGetter s a
    forall s a. (s -> a) -> SimpleGetter s a
    Lens.Micro.to
    {-# INLINE to #-}

    -- | Identical to @"Control.Lens.Fold".`Control.Lens.Fold.foldOf`@
    foldOf :: Getting a s a -> s -> a
    foldOf :: forall a s. Getting a s a -> s -> a
    foldOf Getting a s a
    l = Const a s -> a
    forall {k} a (b :: k). Const a b -> a
    getConst (Const a s -> a) -> (s -> Const a s) -> s -> a
    forall c b a. Coercible c b => (b -> c) -> (a -> b) -> a -> c
    #. Getting a s a
    l a -> Const a a
    forall {k} a (b :: k). a -> Const a b
    Const
    {-# INLINE foldOf #-}