module Ribosome.App.Data where

import Path (Abs, Dir, Path, Rel)

newtype ProjectName =
  ProjectName { ProjectName -> Text
unProjectName :: Text }
  deriving stock (ProjectName -> ProjectName -> Bool
(ProjectName -> ProjectName -> Bool)
-> (ProjectName -> ProjectName -> Bool) -> Eq ProjectName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectName -> ProjectName -> Bool
$c/= :: ProjectName -> ProjectName -> Bool
== :: ProjectName -> ProjectName -> Bool
$c== :: ProjectName -> ProjectName -> Bool
Eq, Int -> ProjectName -> ShowS
[ProjectName] -> ShowS
ProjectName -> String
(Int -> ProjectName -> ShowS)
-> (ProjectName -> String)
-> ([ProjectName] -> ShowS)
-> Show ProjectName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectName] -> ShowS
$cshowList :: [ProjectName] -> ShowS
show :: ProjectName -> String
$cshow :: ProjectName -> String
showsPrec :: Int -> ProjectName -> ShowS
$cshowsPrec :: Int -> ProjectName -> ShowS
Show)
  deriving newtype (String -> ProjectName
(String -> ProjectName) -> IsString ProjectName
forall a. (String -> a) -> IsString a
fromString :: String -> ProjectName
$cfromString :: String -> ProjectName
IsString, Eq ProjectName
Eq ProjectName
-> (ProjectName -> ProjectName -> Ordering)
-> (ProjectName -> ProjectName -> Bool)
-> (ProjectName -> ProjectName -> Bool)
-> (ProjectName -> ProjectName -> Bool)
-> (ProjectName -> ProjectName -> Bool)
-> (ProjectName -> ProjectName -> ProjectName)
-> (ProjectName -> ProjectName -> ProjectName)
-> Ord ProjectName
ProjectName -> ProjectName -> Bool
ProjectName -> ProjectName -> Ordering
ProjectName -> ProjectName -> ProjectName
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 :: ProjectName -> ProjectName -> ProjectName
$cmin :: ProjectName -> ProjectName -> ProjectName
max :: ProjectName -> ProjectName -> ProjectName
$cmax :: ProjectName -> ProjectName -> ProjectName
>= :: ProjectName -> ProjectName -> Bool
$c>= :: ProjectName -> ProjectName -> Bool
> :: ProjectName -> ProjectName -> Bool
$c> :: ProjectName -> ProjectName -> Bool
<= :: ProjectName -> ProjectName -> Bool
$c<= :: ProjectName -> ProjectName -> Bool
< :: ProjectName -> ProjectName -> Bool
$c< :: ProjectName -> ProjectName -> Bool
compare :: ProjectName -> ProjectName -> Ordering
$ccompare :: ProjectName -> ProjectName -> Ordering
Ord)

newtype ModuleName =
  ModuleName { ModuleName -> Text
unModuleName :: Text }
  deriving stock (ModuleName -> ModuleName -> Bool
(ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool) -> Eq ModuleName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModuleName -> ModuleName -> Bool
$c/= :: ModuleName -> ModuleName -> Bool
== :: ModuleName -> ModuleName -> Bool
$c== :: ModuleName -> ModuleName -> Bool
Eq, Int -> ModuleName -> ShowS
[ModuleName] -> ShowS
ModuleName -> String
(Int -> ModuleName -> ShowS)
-> (ModuleName -> String)
-> ([ModuleName] -> ShowS)
-> Show ModuleName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModuleName] -> ShowS
$cshowList :: [ModuleName] -> ShowS
show :: ModuleName -> String
$cshow :: ModuleName -> String
showsPrec :: Int -> ModuleName -> ShowS
$cshowsPrec :: Int -> ModuleName -> ShowS
Show)
  deriving newtype (String -> ModuleName
(String -> ModuleName) -> IsString ModuleName
forall a. (String -> a) -> IsString a
fromString :: String -> ModuleName
$cfromString :: String -> ModuleName
IsString, Eq ModuleName
Eq ModuleName
-> (ModuleName -> ModuleName -> Ordering)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> ModuleName)
-> (ModuleName -> ModuleName -> ModuleName)
-> Ord ModuleName
ModuleName -> ModuleName -> Bool
ModuleName -> ModuleName -> Ordering
ModuleName -> ModuleName -> ModuleName
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 :: ModuleName -> ModuleName -> ModuleName
$cmin :: ModuleName -> ModuleName -> ModuleName
max :: ModuleName -> ModuleName -> ModuleName
$cmax :: ModuleName -> ModuleName -> ModuleName
>= :: ModuleName -> ModuleName -> Bool
$c>= :: ModuleName -> ModuleName -> Bool
> :: ModuleName -> ModuleName -> Bool
$c> :: ModuleName -> ModuleName -> Bool
<= :: ModuleName -> ModuleName -> Bool
$c<= :: ModuleName -> ModuleName -> Bool
< :: ModuleName -> ModuleName -> Bool
$c< :: ModuleName -> ModuleName -> Bool
compare :: ModuleName -> ModuleName -> Ordering
$ccompare :: ModuleName -> ModuleName -> Ordering
Ord)

