{-# LANGUAGE DeriveAnyClass        #-}
{-# LANGUAGE DuplicateRecordFields #-}
module Horizon.Spec
  ( CabalFlag(MkCabalFlag)
  , Compiler(MkCompiler, fromCompiler)
  , Flag(Enable, Disable)
  , GitSource(MkGitSource, url, revision, subdir)
  , HackageSource(MkHackageSource, name, version)
  , HaskellPackage(MkHaskellPackage, source, modifiers, flags)
  , HaskellSource(FromGit, FromHackage, FromTarball, FromLocal)
  , HorizonExport(MakePackageSet, MakeOverlay)
  , LocalSource(MkLocalSource, fromLocalSource)
  , Modifiers(doJailbreak, doBenchmark, doCheck, enableProfiling, includeBenchmarks, includeExecutables, includeTests)
  , Name(MkName, fromName)
  , OverlayExportSettings(MkOverlayExportSettings, packagesDir, overlayFile, overlay)
  , OverlayFile(MkOverlayFile, fromOverlayFile)
  , Overlay(MkOverlay, fromOverlay)
  , PackageList(MkPackageList, fromPackageList)
  , PackageSetExportSettings(MkPackageSetExportSettings, packagesDir, packageSetFile, packageSet)
  , PackageSetFile(MkPackageSetFile, fromPackageSetFile)
  , PackageSet(MkPackageSet, compiler, packages)
  , PackagesDir(MkPackagesDir, fromPackagesDir)
  , Repo(MkRepo, fromRepo)
  , Revision(MkRevision, fromRevision)
  , Subdir(MkSubdir, fromSubdir)
  , TarballSource(MkTarballSource, fromTarballSource)
  , Url(MkUrl, fromUrl)
  , Version (MkVersion, fromVersion)
  )
  where

import           Data.Kind  (Type)
import           Data.Map   (Map)
import           Data.Text  (Text)
import           Dhall      (FromDhall, Generic, ToDhall)
import           Path       (Dir, File, 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 LocalSource :: Type
newtype LocalSource where
  MkLocalSource :: { LocalSource -> Subdir
fromLocalSource :: Subdir } -> LocalSource
  deriving stock (LocalSource -> LocalSource -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LocalSource -> LocalSource -> Bool
$c/= :: LocalSource -> LocalSource -> Bool
== :: LocalSource -> LocalSource -> Bool
$c== :: LocalSource -> LocalSource -> Bool
Eq, Int -> LocalSource -> ShowS
[LocalSource] -> ShowS
LocalSource -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LocalSource] -> ShowS
$cshowList :: [LocalSource] -> ShowS
show :: LocalSource -> String
$cshow :: LocalSource -> String
showsPrec :: Int -> LocalSource -> ShowS
$cshowsPrec :: Int -> LocalSource -> ShowS
Show, forall x. Rep LocalSource x -> LocalSource
forall x. LocalSource -> Rep LocalSource x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LocalSource x -> LocalSource
$cfrom :: forall x. LocalSource -> Rep LocalSource x
Generic)
  deriving newtype (InputNormalizer -> Decoder LocalSource
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder LocalSource
$cautoWith :: InputNormalizer -> Decoder LocalSource
FromDhall, InputNormalizer -> Encoder LocalSource
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder LocalSource
$cinjectWith :: InputNormalizer -> Encoder LocalSource
ToDhall)

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

type HaskellSource :: Type
data HaskellSource where
  FromGit :: GitSource -> HaskellSource
  FromHackage :: HackageSource -> HaskellSource
  FromLocal :: LocalSource -> HaskellSource
  FromTarball :: TarballSource -> 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
doBenchmark :: Bool
                 , Modifiers -> Bool
doCheck :: Bool
                 , Modifiers -> Bool
doJailbreak :: Bool
                 , Modifiers -> Bool
enableProfiling :: Bool
                 , Modifiers -> Bool
includeBenchmarks :: Bool
                 , Modifiers -> Bool
includeExecutables :: Bool
                 , Modifiers -> Bool
includeTests :: 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 -> PackageSet
fromOverlay :: PackageSet } -> 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)

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

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

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

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

type OverlayExportSettings :: Type
data OverlayExportSettings where
  MkOverlayExportSettings :: { OverlayExportSettings -> PackagesDir
packagesDir :: PackagesDir
                             , OverlayExportSettings -> OverlayFile
overlayFile :: OverlayFile
                             , OverlayExportSettings -> Overlay
overlay :: Overlay } -> OverlayExportSettings
  deriving stock (Int -> OverlayExportSettings -> ShowS
[OverlayExportSettings] -> ShowS
OverlayExportSettings -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OverlayExportSettings] -> ShowS
$cshowList :: [OverlayExportSettings] -> ShowS
show :: OverlayExportSettings -> String
$cshow :: OverlayExportSettings -> String
showsPrec :: Int -> OverlayExportSettings -> ShowS
$cshowsPrec :: Int -> OverlayExportSettings -> ShowS
Show, OverlayExportSettings -> OverlayExportSettings -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OverlayExportSettings -> OverlayExportSettings -> Bool
$c/= :: OverlayExportSettings -> OverlayExportSettings -> Bool
== :: OverlayExportSettings -> OverlayExportSettings -> Bool
$c== :: OverlayExportSettings -> OverlayExportSettings -> Bool
Eq, forall x. Rep OverlayExportSettings x -> OverlayExportSettings
forall x. OverlayExportSettings -> Rep OverlayExportSettings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OverlayExportSettings x -> OverlayExportSettings
$cfrom :: forall x. OverlayExportSettings -> Rep OverlayExportSettings x
Generic)
  deriving anyclass (InputNormalizer -> Decoder OverlayExportSettings
forall a. (InputNormalizer -> Decoder a) -> FromDhall a
autoWith :: InputNormalizer -> Decoder OverlayExportSettings
$cautoWith :: InputNormalizer -> Decoder OverlayExportSettings
FromDhall, InputNormalizer -> Encoder OverlayExportSettings
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
injectWith :: InputNormalizer -> Encoder OverlayExportSettings
$cinjectWith :: InputNormalizer -> Encoder OverlayExportSettings
ToDhall)

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