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, Prelude -> Bool local :: Bool } deriving stock (Prelude -> Prelude -> Bool (Prelude -> Prelude -> Bool) -> (Prelude -> Prelude -> Bool) -> Eq Prelude forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a $c== :: Prelude -> Prelude -> Bool == :: Prelude -> Prelude -> Bool $c/= :: Prelude -> Prelude -> Bool /= :: Prelude -> Prelude -> Bool Eq, Int -> Prelude -> ShowS [Prelude] -> ShowS Prelude -> String (Int -> Prelude -> ShowS) -> (Prelude -> String) -> ([Prelude] -> ShowS) -> Show Prelude forall a. (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a $cshowsPrec :: Int -> Prelude -> ShowS showsPrec :: Int -> Prelude -> ShowS $cshow :: Prelude -> String show :: Prelude -> String $cshowList :: [Prelude] -> ShowS showList :: [Prelude] -> ShowS Show) preludeRenaming :: [(b, ModuleName)] -> Maybe b preludeRenaming :: forall b. [(b, ModuleName)] -> Maybe b preludeRenaming = ((b, ModuleName) -> Maybe b) -> [(b, ModuleName)] -> Maybe b forall a b. (a -> Maybe b) -> [a] -> Maybe b firstJust \case (b real, ModuleName "Prelude") -> b -> Maybe b forall a. a -> Maybe a Just b real (b, ModuleName) _ -> Maybe b 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 = (Mixin -> Maybe Prelude) -> [Mixin] -> Maybe Prelude forall a b. (a -> Maybe b) -> [a] -> Maybe b firstJust \case Mixin {mixinIncludeRenaming :: Mixin -> IncludeRenaming mixinIncludeRenaming = PreludeInclude ModuleName real, LibraryName PackageName mixinPackageName :: PackageName mixinLibraryName :: LibraryName mixinPackageName :: Mixin -> PackageName mixinLibraryName :: Mixin -> LibraryName ..} -> let preludePackage :: String preludePackage = PackageName -> String unPackageName PackageName mixinPackageName preludeModule :: String preludeModule = String -> [String] -> String forall a (t :: * -> *). (Exon a, Monoid a, Foldable t) => a -> t a -> a Exon.intercalate String "." (ModuleName -> [String] ModuleName.components ModuleName real) in Prelude -> Maybe Prelude forall a. a -> Maybe a Just Prelude {$sel:local:Prelude :: Bool local = Bool False, String $sel:preludePackage:Prelude :: String $sel:preludeModule:Prelude :: String preludePackage :: String preludeModule :: String ..} Mixin _ -> Maybe Prelude forall a. Maybe a Nothing