data ProjectNames =
  ProjectNames {
    ProjectNames -> ProjectName
name :: ProjectName,
    ProjectNames -> Path Rel Dir
nameDir :: Path Rel Dir,
    ProjectNames -> ModuleName
moduleName :: ModuleName,
    ProjectNames -> Path Rel Dir
moduleNameDir :: Path Rel Dir
  }
  deriving stock (ProjectNames -> ProjectNames -> Bool
(ProjectNames -> ProjectNames -> Bool)
-> (ProjectNames -> ProjectNames -> Bool) -> Eq ProjectNames
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectNames -> ProjectNames -> Bool
$c/= :: ProjectNames -> ProjectNames -> Bool
== :: ProjectNames -> ProjectNames -> Bool
$c== :: ProjectNames -> ProjectNames -> Bool
Eq, Int -> ProjectNames -> ShowS
[ProjectNames] -> ShowS
ProjectNames -> String
(Int -> ProjectNames -> ShowS)
-> (ProjectNames -> String)
-> ([ProjectNames] -> ShowS)
-> Show ProjectNames
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProjectNames] -> ShowS
$cshowList :: [ProjectNames] -> ShowS
show :: ProjectNames -> String
$cshow :: ProjectNames -> String
showsPrec :: Int -> ProjectNames -> ShowS
$cshowsPrec :: Int -> ProjectNames -> ShowS
Show, (forall x. ProjectNames -> Rep ProjectNames x)
-> (forall x. Rep ProjectNames x -> ProjectNames)
-> Generic ProjectNames
forall x. Rep ProjectNames x -> ProjectNames
forall x. ProjectNames -> Rep ProjectNames x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProjectNames x -> ProjectNames
$cfrom :: forall x. ProjectNames -> Rep ProjectNames x
Generic)

newtype GithubOrg =
  GithubOrg { GithubOrg -> Text
unGithubOrg :: Text }
  deriving stock (GithubOrg -> GithubOrg -> Bool
(GithubOrg -> GithubOrg -> Bool)
-> (GithubOrg -> GithubOrg -> Bool) -> Eq GithubOrg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GithubOrg -> GithubOrg -> Bool
$c/= :: GithubOrg -> GithubOrg -> Bool
== :: GithubOrg -> GithubOrg -> Bool
$c== :: GithubOrg -> GithubOrg -> Bool
Eq, Int -> GithubOrg -> ShowS
[GithubOrg] -> ShowS
GithubOrg -> String
(Int -> GithubOrg -> ShowS)
-> (GithubOrg -> String)
-> ([GithubOrg] -> ShowS)
-> Show GithubOrg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GithubOrg] -> ShowS
$cshowList :: [GithubOrg] -> ShowS
show :: GithubOrg -> String
$cshow :: GithubOrg -> String
showsPrec :: Int -> GithubOrg -> ShowS
$cshowsPrec :: Int -> GithubOrg -> ShowS
Show)
  deriving newtype (String -> GithubOrg
(String -> GithubOrg) -> IsString GithubOrg
forall a. (String -> a) -> IsString a
fromString :: String -> GithubOrg
$cfromString :: String -> GithubOrg
IsString, Eq GithubOrg
Eq GithubOrg
-> (GithubOrg -> GithubOrg -> Ordering)
-> (GithubOrg -> GithubOrg -> Bool)
-> (GithubOrg -> GithubOrg -> Bool)
-> (GithubOrg -> GithubOrg -> Bool)
-> (GithubOrg -> GithubOrg -> Bool)
-> (GithubOrg -> GithubOrg -> GithubOrg)
-> (GithubOrg -> GithubOrg -> GithubOrg)
-> Ord GithubOrg
GithubOrg -> GithubOrg -> Bool
GithubOrg -> GithubOrg -> Ordering
GithubOrg -> GithubOrg -> GithubOrg
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 :: GithubOrg -> GithubOrg -> GithubOrg
$cmin :: GithubOrg -> GithubOrg -> GithubOrg
max :: GithubOrg -> GithubOrg -> GithubOrg
$cmax :: GithubOrg -> GithubOrg -> GithubOrg
>= :: GithubOrg -> GithubOrg -> Bool
$c>= :: GithubOrg -> GithubOrg -> Bool
> :: GithubOrg -> GithubOrg -> Bool
$c> :: GithubOrg -> GithubOrg -> Bool
<= :: GithubOrg -> GithubOrg -> Bool
$c<= :: GithubOrg -> GithubOrg -> Bool
< :: GithubOrg -> GithubOrg -> Bool
$c< :: GithubOrg -> GithubOrg -> Bool
compare :: GithubOrg -> GithubOrg -> Ordering
$ccompare :: GithubOrg -> GithubOrg -> Ordering
Ord)

