module Hix.Prelude where

import Data.Generics.Labels ()
import Data.List.Extra (firstJust)
import qualified Distribution.ModuleName as ModuleName
import Distribution.ModuleName (ModuleName)
import Distribution.PackageDescription (ModuleRenaming (..), unPackageName)
import Distribution.Types.IncludeRenaming (IncludeRenaming (..))
import Distribution.Types.Mixin (Mixin (..))
import qualified Exon

data Prelude =
  Prelude {
    Prelude -> String
preludePackage :: String,
    Prelude -> String
preludeModule :: String
  }
  deriving stock (Prelude -> Prelude -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Prelude -> Prelude -> Bool
$c/= :: Prelude -> Prelude -> Bool
== :: Prelude -> Prelude -> Bool
$c== :: Prelude -> Prelude -> Bool
Eq, Int -> Prelude -> ShowS
[Prelude] -> ShowS
Prelude -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Prelude] -> ShowS
$cshowList :: [Prelude] -> ShowS
show :: Prelude -> String
$cshow :: Prelude -> String
showsPrec :: Int -> Prelude -> ShowS
$cshowsPrec :: Int -> Prelude -> ShowS
Show)

preludeRenaming :: [(b, ModuleName)] -> Maybe b
preludeRenaming :: forall b. [(b, ModuleName)] -> Maybe b
preludeRenaming =
  forall a b. (a -> Maybe b) -> [a] -> Maybe b
firstJust \case
    (b
real, ModuleName
"Prelude") -> forall a. a -> Maybe a
Just b
real
    (b, ModuleName)
_ -> forall a. Maybe a
Nothing

pattern PreludeRenaming :: ModuleName -> ModuleRenaming
pattern $mPreludeRenaming :: forall {r}.
ModuleRenaming -> (ModuleName -> r) -> ((# #) -> r) -> r
PreludeRenaming p <- ModuleRenaming (preludeRenaming -> Just p)

pattern PreludeInclude :: ModuleName -> IncludeRenaming
pattern $mPreludeInclude :: forall {r}.
IncludeRenaming -> (ModuleName -> r) -> ((# #) -> r) -> r
PreludeInclude p <- IncludeRenaming {includeProvidesRn = PreludeRenaming p}

findPrelude :: [Mixin] -> Maybe Prelude
findPrelude :: [Mixin] -> Maybe Prelude
findPrelude =
  forall a b. (a -> Maybe b) -> [a] -> Maybe b
firstJust \case
    Mixin {mixinIncludeRenaming :: Mixin -> IncludeRenaming
mixinIncludeRenaming = PreludeInclude ModuleName
real, LibraryName
PackageName
mixinLibraryName :: Mixin -> LibraryName
mixinPackageName :: Mixin -> PackageName
mixinLibraryName :: LibraryName
mixinPackageName :: PackageName
..} ->
      let
        preludePackage :: String
preludePackage = PackageName -> String
unPackageName PackageName
mixinPackageName
        preludeModule :: String
preludeModule = forall a (t :: * -> *). (Monoid a, Foldable t) => a -> t a -> a
Exon.intercalate String
"." (ModuleName -> [String]
ModuleName.components ModuleName
real)
      in forall a. a -> Maybe a
Just Prelude {String
preludeModule :: String
preludePackage :: String
$sel:preludeModule:Prelude :: String
$sel:preludePackage:Prelude :: String
..}
    Mixin
_ -> forall a. Maybe a
Nothing