{-# LANGUAGE DeriveAnyClass #-}
module Horizon.Spec where

import           Data.Kind  (Type)
import           Data.Map   (Map)
import           Data.Text  (Text)
import           Dhall      (FromDhall, Generic, ToDhall)
import           Path       (Dir, Path, Rel)
import           Path.Dhall ()


type Url :: Type
newtype Url = MkUrl { Url -> Text
fromUrl :: Text }
  deriving stock (Url -> Url -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Url -> Url -> Bool
$c/= :: Url -> Url -> Bool
== :: Url -> Url -> Bool
$c== :: Url -> Url -> Bool
Eq, Int -> Url -> ShowS
[Url] -> ShowS
Url -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Url] -> ShowS
$cshowList :: [Url] -> ShowS
show :: Url -> String
$cshow :: Url -> String
showsPrec :: Int -> Url -> ShowS
$cshowsPrec :: Int -> Url -> ShowS
Show)
  deriving newtype (InputNormalizer -> Decoder Url
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder Url
$cautoWith :: InputNormalizer -> Decoder Url
FromDhall, InputNormalizer -> Encoder Url
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder Url
$cinjectWith :: InputNormalizer -> Encoder Url
ToDhall)

type Repo :: Type
newtype Repo = MkRepo { Repo -> Url
fromRepo :: Url }
  deriving stock (Repo -> Repo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Repo -> Repo -> Bool
$c/= :: Repo -> Repo -> Bool
== :: Repo -> Repo -> Bool
$c== :: Repo -> Repo -> Bool
Eq, Int -> Repo -> ShowS
[Repo] -> ShowS
Repo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Repo] -> ShowS
$cshowList :: [Repo] -> ShowS
show :: Repo -> String
$cshow :: Repo -> String
showsPrec :: Int -> Repo -> ShowS
$cshowsPrec :: Int -> Repo -> ShowS
Show)
  deriving newtype (InputNormalizer -> Decoder Repo
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder Repo
$cautoWith :: InputNormalizer -> Decoder Repo
FromDhall, InputNormalizer -> Encoder Repo
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder Repo
$cinjectWith :: InputNormalizer -> Encoder Repo
ToDhall)

type Subdir :: Type
newtype Subdir = MkSubdir { Subdir -> Path Rel Dir
fromSubdir :: Path Rel Dir }
  deriving stock (Subdir -> Subdir -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Subdir -> Subdir -> Bool
$c/= :: Subdir -> Subdir -> Bool
== :: Subdir -> Subdir -> Bool
$c== :: Subdir -> Subdir -> Bool
Eq, Int -> Subdir -> ShowS
[Subdir] -> ShowS
Subdir -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Subdir] -> ShowS
$cshowList :: [Subdir] -> ShowS
show :: Subdir -> String
$cshow :: Subdir -> String
showsPrec :: Int -> Subdir -> ShowS
$cshowsPrec :: Int -> Subdir -> ShowS
Show)
  deriving newtype (InputNormalizer -> Decoder Subdir
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder Subdir
$cautoWith :: InputNormalizer -> Decoder Subdir
FromDhall, InputNormalizer -> Encoder Subdir
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder Subdir
$cinjectWith :: InputNormalizer -> Encoder Subdir
ToDhall)

type Name :: Type
newtype Name = MkName { Name -> Text
fromName :: Text }
  deriving stock (Name -> Name -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq, Eq Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmax :: Name -> Name -> Name
>= :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c< :: Name -> Name -> Bool
compare :: Name -> Name -> Ordering
$ccompare :: Name -> Name -> Ordering
Ord, Int -> Name -> ShowS
[Name] -> ShowS
Name -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Name] -> ShowS
$cshowList :: [Name] -> ShowS
show :: Name -> String
$cshow :: Name -> String
showsPrec :: Int -> Name -> ShowS
$cshowsPrec :: Int -> Name -> ShowS
Show)
  deriving newtype (InputNormalizer -> Decoder Name
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder Name
$cautoWith :: InputNormalizer -> Decoder Name
FromDhall, InputNormalizer -> Encoder Name
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder Name
$cinjectWith :: InputNormalizer -> Encoder Name
ToDhall)