newtype GithubRepo =
  GithubRepo { GithubRepo -> Text
unGithubRepo :: Text }
  deriving stock (GithubRepo -> GithubRepo -> Bool
(GithubRepo -> GithubRepo -> Bool)
-> (GithubRepo -> GithubRepo -> Bool) -> Eq GithubRepo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GithubRepo -> GithubRepo -> Bool
$c/= :: GithubRepo -> GithubRepo -> Bool
== :: GithubRepo -> GithubRepo -> Bool
$c== :: GithubRepo -> GithubRepo -> Bool
Eq, Int -> GithubRepo -> ShowS
[GithubRepo] -> ShowS
GithubRepo -> String
(Int -> GithubRepo -> ShowS)
-> (GithubRepo -> String)
-> ([GithubRepo] -> ShowS)
-> Show GithubRepo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GithubRepo] -> ShowS
$cshowList :: [GithubRepo] -> ShowS
show :: GithubRepo -> String
$cshow :: GithubRepo -> String
showsPrec :: Int -> GithubRepo -> ShowS
$cshowsPrec :: Int -> GithubRepo -> ShowS
Show)
  deriving newtype (String -> GithubRepo
(String -> GithubRepo) -> IsString GithubRepo
forall a. (String -> a) -> IsString a
fromString :: String -> GithubRepo
$cfromString :: String -> GithubRepo
IsString, Eq GithubRepo
Eq GithubRepo
-> (GithubRepo -> GithubRepo -> Ordering)
-> (GithubRepo -> GithubRepo -> Bool)
-> (GithubRepo -> GithubRepo -> Bool)
-> (GithubRepo -> GithubRepo -> Bool)
-> (GithubRepo -> GithubRepo -> Bool)
-> (GithubRepo -> GithubRepo -> GithubRepo)
-> (GithubRepo -> GithubRepo -> GithubRepo)
-> Ord GithubRepo
GithubRepo -> GithubRepo -> Bool
GithubRepo -> GithubRepo -> Ordering
GithubRepo -> GithubRepo -> GithubRepo
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 :: GithubRepo -> GithubRepo -> GithubRepo
$cmin :: GithubRepo -> GithubRepo -> GithubRepo
max :: GithubRepo -> GithubRepo -> GithubRepo
$cmax :: GithubRepo -> GithubRepo -> GithubRepo
>= :: GithubRepo -> GithubRepo -> Bool
$c>= :: GithubRepo -> GithubRepo -> Bool
> :: GithubRepo -> GithubRepo -> Bool
$c> :: GithubRepo -> GithubRepo -> Bool
<= :: GithubRepo -> GithubRepo -> Bool
$c<= :: GithubRepo -> GithubRepo -> Bool
< :: GithubRepo -> GithubRepo -> Bool
$c< :: GithubRepo -> GithubRepo -> Bool
compare :: GithubRepo -> GithubRepo -> Ordering
$ccompare :: GithubRepo -> GithubRepo -> Ordering
Ord)

newtype CachixName =
  CachixName { CachixName -> Text
unCachixName :: Text }
  deriving stock (CachixName -> CachixName -> Bool
(CachixName -> CachixName -> Bool)
-> (CachixName -> CachixName -> Bool) -> Eq CachixName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CachixName -> CachixName -> Bool
$c/= :: CachixName -> CachixName -> Bool
== :: CachixName -> CachixName -> Bool
$c== :: CachixName -> CachixName -> Bool
Eq, Int -> CachixName -> ShowS
[CachixName] -> ShowS
CachixName -> String
(Int -> CachixName -> ShowS)
-> (CachixName -> String)
-> ([CachixName] -> ShowS)
-> Show CachixName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CachixName] -> ShowS
$cshowList :: [CachixName] -> ShowS
show :: CachixName -> String
$cshow :: CachixName -> String
showsPrec :: Int -> CachixName -> ShowS
$cshowsPrec :: Int -> CachixName -> ShowS
Show)
  deriving newtype (String -> CachixName
(String -> CachixName) -> IsString CachixName
forall a. (String -> a) -> IsString a
fromString :: String -> CachixName
$cfromString :: String -> CachixName
IsString, Eq CachixName
Eq CachixName
-> (CachixName -> CachixName -> Ordering)
-> (CachixName -> CachixName -> Bool)
-> (CachixName -> CachixName -> Bool)
-> (CachixName -> CachixName -> Bool)
-> (CachixName -> CachixName -> Bool)
-> (CachixName -> CachixName -> CachixName)
-> (CachixName -> CachixName -> CachixName)
-> Ord CachixName
CachixName -> CachixName -> Bool
CachixName -> CachixName -> Ordering
CachixName -> CachixName -> CachixName
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 :: CachixName -> CachixName -> CachixName
$cmin :: CachixName -> CachixName -> CachixName
max :: CachixName -> CachixName -> CachixName
$cmax :: CachixName -> CachixName -> CachixName
>= :: CachixName -> CachixName -> Bool
$c>= :: CachixName -> CachixName -> Bool
> :: CachixName -> CachixName -> Bool
$c> :: CachixName -> CachixName -> Bool
<= :: CachixName -> CachixName -> Bool
$c<= :: CachixName -> CachixName -> Bool
< :: CachixName -> CachixName -> Bool
$c< :: CachixName -> CachixName -> Bool
compare :: CachixName -> CachixName -> Ordering
$ccompare :: CachixName -> CachixName -> Ordering
Ord)

