{-# LANGUAGE RankNTypes #-}

-- | Copyright: (c) 2020-2021 berberman
-- SPDX-License-Identifier: MIT
-- Maintainer: berberman <berberman@yandex.com>
-- Stability: experimental
-- Portability: portable
-- Lenses from "Distribution.Compat.Lens"
module Distribution.Uusi.Lens
  ( module Distribution.Compat.Lens,
    lens,
    (<&>),
    mapped,
    HasVersionedPackage (..),
    HasComponentialPackage (..),
  )
where

import Data.Functor ((<&>))
import Data.Functor.Identity
import Distribution.Compat.Lens
import Distribution.Types.Dependency
import Distribution.Types.ExeDependency
import Distribution.Types.LegacyExeDependency
import Distribution.Types.PackageName
import Distribution.Types.UnqualComponentName
import Distribution.Types.VersionRange
import Distribution.Uusi.Types

lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
lens s -> a
sa s -> b -> t
sbt a -> f b
afb s
s = s -> b -> t
sbt s
s (b -> t) -> f b -> f t
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
afb (s -> a
sa s
s)
{-# INLINE lens #-}

mapped :: Functor f => ASetter (f a) (f b) a b
mapped :: ASetter (f a) (f b) a b
mapped a -> Identity b
f = f b -> Identity (f b)
forall a. a -> Identity a
Identity (f b -> Identity (f b)) -> (f a -> f b) -> f a -> Identity (f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Identity b -> b
forall a. Identity a -> a
runIdentity (Identity b -> b) -> (a -> Identity b) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Identity b
f)
{-# INLINE mapped #-}

class HasVersionedPackage a where
  versionedPackage :: Lens' a VersionedPackage
  myPkgName :: Lens' a PackageName
  myVersionRange :: Lens' a VersionRange

  myPkgName = LensLike f a a VersionedPackage VersionedPackage
forall a. HasVersionedPackage a => Lens' a VersionedPackage
versionedPackage LensLike f a a VersionedPackage VersionedPackage
-> ((PackageName -> f PackageName)
    -> VersionedPackage -> f VersionedPackage)
-> LensLike f a a PackageName PackageName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageName -> f PackageName)
-> VersionedPackage -> f VersionedPackage
forall a. HasVersionedPackage a => Lens' a PackageName
myPkgName
  {-# INLINE myPkgName #-}
  myVersionRange = LensLike f a a VersionedPackage VersionedPackage
forall a. HasVersionedPackage a => Lens' a VersionedPackage
versionedPackage LensLike f a a VersionedPackage VersionedPackage
-> ((VersionRange -> f VersionRange)
    -> VersionedPackage -> f VersionedPackage)
-> LensLike f a a VersionRange VersionRange
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VersionRange -> f VersionRange)
-> VersionedPackage -> f VersionedPackage
forall a. HasVersionedPackage a => Lens' a VersionRange
myVersionRange
  {-# INLINE myVersionRange #-}

instance HasVersionedPackage VersionedPackage where
  versionedPackage :: LensLike
  f
  VersionedPackage
  VersionedPackage
  VersionedPackage
  VersionedPackage
versionedPackage = LensLike
  f
  VersionedPackage
  VersionedPackage
  VersionedPackage
  VersionedPackage
forall a. a -> a
id
  myPkgName :: LensLike
  f VersionedPackage VersionedPackage PackageName PackageName
myPkgName = (VersionedPackage -> PackageName)
-> (VersionedPackage -> PackageName -> VersionedPackage)
-> Lens' VersionedPackage PackageName
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens VersionedPackage -> PackageName
_myPkgName (\(VersionedPackage PackageName
_ VersionRange
range) PackageName
name -> PackageName -> VersionRange -> VersionedPackage
VersionedPackage PackageName
name VersionRange
range)
  {-# INLINE myPkgName #-}
  myVersionRange :: LensLike
  f VersionedPackage VersionedPackage VersionRange VersionRange
myVersionRange = (VersionedPackage -> VersionRange)
-> (VersionedPackage -> VersionRange -> VersionedPackage)
-> Lens' VersionedPackage VersionRange
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens VersionedPackage -> VersionRange
_myVersionRange (\(VersionedPackage PackageName
name VersionRange
_) VersionRange
range -> PackageName -> VersionRange -> VersionedPackage
VersionedPackage PackageName
name VersionRange
range)
  {-# INLINE myVersionRange #-}

class HasComponentialPackage a where
  componentialPackage :: Lens' a ComponentialPackage
  myComponentName :: Lens' a UnqualComponentName
  myCorePackage :: Lens' a VersionedPackage
  myComponentName = LensLike f a a ComponentialPackage ComponentialPackage
forall a. HasComponentialPackage a => Lens' a ComponentialPackage
componentialPackage LensLike f a a ComponentialPackage ComponentialPackage
-> ((UnqualComponentName -> f UnqualComponentName)
    -> ComponentialPackage -> f ComponentialPackage)
-> LensLike f a a UnqualComponentName UnqualComponentName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName -> f UnqualComponentName)
-> ComponentialPackage -> f ComponentialPackage
forall a. HasComponentialPackage a => Lens' a UnqualComponentName
myComponentName
  {-# INLINE myComponentName #-}
  myCorePackage = LensLike f a a ComponentialPackage ComponentialPackage
forall a. HasComponentialPackage a => Lens' a ComponentialPackage
componentialPackage LensLike f a a ComponentialPackage ComponentialPackage
-> ((VersionedPackage -> f VersionedPackage)
    -> ComponentialPackage -> f ComponentialPackage)
-> LensLike f a a VersionedPackage VersionedPackage
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VersionedPackage -> f VersionedPackage)
-> ComponentialPackage -> f ComponentialPackage
forall a. HasComponentialPackage a => Lens' a VersionedPackage
myCorePackage
  {-# INLINE myCorePackage #-}

instance HasComponentialPackage ComponentialPackage where
  componentialPackage :: LensLike
  f
  ComponentialPackage
  ComponentialPackage
  ComponentialPackage
  ComponentialPackage
componentialPackage = LensLike
  f
  ComponentialPackage
  ComponentialPackage
  ComponentialPackage
  ComponentialPackage
forall a. a -> a
id
  myComponentName :: LensLike
  f
  ComponentialPackage
  ComponentialPackage
  UnqualComponentName
  UnqualComponentName
myComponentName = (ComponentialPackage -> UnqualComponentName)
-> (ComponentialPackage
    -> UnqualComponentName -> ComponentialPackage)
-> Lens' ComponentialPackage UnqualComponentName
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ComponentialPackage -> UnqualComponentName
_myComponentName (\(ComponentialPackage VersionedPackage
core UnqualComponentName
_) UnqualComponentName
name -> VersionedPackage -> UnqualComponentName -> ComponentialPackage
ComponentialPackage VersionedPackage
core UnqualComponentName
name)
  {-# INLINE myComponentName #-}
  myCorePackage :: LensLike
  f
  ComponentialPackage
  ComponentialPackage
  VersionedPackage
  VersionedPackage
myCorePackage = (ComponentialPackage -> VersionedPackage)
-> (ComponentialPackage -> VersionedPackage -> ComponentialPackage)
-> Lens' ComponentialPackage VersionedPackage
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ComponentialPackage -> VersionedPackage
_myCorePackage (\(ComponentialPackage VersionedPackage
_ UnqualComponentName
name) VersionedPackage
core -> VersionedPackage -> UnqualComponentName -> ComponentialPackage
ComponentialPackage VersionedPackage
core UnqualComponentName
name)
  {-# INLINE myCorePackage #-}

instance HasVersionedPackage Dependency where
  versionedPackage :: LensLike f Dependency Dependency VersionedPackage VersionedPackage
versionedPackage =
    (Dependency -> VersionedPackage)
-> (Dependency -> VersionedPackage -> Dependency)
-> Lens' Dependency VersionedPackage
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
      (\(Dependency PackageName
name VersionRange
range Set LibraryName
_) -> PackageName -> VersionRange -> VersionedPackage
VersionedPackage PackageName
name VersionRange
range)
      (\(Dependency PackageName
_ VersionRange
_ Set LibraryName
lib) (VersionedPackage PackageName
name VersionRange
range) -> PackageName -> VersionRange -> Set LibraryName -> Dependency
Dependency PackageName
name VersionRange
range Set LibraryName
lib)
  {-# INLINE versionedPackage #-}

instance HasVersionedPackage ExeDependency where
  versionedPackage :: LensLike
  f ExeDependency ExeDependency VersionedPackage VersionedPackage
versionedPackage =
    (ExeDependency -> VersionedPackage)
-> (ExeDependency -> VersionedPackage -> ExeDependency)
-> Lens' ExeDependency VersionedPackage
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
      (\(ExeDependency PackageName
name UnqualComponentName
_ VersionRange
range) -> PackageName -> VersionRange -> VersionedPackage
VersionedPackage PackageName
name VersionRange
range)
      (\(ExeDependency PackageName
_ UnqualComponentName
component VersionRange
_) (VersionedPackage PackageName
name VersionRange
range) -> PackageName -> UnqualComponentName -> VersionRange -> ExeDependency
ExeDependency PackageName
name UnqualComponentName
component VersionRange
range)
  {-# INLINE versionedPackage #-}

instance HasComponentialPackage ExeDependency where
  componentialPackage :: LensLike
  f
  ExeDependency
  ExeDependency
  ComponentialPackage
  ComponentialPackage
componentialPackage =
    (ExeDependency -> ComponentialPackage)
-> (ExeDependency -> ComponentialPackage -> ExeDependency)
-> Lens' ExeDependency ComponentialPackage
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
      (\x :: ExeDependency
x@(ExeDependency PackageName
_ UnqualComponentName
component VersionRange
_) -> VersionedPackage -> UnqualComponentName -> ComponentialPackage
ComponentialPackage (ExeDependency
x ExeDependency
-> Getting VersionedPackage ExeDependency VersionedPackage
-> VersionedPackage
forall s a. s -> Getting a s a -> a
^. Getting VersionedPackage ExeDependency VersionedPackage
forall a. HasVersionedPackage a => Lens' a VersionedPackage
versionedPackage) UnqualComponentName
component)
      ( \ExeDependency
x (ComponentialPackage VersionedPackage
core UnqualComponentName
component) ->
          ExeDependency
x ExeDependency -> (ExeDependency -> ExeDependency) -> ExeDependency
forall a b. a -> (a -> b) -> b
& LensLike
  Identity
  ExeDependency
  ExeDependency
  VersionedPackage
  VersionedPackage
forall a. HasComponentialPackage a => Lens' a VersionedPackage
myCorePackage LensLike
  Identity
  ExeDependency
  ExeDependency
  VersionedPackage
  VersionedPackage
-> VersionedPackage -> ExeDependency -> ExeDependency
forall s t a b. ASetter s t a b -> b -> s -> t
.~ VersionedPackage
core
            ExeDependency -> (ExeDependency -> ExeDependency) -> ExeDependency
forall a b. a -> (a -> b) -> b
& LensLike
  Identity
  ExeDependency
  ExeDependency
  UnqualComponentName
  UnqualComponentName
forall a. HasComponentialPackage a => Lens' a UnqualComponentName
myComponentName LensLike
  Identity
  ExeDependency
  ExeDependency
  UnqualComponentName
  UnqualComponentName
-> UnqualComponentName -> ExeDependency -> ExeDependency
forall s t a b. ASetter s t a b -> b -> s -> t
.~ UnqualComponentName
component
      )
  {-# INLINE componentialPackage #-}

instance HasVersionedPackage LegacyExeDependency where
  versionedPackage :: LensLike
  f
  LegacyExeDependency
  LegacyExeDependency
  VersionedPackage
  VersionedPackage
versionedPackage =
    (LegacyExeDependency -> VersionedPackage)
-> (LegacyExeDependency -> VersionedPackage -> LegacyExeDependency)
-> Lens' LegacyExeDependency VersionedPackage
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
      (\(LegacyExeDependency String
name VersionRange
range) -> PackageName -> VersionRange -> VersionedPackage
VersionedPackage (String -> PackageName
mkPackageName String
name) VersionRange
range)
      (\LegacyExeDependency
_ (VersionedPackage PackageName
name VersionRange
range) -> String -> VersionRange -> LegacyExeDependency
LegacyExeDependency (PackageName -> String
unPackageName PackageName
name) VersionRange
range)
  {-# INLINE versionedPackage #-}