type Version :: Type
newtype Version = MkVersion { Version -> Text
fromVersion :: Text }
  deriving stock (Version -> Version -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Version -> Version -> Bool
$c/= :: Version -> Version -> Bool
== :: Version -> Version -> Bool
$c== :: Version -> Version -> Bool
Eq, Int -> Version -> ShowS
[Version] -> ShowS
Version -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Version] -> ShowS
$cshowList :: [Version] -> ShowS
show :: Version -> String
$cshow :: Version -> String
showsPrec :: Int -> Version -> ShowS
$cshowsPrec :: Int -> Version -> ShowS
Show)
  deriving newtype (InputNormalizer -> Decoder Version
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder Version
$cautoWith :: InputNormalizer -> Decoder Version
FromDhall, InputNormalizer -> Encoder Version
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder Version
$cinjectWith :: InputNormalizer -> Encoder Version
ToDhall)

type GitSource :: Type
data GitSource where
  MkGitSource :: { GitSource -> Repo
url :: Repo, GitSource -> Revision
revision :: Revision, GitSource -> Maybe Subdir
subdir :: Maybe Subdir } -> GitSource
  deriving stock (GitSource -> GitSource -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitSource -> GitSource -> Bool
$c/= :: GitSource -> GitSource -> Bool
== :: GitSource -> GitSource -> Bool
$c== :: GitSource -> GitSource -> Bool
Eq, Int -> GitSource -> ShowS
[GitSource] -> ShowS
GitSource -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitSource] -> ShowS
$cshowList :: [GitSource] -> ShowS
show :: GitSource -> String
$cshow :: GitSource -> String
showsPrec :: Int -> GitSource -> ShowS
$cshowsPrec :: Int -> GitSource -> ShowS
Show, forall x. Rep GitSource x -> GitSource
forall x. GitSource -> Rep GitSource x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitSource x -> GitSource
$cfrom :: forall x. GitSource -> Rep GitSource x
Generic)
  deriving anyclass (InputNormalizer -> Decoder GitSource
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder GitSource
$cautoWith :: InputNormalizer -> Decoder GitSource
FromDhall, InputNormalizer -> Encoder GitSource
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder GitSource
$cinjectWith :: InputNormalizer -> Encoder GitSource
ToDhall)

type HackageSource :: Type
data HackageSource where
  MkHackageSource :: { HackageSource -> Name
name :: Name, HackageSource -> Version
version :: Version } -> HackageSource
  deriving stock (HackageSource -> HackageSource -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HackageSource -> HackageSource -> Bool
$c/= :: HackageSource -> HackageSource -> Bool
== :: HackageSource -> HackageSource -> Bool
$c== :: HackageSource -> HackageSource -> Bool
Eq, Int -> HackageSource -> ShowS
[HackageSource] -> ShowS
HackageSource -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HackageSource] -> ShowS
$cshowList :: [HackageSource] -> ShowS
show :: HackageSource -> String
$cshow :: HackageSource -> String
showsPrec :: Int -> HackageSource -> ShowS
$cshowsPrec :: Int -> HackageSource -> ShowS
Show, forall x. Rep HackageSource x -> HackageSource
forall x. HackageSource -> Rep HackageSource x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HackageSource x -> HackageSource
$cfrom :: forall x. HackageSource -> Rep HackageSource x
Generic)
  deriving anyclass (InputNormalizer -> Decoder HackageSource
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder HackageSource
$cautoWith :: InputNormalizer -> Decoder HackageSource
FromDhall, InputNormalizer -> Encoder HackageSource
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder HackageSource
$cinjectWith :: InputNormalizer -> Encoder HackageSource
ToDhall)

type HaskellSource :: Type
data HaskellSource where
  FromGit :: GitSource -> HaskellSource
  FromHackage :: HackageSource -> HaskellSource
  deriving stock (Int -> HaskellSource -> ShowS
[HaskellSource] -> ShowS
HaskellSource -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HaskellSource] -> ShowS
$cshowList :: [HaskellSource] -> ShowS
show :: HaskellSource -> String
$cshow :: HaskellSource -> String
showsPrec :: Int -> HaskellSource -> ShowS
$cshowsPrec :: Int -> HaskellSource -> ShowS
Show, HaskellSource -> HaskellSource -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HaskellSource -> HaskellSource -> Bool
$c/= :: HaskellSource -> HaskellSource -> Bool
== :: HaskellSource -> HaskellSource -> Bool
$c== :: HaskellSource -> HaskellSource -> Bool
Eq, forall x. Rep HaskellSource x -> HaskellSource
forall x. HaskellSource -> Rep HaskellSource x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HaskellSource x -> HaskellSource
$cfrom :: forall x. HaskellSource -> Rep HaskellSource x
Generic)
  deriving anyclass (InputNormalizer -> Decoder HaskellSource
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder HaskellSource
$cautoWith :: InputNormalizer -> Decoder HaskellSource
FromDhall, InputNormalizer -> Encoder HaskellSource
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder HaskellSource
$cinjectWith :: InputNormalizer -> Encoder HaskellSource
ToDhall)