newtype CachixKey =
  CachixKey { CachixKey -> Text
unCachixKey :: Text }
  deriving stock (CachixKey -> CachixKey -> Bool
(CachixKey -> CachixKey -> Bool)
-> (CachixKey -> CachixKey -> Bool) -> Eq CachixKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CachixKey -> CachixKey -> Bool
$c/= :: CachixKey -> CachixKey -> Bool
== :: CachixKey -> CachixKey -> Bool
$c== :: CachixKey -> CachixKey -> Bool
Eq, Int -> CachixKey -> ShowS
[CachixKey] -> ShowS
CachixKey -> String
(Int -> CachixKey -> ShowS)
-> (CachixKey -> String)
-> ([CachixKey] -> ShowS)
-> Show CachixKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CachixKey] -> ShowS
$cshowList :: [CachixKey] -> ShowS
show :: CachixKey -> String
$cshow :: CachixKey -> String
showsPrec :: Int -> CachixKey -> ShowS
$cshowsPrec :: Int -> CachixKey -> ShowS
Show)
  deriving newtype (String -> CachixKey
(String -> CachixKey) -> IsString CachixKey
forall a. (String -> a) -> IsString a
fromString :: String -> CachixKey
$cfromString :: String -> CachixKey
IsString, Eq CachixKey
Eq CachixKey
-> (CachixKey -> CachixKey -> Ordering)
-> (CachixKey -> CachixKey -> Bool)
-> (CachixKey -> CachixKey -> Bool)
-> (CachixKey -> CachixKey -> Bool)
-> (CachixKey -> CachixKey -> Bool)
-> (CachixKey -> CachixKey -> CachixKey)
-> (CachixKey -> CachixKey -> CachixKey)
-> Ord CachixKey
CachixKey -> CachixKey -> Bool
CachixKey -> CachixKey -> Ordering
CachixKey -> CachixKey -> CachixKey
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 :: CachixKey -> CachixKey -> CachixKey
$cmin :: CachixKey -> CachixKey -> CachixKey
max :: CachixKey -> CachixKey -> CachixKey
$cmax :: CachixKey -> CachixKey -> CachixKey
>= :: CachixKey -> CachixKey -> Bool
$c>= :: CachixKey -> CachixKey -> Bool
> :: CachixKey -> CachixKey -> Bool
$c> :: CachixKey -> CachixKey -> Bool
<= :: CachixKey -> CachixKey -> Bool
$c<= :: CachixKey -> CachixKey -> Bool
< :: CachixKey -> CachixKey -> Bool
$c< :: CachixKey -> CachixKey -> Bool
compare :: CachixKey -> CachixKey -> Ordering
$ccompare :: CachixKey -> CachixKey -> Ordering
Ord)

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

instance Default SkipCachix where
  def :: SkipCachix
def =
    Bool -> SkipCachix
SkipCachix Bool
False

newtype FlakeUrl =
  FlakeUrl { FlakeUrl -> Text
unFlakeUrl :: Text }
  deriving stock (FlakeUrl -> FlakeUrl -> Bool
(FlakeUrl -> FlakeUrl -> Bool)
-> (FlakeUrl -> FlakeUrl -> Bool) -> Eq FlakeUrl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FlakeUrl -> FlakeUrl -> Bool
$c/= :: FlakeUrl -> FlakeUrl -> Bool
== :: FlakeUrl -> FlakeUrl -> Bool
$c== :: FlakeUrl -> FlakeUrl -> Bool
Eq, Int -> FlakeUrl -> ShowS
[FlakeUrl] -> ShowS
FlakeUrl -> String
(Int -> FlakeUrl -> ShowS)
-> (FlakeUrl -> String) -> ([FlakeUrl] -> ShowS) -> Show FlakeUrl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FlakeUrl] -> ShowS
$cshowList :: [FlakeUrl] -> ShowS
show :: FlakeUrl -> String
$cshow :: FlakeUrl -> String
showsPrec :: Int -> FlakeUrl -> ShowS
$cshowsPrec :: Int -> FlakeUrl -> ShowS
Show)
  deriving newtype (String -> FlakeUrl
(String -> FlakeUrl) -> IsString FlakeUrl
forall a. (String -> a) -> IsString a
fromString :: String -> FlakeUrl
$cfromString :: String -> FlakeUrl
IsString, Eq FlakeUrl
Eq FlakeUrl
-> (FlakeUrl -> FlakeUrl -> Ordering)
-> (FlakeUrl -> FlakeUrl -> Bool)
-> (FlakeUrl -> FlakeUrl -> Bool)
-> (FlakeUrl -> FlakeUrl -> Bool)
-> (FlakeUrl -> FlakeUrl -> Bool)
-> (FlakeUrl -> FlakeUrl -> FlakeUrl)
-> (FlakeUrl -> FlakeUrl -> FlakeUrl)
-> Ord FlakeUrl
FlakeUrl -> FlakeUrl -> Bool
FlakeUrl -> FlakeUrl -> Ordering
FlakeUrl -> FlakeUrl -> FlakeUrl
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 :: FlakeUrl -> FlakeUrl -> FlakeUrl
$cmin :: FlakeUrl -> FlakeUrl -> FlakeUrl
max :: FlakeUrl -> FlakeUrl -> FlakeUrl
$cmax :: FlakeUrl -> FlakeUrl -> FlakeUrl
>= :: FlakeUrl -> FlakeUrl -> Bool
$c>= :: FlakeUrl -> FlakeUrl -> Bool
> :: FlakeUrl -> FlakeUrl -> Bool
$c> :: FlakeUrl -> FlakeUrl -> Bool
<= :: FlakeUrl -> FlakeUrl -> Bool
$c<= :: FlakeUrl -> FlakeUrl -> Bool
< :: FlakeUrl -> FlakeUrl -> Bool
$c< :: FlakeUrl -> FlakeUrl -> Bool
compare :: FlakeUrl -> FlakeUrl -> Ordering
$ccompare :: FlakeUrl -> FlakeUrl -> Ordering
Ord)

newtype Branch =
  Branch { Branch -> Text
unBranch :: Text }
  deriving stock (Branch -> Branch -> Bool
(Branch -> Branch -> Bool)
-> (Branch -> Branch -> Bool) -> Eq Branch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Branch -> Branch -> Bool
$c/= :: Branch -> Branch -> Bool
== :: Branch -> Branch -> Bool
$c== :: Branch -> Branch -> Bool
Eq, Int -> Branch -> ShowS
[Branch] -> ShowS
Branch -> String
(Int -> Branch -> ShowS)
-> (Branch -> String) -> ([Branch] -> ShowS) -> Show Branch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Branch] -> ShowS
$cshowList :: [Branch] -> ShowS
show :: Branch -> String
$cshow :: Branch -> String
showsPrec :: Int -> Branch -> ShowS
$cshowsPrec :: Int -> Branch -> ShowS
Show)
  deriving newtype (String -> Branch
(String -> Branch) -> IsString Branch
forall a. (String -> a) -> IsString a
fromString :: String -> Branch
$cfromString :: String -> Branch
IsString, Eq Branch
Eq Branch
-> (Branch -> Branch -> Ordering)
-> (Branch -> Branch -> Bool)
-> (Branch -> Branch -> Bool)
-> (Branch -> Branch -> Bool)
-> (Branch -> Branch -> Bool)
-> (Branch -> Branch -> Branch)
-> (Branch -> Branch -> Branch)
-> Ord Branch
Branch -> Branch -> Bool
Branch -> Branch -> Ordering
Branch -> Branch -> Branch
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 :: Branch -> Branch -> Branch
$cmin :: Branch -> Branch -> Branch
max :: Branch -> Branch -> Branch
$cmax :: Branch -> Branch -> Branch
>= :: Branch -> Branch -> Bool
$c>= :: Branch -> Branch -> Bool
> :: Branch -> Branch -> Bool
$c> :: Branch -> Branch -> Bool
<= :: Branch -> Branch -> Bool
$c<= :: Branch -> Branch -> Bool
< :: Branch -> Branch -> Bool
$c< :: Branch -> Branch -> Bool
compare :: Branch -> Branch -> Ordering
$ccompare :: Branch -> Branch -> Ordering
Ord)

newtype Author =
  Author { Author -> Text
unAuthor :: Text }
  deriving stock (Author -> Author -> Bool
(Author -> Author -> Bool)
-> (Author -> Author -> Bool) -> Eq Author
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Author -> Author -> Bool
$c/= :: Author -> Author -> Bool
== :: Author -> Author -> Bool
$c== :: Author -> Author -> Bool
Eq, Int -> Author -> ShowS
[Author] -> ShowS
Author -> String
(Int -> Author -> ShowS)
-> (Author -> String) -> ([Author] -> ShowS) -> Show Author
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Author] -> ShowS
$cshowList :: [Author] -> ShowS
show :: Author -> String
$cshow :: Author -> String
showsPrec :: Int -> Author -> ShowS
$cshowsPrec :: Int -> Author -> ShowS
Show)
  deriving newtype (String -> Author
(String -> Author) -> IsString Author
forall a. (String -> a) -> IsString a
fromString :: String -> Author
$cfromString :: String -> Author
IsString, Eq Author
Eq Author
-> (Author -> Author -> Ordering)
-> (Author -> Author -> Bool)
-> (Author -> Author -> Bool)
-> (Author -> Author -> Bool)
-> (Author -> Author -> Bool)
-> (Author -> Author -> Author)
-> (Author -> Author -> Author)
-> Ord Author
Author -> Author -> Bool
Author -> Author -> Ordering
Author -> Author -> Author
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 :: Author -> Author -> Author
$cmin :: Author -> Author -> Author
max :: Author -> Author -> Author
$cmax :: Author -> Author -> Author
>= :: Author -> Author -> Bool
$c>= :: Author -> Author -> Bool
> :: Author -> Author -> Bool
$c> :: Author -> Author -> Bool
<= :: Author -> Author -> Bool
$c<= :: Author -> Author -> Bool
< :: Author -> Author -> Bool
$c< :: Author -> Author -> Bool
compare :: Author -> Author -> Ordering
$ccompare :: Author -> Author -> Ordering
Ord)