type Flag :: Type -> Type
data Flag a where
  Enable :: a -> Flag a
  Disable :: a -> Flag a
  deriving stock (Int -> Flag a -> ShowS
forall a. Show a => Int -> Flag a -> ShowS
forall a. Show a => [Flag a] -> ShowS
forall a. Show a => Flag a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Flag a] -> ShowS
$cshowList :: forall a. Show a => [Flag a] -> ShowS
show :: Flag a -> String
$cshow :: forall a. Show a => Flag a -> String
showsPrec :: Int -> Flag a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Flag a -> ShowS
Show, Flag a -> Flag a -> Bool
forall a. Eq a => Flag a -> Flag a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flag a -> Flag a -> Bool
$c/= :: forall a. Eq a => Flag a -> Flag a -> Bool
== :: Flag a -> Flag a -> Bool
$c== :: forall a. Eq a => Flag a -> Flag a -> Bool
Eq, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Flag a) x -> Flag a
forall a x. Flag a -> Rep (Flag a) x
$cto :: forall a x. Rep (Flag a) x -> Flag a
$cfrom :: forall a x. Flag a -> Rep (Flag a) x
Generic)
  deriving anyclass (forall a. FromDhall a => InputNormalizer -> Decoder (Flag a)
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder (Flag a)
$cautoWith :: forall a. FromDhall a => InputNormalizer -> Decoder (Flag a)
FromDhall, forall a. ToDhall a => InputNormalizer -> Encoder (Flag a)
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder (Flag a)
$cinjectWith :: forall a. ToDhall a => InputNormalizer -> Encoder (Flag a)
ToDhall)

type CabalFlag :: Type
data CabalFlag where
  MkCabalFlag :: Flag Text -> CabalFlag
  deriving stock (Int -> CabalFlag -> ShowS
[CabalFlag] -> ShowS
CabalFlag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CabalFlag] -> ShowS
$cshowList :: [CabalFlag] -> ShowS
show :: CabalFlag -> String
$cshow :: CabalFlag -> String
showsPrec :: Int -> CabalFlag -> ShowS
$cshowsPrec :: Int -> CabalFlag -> ShowS
Show, CabalFlag -> CabalFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CabalFlag -> CabalFlag -> Bool
$c/= :: CabalFlag -> CabalFlag -> Bool
== :: CabalFlag -> CabalFlag -> Bool
$c== :: CabalFlag -> CabalFlag -> Bool
Eq, forall x. Rep CabalFlag x -> CabalFlag
forall x. CabalFlag -> Rep CabalFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CabalFlag x -> CabalFlag
$cfrom :: forall x. CabalFlag -> Rep CabalFlag x
Generic)
  deriving anyclass (InputNormalizer -> Decoder CabalFlag
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder CabalFlag
$cautoWith :: InputNormalizer -> Decoder CabalFlag
FromDhall, InputNormalizer -> Encoder CabalFlag
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder CabalFlag
$cinjectWith :: InputNormalizer -> Encoder CabalFlag
ToDhall)

type Modifiers :: Type
data Modifiers where
  MkModifiers :: { Modifiers -> Bool
doJailbreak :: Bool
                 , Modifiers -> Bool
doCheck :: Bool
                 , Modifiers -> Bool
enableProfiling :: Bool } -> Modifiers
  deriving stock (Int -> Modifiers -> ShowS
[Modifiers] -> ShowS
Modifiers -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Modifiers] -> ShowS
$cshowList :: [Modifiers] -> ShowS
show :: Modifiers -> String
$cshow :: Modifiers -> String
showsPrec :: Int -> Modifiers -> ShowS
$cshowsPrec :: Int -> Modifiers -> ShowS
Show, Modifiers -> Modifiers -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Modifiers -> Modifiers -> Bool
$c/= :: Modifiers -> Modifiers -> Bool
== :: Modifiers -> Modifiers -> Bool
$c== :: Modifiers -> Modifiers -> Bool
Eq, forall x. Rep Modifiers x -> Modifiers
forall x. Modifiers -> Rep Modifiers x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Modifiers x -> Modifiers
$cfrom :: forall x. Modifiers -> Rep Modifiers x
Generic)
  deriving anyclass (InputNormalizer -> Decoder Modifiers
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder Modifiers
$cautoWith :: InputNormalizer -> Decoder Modifiers
FromDhall, InputNormalizer -> Encoder Modifiers
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder Modifiers
$cinjectWith :: InputNormalizer -> Encoder Modifiers
ToDhall)