newtype Maintainer =
  Maintainer { Maintainer -> Text
unMaintainer :: Text }
  deriving stock (Maintainer -> Maintainer -> Bool
(Maintainer -> Maintainer -> Bool)
-> (Maintainer -> Maintainer -> Bool) -> Eq Maintainer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Maintainer -> Maintainer -> Bool
$c/= :: Maintainer -> Maintainer -> Bool
== :: Maintainer -> Maintainer -> Bool
$c== :: Maintainer -> Maintainer -> Bool
Eq, Int -> Maintainer -> ShowS
[Maintainer] -> ShowS
Maintainer -> String
(Int -> Maintainer -> ShowS)
-> (Maintainer -> String)
-> ([Maintainer] -> ShowS)
-> Show Maintainer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Maintainer] -> ShowS
$cshowList :: [Maintainer] -> ShowS
show :: Maintainer -> String
$cshow :: Maintainer -> String
showsPrec :: Int -> Maintainer -> ShowS
$cshowsPrec :: Int -> Maintainer -> ShowS
Show)
  deriving newtype (String -> Maintainer
(String -> Maintainer) -> IsString Maintainer
forall a. (String -> a) -> IsString a
fromString :: String -> Maintainer
$cfromString :: String -> Maintainer
IsString, Eq Maintainer
Eq Maintainer
-> (Maintainer -> Maintainer -> Ordering)
-> (Maintainer -> Maintainer -> Bool)
-> (Maintainer -> Maintainer -> Bool)
-> (Maintainer -> Maintainer -> Bool)
-> (Maintainer -> Maintainer -> Bool)
-> (Maintainer -> Maintainer -> Maintainer)
-> (Maintainer -> Maintainer -> Maintainer)
-> Ord Maintainer
Maintainer -> Maintainer -> Bool
Maintainer -> Maintainer -> Ordering
Maintainer -> Maintainer -> Maintainer
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 :: Maintainer -> Maintainer -> Maintainer
$cmin :: Maintainer -> Maintainer -> Maintainer
max :: Maintainer -> Maintainer -> Maintainer
$cmax :: Maintainer -> Maintainer -> Maintainer
>= :: Maintainer -> Maintainer -> Bool
$c>= :: Maintainer -> Maintainer -> Bool
> :: Maintainer -> Maintainer -> Bool
$c> :: Maintainer -> Maintainer -> Bool
<= :: Maintainer -> Maintainer -> Bool
$c<= :: Maintainer -> Maintainer -> Bool
< :: Maintainer -> Maintainer -> Bool
$c< :: Maintainer -> Maintainer -> Bool
compare :: Maintainer -> Maintainer -> Ordering
$ccompare :: Maintainer -> Maintainer -> Ordering
Ord)

newtype Year =
  Year { Year -> Int
unYear :: Int }
  deriving stock (Year -> Year -> Bool
(Year -> Year -> Bool) -> (Year -> Year -> Bool) -> Eq Year
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Year -> Year -> Bool
$c/= :: Year -> Year -> Bool
== :: Year -> Year -> Bool
$c== :: Year -> Year -> Bool
Eq, Int -> Year -> ShowS
[Year] -> ShowS
Year -> String
(Int -> Year -> ShowS)
-> (Year -> String) -> ([Year] -> ShowS) -> Show Year
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Year] -> ShowS
$cshowList :: [Year] -> ShowS
show :: Year -> String
$cshow :: Year -> String
showsPrec :: Int -> Year -> ShowS
$cshowsPrec :: Int -> Year -> ShowS
Show)
  deriving newtype (Integer -> Year
Year -> Year
Year -> Year -> Year
(Year -> Year -> Year)
-> (Year -> Year -> Year)
-> (Year -> Year -> Year)
-> (Year -> Year)
-> (Year -> Year)
-> (Year -> Year)
-> (Integer -> Year)
-> Num Year
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Year
$cfromInteger :: Integer -> Year
signum :: Year -> Year
$csignum :: Year -> Year
abs :: Year -> Year
$cabs :: Year -> Year
negate :: Year -> Year
$cnegate :: Year -> Year
* :: Year -> Year -> Year
$c* :: Year -> Year -> Year
- :: Year -> Year -> Year
$c- :: Year -> Year -> Year
+ :: Year -> Year -> Year
$c+ :: Year -> Year -> Year
Num, Num Year
Ord Year
Num Year -> Ord Year -> (Year -> Rational) -> Real Year
Year -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Year -> Rational
$ctoRational :: Year -> Rational
Real, Int -> Year
Year -> Int
Year -> [Year]
Year -> Year
Year -> Year -> [Year]
Year -> Year -> Year -> [Year]
(Year -> Year)
-> (Year -> Year)
-> (Int -> Year)
-> (Year -> Int)
-> (Year -> [Year])
-> (Year -> Year -> [Year])
-> (Year -> Year -> [Year])
-> (Year -> Year -> Year -> [Year])
-> Enum Year
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Year -> Year -> Year -> [Year]
$cenumFromThenTo :: Year -> Year -> Year -> [Year]
enumFromTo :: Year -> Year -> [Year]
$cenumFromTo :: Year -> Year -> [Year]
enumFromThen :: Year -> Year -> [Year]
$cenumFromThen :: Year -> Year -> [Year]
enumFrom :: Year -> [Year]
$cenumFrom :: Year -> [Year]
fromEnum :: Year -> Int
$cfromEnum :: Year -> Int
toEnum :: Int -> Year
$ctoEnum :: Int -> Year
pred :: Year -> Year
$cpred :: Year -> Year
succ :: Year -> Year
$csucc :: Year -> Year
Enum, Enum Year
Real Year
Real Year
-> Enum Year
-> (Year -> Year -> Year)
-> (Year -> Year -> Year)
-> (Year -> Year -> Year)
-> (Year -> Year -> Year)
-> (Year -> Year -> (Year, Year))
-> (Year -> Year -> (Year, Year))
-> (Year -> Integer)
-> Integral Year
Year -> Integer
Year -> Year -> (Year, Year)
Year -> Year -> Year
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: Year -> Integer
$ctoInteger :: Year -> Integer
divMod :: Year -> Year -> (Year, Year)
$cdivMod :: Year -> Year -> (Year, Year)
quotRem :: Year -> Year -> (Year, Year)
$cquotRem :: Year -> Year -> (Year, Year)
mod :: Year -> Year -> Year
$cmod :: Year -> Year -> Year
div :: Year -> Year -> Year
$cdiv :: Year -> Year -> Year
rem :: Year -> Year -> Year
$crem :: Year -> Year -> Year
quot :: Year -> Year -> Year
$cquot :: Year -> Year -> Year
Integral, Eq Year
Eq Year
-> (Year -> Year -> Ordering)
-> (Year -> Year -> Bool)
-> (Year -> Year -> Bool)
-> (Year -> Year -> Bool)
-> (Year -> Year -> Bool)
-> (Year -> Year -> Year)
-> (Year -> Year -> Year)
-> Ord Year
Year -> Year -> Bool
Year -> Year -> Ordering
Year -> Year -> Year
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 :: Year -> Year -> Year
$cmin :: Year -> Year -> Year
max :: Year -> Year -> Year
$cmax :: Year -> Year -> Year
>= :: Year -> Year -> Bool
$c>= :: Year -> Year -> Bool
> :: Year -> Year -> Bool
$c> :: Year -> Year -> Bool
<= :: Year -> Year -> Bool
$c<= :: Year -> Year -> Bool
< :: Year -> Year -> Bool
$c< :: Year -> Year -> Bool
compare :: Year -> Year -> Ordering
$ccompare :: Year -> Year -> Ordering
Ord)

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

instance Default PrintDir where
  def :: PrintDir
def =
    Bool -> PrintDir
PrintDir Bool
False

data Github =
  Github {
    Github -> GithubOrg
org :: GithubOrg,
    Github -> GithubRepo
repo :: GithubRepo
  }
  deriving stock (Github -> Github -> Bool
(Github -> Github -> Bool)
-> (Github -> Github -> Bool) -> Eq Github
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Github -> Github -> Bool
$c/= :: Github -> Github -> Bool
== :: Github -> Github -> Bool
$c== :: Github -> Github -> Bool
Eq, Int -> Github -> ShowS
[Github] -> ShowS
Github -> String
(Int -> Github -> ShowS)
-> (Github -> String) -> ([Github] -> ShowS) -> Show Github
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Github] -> ShowS
$cshowList :: [Github] -> ShowS
show :: Github -> String
$cshow :: Github -> String
showsPrec :: Int -> Github -> ShowS
$cshowsPrec :: Int -> Github -> ShowS
Show, (forall x. Github -> Rep Github x)
-> (forall x. Rep Github x -> Github) -> Generic Github
forall x. Rep Github x -> Github
forall x. Github -> Rep Github x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Github x -> Github
$cfrom :: forall x. Github -> Rep Github x
Generic)

data Cachix =
  Cachix {
    Cachix -> CachixName
cachixName :: CachixName,
    Cachix -> CachixKey
cachixKey :: CachixKey
  }
  deriving stock (Cachix -> Cachix -> Bool
(Cachix -> Cachix -> Bool)
-> (Cachix -> Cachix -> Bool) -> Eq Cachix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cachix -> Cachix -> Bool
$c/= :: Cachix -> Cachix -> Bool
== :: Cachix -> Cachix -> Bool
$c== :: Cachix -> Cachix -> Bool
Eq, Int -> Cachix -> ShowS
[Cachix] -> ShowS
Cachix -> String
(Int -> Cachix -> ShowS)
-> (Cachix -> String) -> ([Cachix] -> ShowS) -> Show Cachix
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Cachix] -> ShowS
$cshowList :: [Cachix] -> ShowS
show :: Cachix -> String
$cshow :: Cachix -> String
showsPrec :: Int -> Cachix -> ShowS
$cshowsPrec :: Int -> Cachix -> ShowS
Show, (forall x. Cachix -> Rep Cachix x)
-> (forall x. Rep Cachix x -> Cachix) -> Generic Cachix
forall x. Rep Cachix x -> Cachix
forall x. Cachix -> Rep Cachix x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Cachix x -> Cachix
$cfrom :: forall x. Cachix -> Rep Cachix x
Generic)