type HaskellPackage :: Type
data HaskellPackage where
  MkHaskellPackage :: { HaskellPackage -> HaskellSource
source :: HaskellSource
                      , HaskellPackage -> Modifiers
modifiers :: Modifiers
                      , HaskellPackage -> [CabalFlag]
flags :: [CabalFlag] } -> HaskellPackage
  deriving stock (Int -> HaskellPackage -> ShowS
[HaskellPackage] -> ShowS
HaskellPackage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HaskellPackage] -> ShowS
$cshowList :: [HaskellPackage] -> ShowS
show :: HaskellPackage -> String
$cshow :: HaskellPackage -> String
showsPrec :: Int -> HaskellPackage -> ShowS
$cshowsPrec :: Int -> HaskellPackage -> ShowS
Show, HaskellPackage -> HaskellPackage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HaskellPackage -> HaskellPackage -> Bool
$c/= :: HaskellPackage -> HaskellPackage -> Bool
== :: HaskellPackage -> HaskellPackage -> Bool
$c== :: HaskellPackage -> HaskellPackage -> Bool
Eq, forall x. Rep HaskellPackage x -> HaskellPackage
forall x. HaskellPackage -> Rep HaskellPackage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep HaskellPackage x -> HaskellPackage
$cfrom :: forall x. HaskellPackage -> Rep HaskellPackage x
Generic)
  deriving anyclass (InputNormalizer -> Decoder HaskellPackage
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder HaskellPackage
$cautoWith :: InputNormalizer -> Decoder HaskellPackage
FromDhall, InputNormalizer -> Encoder HaskellPackage
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder HaskellPackage
$cinjectWith :: InputNormalizer -> Encoder HaskellPackage
ToDhall)

type Revision :: Type
newtype Revision where
  MkRevision :: { Revision -> Text
fromRevision :: Text } -> Revision
  deriving stock (Int -> Revision -> ShowS
[Revision] -> ShowS
Revision -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Revision] -> ShowS
$cshowList :: [Revision] -> ShowS
show :: Revision -> String
$cshow :: Revision -> String
showsPrec :: Int -> Revision -> ShowS
$cshowsPrec :: Int -> Revision -> ShowS
Show, Revision -> Revision -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Revision -> Revision -> Bool
$c/= :: Revision -> Revision -> Bool
== :: Revision -> Revision -> Bool
$c== :: Revision -> Revision -> Bool
Eq, forall x. Rep Revision x -> Revision
forall x. Revision -> Rep Revision x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Revision x -> Revision
$cfrom :: forall x. Revision -> Rep Revision x
Generic)
  deriving newtype (InputNormalizer -> Decoder Revision
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder Revision
$cautoWith :: InputNormalizer -> Decoder Revision
FromDhall, InputNormalizer -> Encoder Revision
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder Revision
$cinjectWith :: InputNormalizer -> Encoder Revision
ToDhall)

type Compiler :: Type
newtype Compiler where
  MkCompiler :: { Compiler -> Text
fromCompiler :: Text } -> Compiler
  deriving stock (Int -> Compiler -> ShowS
[Compiler] -> ShowS
Compiler -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Compiler] -> ShowS
$cshowList :: [Compiler] -> ShowS
show :: Compiler -> String
$cshow :: Compiler -> String
showsPrec :: Int -> Compiler -> ShowS
$cshowsPrec :: Int -> Compiler -> ShowS
Show, Compiler -> Compiler -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Compiler -> Compiler -> Bool
$c/= :: Compiler -> Compiler -> Bool
== :: Compiler -> Compiler -> Bool
$c== :: Compiler -> Compiler -> Bool
Eq, forall x. Rep Compiler x -> Compiler
forall x. Compiler -> Rep Compiler x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Compiler x -> Compiler
$cfrom :: forall x. Compiler -> Rep Compiler x
Generic)
  deriving newtype (InputNormalizer -> Decoder Compiler
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder Compiler
$cautoWith :: InputNormalizer -> Decoder Compiler
FromDhall, InputNormalizer -> Encoder Compiler
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder Compiler
$cinjectWith :: InputNormalizer -> Encoder Compiler
ToDhall)