cachixTek :: Cachix
cachixTek :: Cachix
cachixTek =
  CachixName -> CachixKey -> Cachix
Cachix CachixName
"tek" CachixKey
"tek.cachix.org-1:+sdc73WFq8aEKnrVv5j/kuhmnW2hQJuqdPJF5SnaCBk="

data Project =
  Project {
    Project -> ProjectNames
names :: ProjectNames,
    Project -> Maybe Github
github :: Maybe Github,
    Project -> Maybe Cachix
cachix :: Maybe Cachix,
    Project -> Path Abs Dir
directory :: Path Abs Dir,
    Project -> Branch
branch :: Branch
  }
  deriving stock (Project -> Project -> Bool
(Project -> Project -> Bool)
-> (Project -> Project -> Bool) -> Eq Project
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Project -> Project -> Bool
$c/= :: Project -> Project -> Bool
== :: Project -> Project -> Bool
$c== :: Project -> Project -> Bool
Eq, Int -> Project -> ShowS
[Project] -> ShowS
Project -> String
(Int -> Project -> ShowS)
-> (Project -> String) -> ([Project] -> ShowS) -> Show Project
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Project] -> ShowS
$cshowList :: [Project] -> ShowS
show :: Project -> String
$cshow :: Project -> String
showsPrec :: Int -> Project -> ShowS
$cshowsPrec :: Int -> Project -> ShowS
Show, (forall x. Project -> Rep Project x)
-> (forall x. Rep Project x -> Project) -> Generic Project
forall x. Rep Project x -> Project
forall x. Project -> Rep Project x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Project x -> Project
$cfrom :: forall x. Project -> Rep Project x
Generic)

data Global =
  Global {
    Global -> Bool
quiet :: Bool,
    Global -> Bool
force :: Bool
  }
  deriving stock (Global -> Global -> Bool
(Global -> Global -> Bool)
-> (Global -> Global -> Bool) -> Eq Global
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Global -> Global -> Bool
$c/= :: Global -> Global -> Bool
== :: Global -> Global -> Bool
$c== :: Global -> Global -> Bool
Eq, Int -> Global -> ShowS
[Global] -> ShowS
Global -> String
(Int -> Global -> ShowS)
-> (Global -> String) -> ([Global] -> ShowS) -> Show Global
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Global] -> ShowS
$cshowList :: [Global] -> ShowS
show :: Global -> String
$cshow :: Global -> String
showsPrec :: Int -> Global -> ShowS
$cshowsPrec :: Int -> Global -> ShowS
Show, (forall x. Global -> Rep Global x)
-> (forall x. Rep Global x -> Global) -> Generic Global
forall x. Rep Global x -> Global
forall x. Global -> Rep Global x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Global x -> Global
$cfrom :: forall x. Global -> Rep Global x
Generic)

instance Default Global where
  def :: Global
def =
    Bool -> Bool -> Global
Global Bool
False Bool
False

data NewProject =
  NewProject {
    NewProject -> Project
project :: Project,
    NewProject -> FlakeUrl
flakeUrl :: FlakeUrl,
    NewProject -> PrintDir
printDir :: PrintDir,
    NewProject -> Author
author :: Author,
    NewProject -> Maintainer
maintainer :: Maintainer
  }
  deriving stock (NewProject -> NewProject -> Bool
(NewProject -> NewProject -> Bool)
-> (NewProject -> NewProject -> Bool) -> Eq NewProject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NewProject -> NewProject -> Bool
$c/= :: NewProject -> NewProject -> Bool
== :: NewProject -> NewProject -> Bool
$c== :: NewProject -> NewProject -> Bool
Eq, Int -> NewProject -> ShowS
[NewProject] -> ShowS
NewProject -> String
(Int -> NewProject -> ShowS)
-> (NewProject -> String)
-> ([NewProject] -> ShowS)
-> Show NewProject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NewProject] -> ShowS
$cshowList :: [NewProject] -> ShowS
show :: NewProject -> String
$cshow :: NewProject -> String
showsPrec :: Int -> NewProject -> ShowS
$cshowsPrec :: Int -> NewProject -> ShowS
Show, (forall x. NewProject -> Rep NewProject x)
-> (forall x. Rep NewProject x -> NewProject) -> Generic NewProject
forall x. Rep NewProject x -> NewProject
forall x. NewProject -> Rep NewProject x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NewProject x -> NewProject
$cfrom :: forall x. NewProject -> Rep NewProject x
Generic)