type PackageList :: Type
newtype PackageList where
  MkPackageList :: { PackageList -> Map Name HaskellPackage
fromPackageList :: Map Name HaskellPackage } -> PackageList
  deriving stock (Int -> PackageList -> ShowS
[PackageList] -> ShowS
PackageList -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackageList] -> ShowS
$cshowList :: [PackageList] -> ShowS
show :: PackageList -> String
$cshow :: PackageList -> String
showsPrec :: Int -> PackageList -> ShowS
$cshowsPrec :: Int -> PackageList -> ShowS
Show, PackageList -> PackageList -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackageList -> PackageList -> Bool
$c/= :: PackageList -> PackageList -> Bool
== :: PackageList -> PackageList -> Bool
$c== :: PackageList -> PackageList -> Bool
Eq, forall x. Rep PackageList x -> PackageList
forall x. PackageList -> Rep PackageList x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PackageList x -> PackageList
$cfrom :: forall x. PackageList -> Rep PackageList x
Generic)
  deriving newtype (InputNormalizer -> Decoder PackageList
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder PackageList
$cautoWith :: InputNormalizer -> Decoder PackageList
FromDhall, InputNormalizer -> Encoder PackageList
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder PackageList
$cinjectWith :: InputNormalizer -> Encoder PackageList
ToDhall)

type Overlay :: Type
newtype Overlay where
  MkOverlay :: { Overlay -> PackageList
fromOverlay :: PackageList } -> Overlay
  deriving stock (Int -> Overlay -> ShowS
[Overlay] -> ShowS
Overlay -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Overlay] -> ShowS
$cshowList :: [Overlay] -> ShowS
show :: Overlay -> String
$cshow :: Overlay -> String
showsPrec :: Int -> Overlay -> ShowS
$cshowsPrec :: Int -> Overlay -> ShowS
Show, Overlay -> Overlay -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Overlay -> Overlay -> Bool
$c/= :: Overlay -> Overlay -> Bool
== :: Overlay -> Overlay -> Bool
$c== :: Overlay -> Overlay -> Bool
Eq, forall x. Rep Overlay x -> Overlay
forall x. Overlay -> Rep Overlay x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Overlay x -> Overlay
$cfrom :: forall x. Overlay -> Rep Overlay x
Generic)
  deriving newtype (InputNormalizer -> Decoder Overlay
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder Overlay
$cautoWith :: InputNormalizer -> Decoder Overlay
FromDhall, InputNormalizer -> Encoder Overlay
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder Overlay
$cinjectWith :: InputNormalizer -> Encoder Overlay
ToDhall)

type PackageSet :: Type
data PackageSet where
  MkPackageSet :: { PackageSet -> Compiler
compiler :: Compiler
                  , PackageSet -> PackageList
packages :: PackageList } -> PackageSet
  deriving stock (Int -> PackageSet -> ShowS
[PackageSet] -> ShowS
PackageSet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackageSet] -> ShowS
$cshowList :: [PackageSet] -> ShowS
show :: PackageSet -> String
$cshow :: PackageSet -> String
showsPrec :: Int -> PackageSet -> ShowS
$cshowsPrec :: Int -> PackageSet -> ShowS
Show, PackageSet -> PackageSet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackageSet -> PackageSet -> Bool
$c/= :: PackageSet -> PackageSet -> Bool
== :: PackageSet -> PackageSet -> Bool
$c== :: PackageSet -> PackageSet -> Bool
Eq, forall x. Rep PackageSet x -> PackageSet
forall x. PackageSet -> Rep PackageSet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PackageSet x -> PackageSet
$cfrom :: forall x. PackageSet -> Rep PackageSet x
Generic)
  deriving anyclass (InputNormalizer -> Decoder PackageSet
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder PackageSet
$cautoWith :: InputNormalizer -> Decoder PackageSet
FromDhall, InputNormalizer -> Encoder PackageSet
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder PackageSet
$cinjectWith :: InputNormalizer -> Encoder PackageSet
ToDhall)