{-# LANGUAGE DeriveAnyClass    #-}
{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE OverloadedStrings #-}

module Package.C.Triple.Type ( TargetTriple (..)
                             , Manufacturer (..)
                             , Arch (..)
                             , ABI (..)
                             , OS (..)
                             ) where

import           CPkgPrelude
import           Data.Text.Prettyprint.Doc.Custom

-- TODO: are the derived Binary instances inefficient? possibly replace them
-- with handwritten instances...
data TargetTriple = TargetTriple { TargetTriple -> Arch
arch         :: Arch
                                 , TargetTriple -> Maybe Manufacturer
manufacturer :: Maybe Manufacturer
                                 , TargetTriple -> OS
os           :: OS
                                 , TargetTriple -> Maybe ABI
abi          :: Maybe ABI
                                 }
                                 deriving (TargetTriple -> TargetTriple -> Bool
(TargetTriple -> TargetTriple -> Bool)
-> (TargetTriple -> TargetTriple -> Bool) -> Eq TargetTriple
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TargetTriple -> TargetTriple -> Bool
== :: TargetTriple -> TargetTriple -> Bool
$c/= :: TargetTriple -> TargetTriple -> Bool
/= :: TargetTriple -> TargetTriple -> Bool
Eq, Eq TargetTriple
Eq TargetTriple =>
(TargetTriple -> TargetTriple -> Ordering)
-> (TargetTriple -> TargetTriple -> Bool)
-> (TargetTriple -> TargetTriple -> Bool)
-> (TargetTriple -> TargetTriple -> Bool)
-> (TargetTriple -> TargetTriple -> Bool)
-> (TargetTriple -> TargetTriple -> TargetTriple)
-> (TargetTriple -> TargetTriple -> TargetTriple)
-> Ord TargetTriple
TargetTriple -> TargetTriple -> Bool
TargetTriple -> TargetTriple -> Ordering
TargetTriple -> TargetTriple -> TargetTriple
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
$ccompare :: TargetTriple -> TargetTriple -> Ordering
compare :: TargetTriple -> TargetTriple -> Ordering
$c< :: TargetTriple -> TargetTriple -> Bool
< :: TargetTriple -> TargetTriple -> Bool
$c<= :: TargetTriple -> TargetTriple -> Bool
<= :: TargetTriple -> TargetTriple -> Bool
$c> :: TargetTriple -> TargetTriple -> Bool
> :: TargetTriple -> TargetTriple -> Bool
$c>= :: TargetTriple -> TargetTriple -> Bool
>= :: TargetTriple -> TargetTriple -> Bool
$cmax :: TargetTriple -> TargetTriple -> TargetTriple
max :: TargetTriple -> TargetTriple -> TargetTriple
$cmin :: TargetTriple -> TargetTriple -> TargetTriple
min :: TargetTriple -> TargetTriple -> TargetTriple
Ord, Eq TargetTriple
Eq TargetTriple =>
(Int -> TargetTriple -> Int)
-> (TargetTriple -> Int) -> Hashable TargetTriple
Int -> TargetTriple -> Int
TargetTriple -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> TargetTriple -> Int
hashWithSalt :: Int -> TargetTriple -> Int
$chash :: TargetTriple -> Int
hash :: TargetTriple -> Int
Hashable, Get TargetTriple
[TargetTriple] -> Put
TargetTriple -> Put
(TargetTriple -> Put)
-> Get TargetTriple
-> ([TargetTriple] -> Put)
-> Binary TargetTriple
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: TargetTriple -> Put
put :: TargetTriple -> Put
$cget :: Get TargetTriple
get :: Get TargetTriple
$cputList :: [TargetTriple] -> Put
putList :: [TargetTriple] -> Put
Binary, (forall x. TargetTriple -> Rep TargetTriple x)
-> (forall x. Rep TargetTriple x -> TargetTriple)
-> Generic TargetTriple
forall x. Rep TargetTriple x -> TargetTriple
forall x. TargetTriple -> Rep TargetTriple x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TargetTriple -> Rep TargetTriple x
from :: forall x. TargetTriple -> Rep TargetTriple x
$cto :: forall x. Rep TargetTriple x -> TargetTriple
to :: forall x. Rep TargetTriple x -> TargetTriple
Generic, InputNormalizer -> Encoder TargetTriple
(InputNormalizer -> Encoder TargetTriple) -> ToDhall TargetTriple
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
$cinjectWith :: InputNormalizer -> Encoder TargetTriple
injectWith :: InputNormalizer -> Encoder TargetTriple
ToDhall)

instance Pretty TargetTriple where
    pretty :: forall ann. TargetTriple -> Doc ann
pretty (TargetTriple Arch
a (Just Manufacturer
m) OS
o (Just ABI
ab)) = [Doc ann] -> Doc ann
forall a. [Doc a] -> Doc a
dashed [Arch -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Arch -> Doc ann
pretty Arch
a, Manufacturer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Manufacturer -> Doc ann
pretty Manufacturer
m, OS -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. OS -> Doc ann
pretty OS
o, ABI -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ABI -> Doc ann
pretty ABI
ab]
    pretty (TargetTriple Arch
a Maybe Manufacturer
Nothing OS
o (Just ABI
ab))  = [Doc ann] -> Doc ann
forall a. [Doc a] -> Doc a
dashed [Arch -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Arch -> Doc ann
pretty Arch
a, OS -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. OS -> Doc ann
pretty OS
o, ABI -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ABI -> Doc ann
pretty ABI
ab]
    pretty (TargetTriple Arch
a (Just Manufacturer
m) OS
o Maybe ABI
Nothing)   = [Doc ann] -> Doc ann
forall a. [Doc a] -> Doc a
dashed [Arch -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Arch -> Doc ann
pretty Arch
a, Manufacturer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Manufacturer -> Doc ann
pretty Manufacturer
m, OS -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. OS -> Doc ann
pretty OS
o]
    pretty (TargetTriple Arch
a Maybe Manufacturer
Nothing OS
o Maybe ABI
Nothing)    = [Doc ann] -> Doc ann
forall a. [Doc a] -> Doc a
dashed [Arch -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Arch -> Doc ann
pretty Arch
a, OS -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. OS -> Doc ann
pretty OS
o]

instance Show TargetTriple where
    show :: TargetTriple -> String
show = Doc Any -> String
forall a. Show a => a -> String
show (Doc Any -> String)
-> (TargetTriple -> Doc Any) -> TargetTriple -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TargetTriple -> Doc Any
forall a ann. Pretty a => a -> Doc ann
forall ann. TargetTriple -> Doc ann
pretty

data Manufacturer = Unknown
                  | Apple
                  | IBM
                  | PC
                  deriving (Manufacturer -> Manufacturer -> Bool
(Manufacturer -> Manufacturer -> Bool)
-> (Manufacturer -> Manufacturer -> Bool) -> Eq Manufacturer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Manufacturer -> Manufacturer -> Bool
== :: Manufacturer -> Manufacturer -> Bool
$c/= :: Manufacturer -> Manufacturer -> Bool
/= :: Manufacturer -> Manufacturer -> Bool
Eq, Eq Manufacturer
Eq Manufacturer =>
(Manufacturer -> Manufacturer -> Ordering)
-> (Manufacturer -> Manufacturer -> Bool)
-> (Manufacturer -> Manufacturer -> Bool)
-> (Manufacturer -> Manufacturer -> Bool)
-> (Manufacturer -> Manufacturer -> Bool)
-> (Manufacturer -> Manufacturer -> Manufacturer)
-> (Manufacturer -> Manufacturer -> Manufacturer)
-> Ord Manufacturer
Manufacturer -> Manufacturer -> Bool
Manufacturer -> Manufacturer -> Ordering
Manufacturer -> Manufacturer -> Manufacturer
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
$ccompare :: Manufacturer -> Manufacturer -> Ordering
compare :: Manufacturer -> Manufacturer -> Ordering
$c< :: Manufacturer -> Manufacturer -> Bool
< :: Manufacturer -> Manufacturer -> Bool
$c<= :: Manufacturer -> Manufacturer -> Bool
<= :: Manufacturer -> Manufacturer -> Bool
$c> :: Manufacturer -> Manufacturer -> Bool
> :: Manufacturer -> Manufacturer -> Bool
$c>= :: Manufacturer -> Manufacturer -> Bool
>= :: Manufacturer -> Manufacturer -> Bool
$cmax :: Manufacturer -> Manufacturer -> Manufacturer
max :: Manufacturer -> Manufacturer -> Manufacturer
$cmin :: Manufacturer -> Manufacturer -> Manufacturer
min :: Manufacturer -> Manufacturer -> Manufacturer
Ord, Eq Manufacturer
Eq Manufacturer =>
(Int -> Manufacturer -> Int)
-> (Manufacturer -> Int) -> Hashable Manufacturer
Int -> Manufacturer -> Int
Manufacturer -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Manufacturer -> Int
hashWithSalt :: Int -> Manufacturer -> Int
$chash :: Manufacturer -> Int
hash :: Manufacturer -> Int
Hashable, Get Manufacturer
[Manufacturer] -> Put
Manufacturer -> Put
(Manufacturer -> Put)
-> Get Manufacturer
-> ([Manufacturer] -> Put)
-> Binary Manufacturer
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: Manufacturer -> Put
put :: Manufacturer -> Put
$cget :: Get Manufacturer
get :: Get Manufacturer
$cputList :: [Manufacturer] -> Put
putList :: [Manufacturer] -> Put
Binary, (forall x. Manufacturer -> Rep Manufacturer x)
-> (forall x. Rep Manufacturer x -> Manufacturer)
-> Generic Manufacturer
forall x. Rep Manufacturer x -> Manufacturer
forall x. Manufacturer -> Rep Manufacturer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Manufacturer -> Rep Manufacturer x
from :: forall x. Manufacturer -> Rep Manufacturer x
$cto :: forall x. Rep Manufacturer x -> Manufacturer
to :: forall x. Rep Manufacturer x -> Manufacturer
Generic, InputNormalizer -> Encoder Manufacturer
(InputNormalizer -> Encoder Manufacturer) -> ToDhall Manufacturer
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
$cinjectWith :: InputNormalizer -> Encoder Manufacturer
injectWith :: InputNormalizer -> Encoder Manufacturer
ToDhall)

instance Pretty Manufacturer where
    pretty :: forall ann. Manufacturer -> Doc ann
pretty Manufacturer
Unknown = Doc ann
"unknown"
    pretty Manufacturer
Apple   = Doc ann
"apple"
    pretty Manufacturer
IBM     = Doc ann
"ibm"
    pretty Manufacturer
PC      = Doc ann
"pc"

data Arch = X64
          | AArch
          | Arm
          | RISCV64
          | PowerPC
          | PowerPC64
          | PowerPC64le
          | Sparc64
          | S390x
          | Alpha
          | M68k
          | Mips
          | MipsEl
          | Mips64
          | Mips64El
          | X86
          | SH4
          | HPPA
          | HPPA64
          | MipsIsa32r6El
          | MipsIsa32r6
          | MipsIsa64r6El
          | MipsIsa64r6
          deriving (Arch -> Arch -> Bool
(Arch -> Arch -> Bool) -> (Arch -> Arch -> Bool) -> Eq Arch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Arch -> Arch -> Bool
== :: Arch -> Arch -> Bool
$c/= :: Arch -> Arch -> Bool
/= :: Arch -> Arch -> Bool
Eq, Eq Arch
Eq Arch =>
(Arch -> Arch -> Ordering)
-> (Arch -> Arch -> Bool)
-> (Arch -> Arch -> Bool)
-> (Arch -> Arch -> Bool)
-> (Arch -> Arch -> Bool)
-> (Arch -> Arch -> Arch)
-> (Arch -> Arch -> Arch)
-> Ord Arch
Arch -> Arch -> Bool
Arch -> Arch -> Ordering
Arch -> Arch -> Arch
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
$ccompare :: Arch -> Arch -> Ordering
compare :: Arch -> Arch -> Ordering
$c< :: Arch -> Arch -> Bool
< :: Arch -> Arch -> Bool
$c<= :: Arch -> Arch -> Bool
<= :: Arch -> Arch -> Bool
$c> :: Arch -> Arch -> Bool
> :: Arch -> Arch -> Bool
$c>= :: Arch -> Arch -> Bool
>= :: Arch -> Arch -> Bool
$cmax :: Arch -> Arch -> Arch
max :: Arch -> Arch -> Arch
$cmin :: Arch -> Arch -> Arch
min :: Arch -> Arch -> Arch
Ord, Eq Arch
Eq Arch => (Int -> Arch -> Int) -> (Arch -> Int) -> Hashable Arch
Int -> Arch -> Int
Arch -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Arch -> Int
hashWithSalt :: Int -> Arch -> Int
$chash :: Arch -> Int
hash :: Arch -> Int
Hashable, Get Arch
[Arch] -> Put
Arch -> Put
(Arch -> Put) -> Get Arch -> ([Arch] -> Put) -> Binary Arch
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: Arch -> Put
put :: Arch -> Put
$cget :: Get Arch
get :: Get Arch
$cputList :: [Arch] -> Put
putList :: [Arch] -> Put
Binary, (forall x. Arch -> Rep Arch x)
-> (forall x. Rep Arch x -> Arch) -> Generic Arch
forall x. Rep Arch x -> Arch
forall x. Arch -> Rep Arch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Arch -> Rep Arch x
from :: forall x. Arch -> Rep Arch x
$cto :: forall x. Rep Arch x -> Arch
to :: forall x. Rep Arch x -> Arch
Generic, InputNormalizer -> Encoder Arch
(InputNormalizer -> Encoder Arch) -> ToDhall Arch
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
$cinjectWith :: InputNormalizer -> Encoder Arch
injectWith :: InputNormalizer -> Encoder Arch
ToDhall)

instance Pretty Arch where
    pretty :: forall ann. Arch -> Doc ann
pretty Arch
X64           = Doc ann
"x86_64"
    pretty Arch
AArch         = Doc ann
"aarch64"
    pretty Arch
Arm           = Doc ann
"arm"
    pretty Arch
RISCV64       = Doc ann
"riscv64"
    pretty Arch
PowerPC       = Doc ann
"powerpc"
    pretty Arch
PowerPC64     = Doc ann
"powerpc64"
    pretty Arch
PowerPC64le   = Doc ann
"powerpc64le"
    pretty Arch
Sparc64       = Doc ann
"sparc64"
    pretty Arch
S390x         = Doc ann
"s390x"
    pretty Arch
Alpha         = Doc ann
"alpha"
    pretty Arch
M68k          = Doc ann
"m68k"
    pretty Arch
Mips          = Doc ann
"mips"
    pretty Arch
MipsEl        = Doc ann
"mipsel"
    pretty Arch
Mips64        = Doc ann
"mips64"
    pretty Arch
Mips64El      = Doc ann
"mips64el"
    pretty Arch
X86           = Doc ann
"i686"
    pretty Arch
SH4           = Doc ann
"sh4"
    pretty Arch
HPPA          = Doc ann
"hppa"
    pretty Arch
HPPA64        = Doc ann
"hppa64"
    pretty Arch
MipsIsa32r6El = Doc ann
"mipsisa32r6el"
    pretty Arch
MipsIsa32r6   = Doc ann
"mipsisa32r6"
    pretty Arch
MipsIsa64r6El = Doc ann
"mipsisa64r6el"
    pretty Arch
MipsIsa64r6   = Doc ann
"mipsisa64r6"

data ABI = GNU
         | GNUabi64
         | GNUeabi
         | GNUeabihf
         | GNUspe
         | MinGw
         deriving (ABI -> ABI -> Bool
(ABI -> ABI -> Bool) -> (ABI -> ABI -> Bool) -> Eq ABI
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ABI -> ABI -> Bool
== :: ABI -> ABI -> Bool
$c/= :: ABI -> ABI -> Bool
/= :: ABI -> ABI -> Bool
Eq, Eq ABI
Eq ABI =>
(ABI -> ABI -> Ordering)
-> (ABI -> ABI -> Bool)
-> (ABI -> ABI -> Bool)
-> (ABI -> ABI -> Bool)
-> (ABI -> ABI -> Bool)
-> (ABI -> ABI -> ABI)
-> (ABI -> ABI -> ABI)
-> Ord ABI
ABI -> ABI -> Bool
ABI -> ABI -> Ordering
ABI -> ABI -> ABI
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
$ccompare :: ABI -> ABI -> Ordering
compare :: ABI -> ABI -> Ordering
$c< :: ABI -> ABI -> Bool
< :: ABI -> ABI -> Bool
$c<= :: ABI -> ABI -> Bool
<= :: ABI -> ABI -> Bool
$c> :: ABI -> ABI -> Bool
> :: ABI -> ABI -> Bool
$c>= :: ABI -> ABI -> Bool
>= :: ABI -> ABI -> Bool
$cmax :: ABI -> ABI -> ABI
max :: ABI -> ABI -> ABI
$cmin :: ABI -> ABI -> ABI
min :: ABI -> ABI -> ABI
Ord, Eq ABI
Eq ABI => (Int -> ABI -> Int) -> (ABI -> Int) -> Hashable ABI
Int -> ABI -> Int
ABI -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> ABI -> Int
hashWithSalt :: Int -> ABI -> Int
$chash :: ABI -> Int
hash :: ABI -> Int
Hashable, Get ABI
[ABI] -> Put
ABI -> Put
(ABI -> Put) -> Get ABI -> ([ABI] -> Put) -> Binary ABI
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: ABI -> Put
put :: ABI -> Put
$cget :: Get ABI
get :: Get ABI
$cputList :: [ABI] -> Put
putList :: [ABI] -> Put
Binary, (forall x. ABI -> Rep ABI x)
-> (forall x. Rep ABI x -> ABI) -> Generic ABI
forall x. Rep ABI x -> ABI
forall x. ABI -> Rep ABI x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ABI -> Rep ABI x
from :: forall x. ABI -> Rep ABI x
$cto :: forall x. Rep ABI x -> ABI
to :: forall x. Rep ABI x -> ABI
Generic, InputNormalizer -> Encoder ABI
(InputNormalizer -> Encoder ABI) -> ToDhall ABI
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
$cinjectWith :: InputNormalizer -> Encoder ABI
injectWith :: InputNormalizer -> Encoder ABI
ToDhall)

instance Pretty ABI where
    pretty :: forall ann. ABI -> Doc ann
pretty ABI
GNU       = Doc ann
"gnu"
    pretty ABI
GNUabi64  = Doc ann
"gnuabi64"
    pretty ABI
GNUeabi   = Doc ann
"gnueabi"
    pretty ABI
GNUeabihf = Doc ann
"gnueabihf"
    pretty ABI
GNUspe    = Doc ann
"gnuspe"
    pretty ABI
MinGw     = Doc ann
"mingw32"

data OS = Darwin
        | Dragonfly
        | FreeBSD
        | Linux
        | OpenBSD
        | NetBSD
        | Solaris
        | Windows
        | Redox
        | Haiku
        | IOS
        | AIX
        | Hurd
        | Android
        | NoOs
        deriving (OS -> OS -> Bool
(OS -> OS -> Bool) -> (OS -> OS -> Bool) -> Eq OS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OS -> OS -> Bool
== :: OS -> OS -> Bool
$c/= :: OS -> OS -> Bool
/= :: OS -> OS -> Bool
Eq, Eq OS
Eq OS =>
(OS -> OS -> Ordering)
-> (OS -> OS -> Bool)
-> (OS -> OS -> Bool)
-> (OS -> OS -> Bool)
-> (OS -> OS -> Bool)
-> (OS -> OS -> OS)
-> (OS -> OS -> OS)
-> Ord OS
OS -> OS -> Bool
OS -> OS -> Ordering
OS -> OS -> OS
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
$ccompare :: OS -> OS -> Ordering
compare :: OS -> OS -> Ordering
$c< :: OS -> OS -> Bool
< :: OS -> OS -> Bool
$c<= :: OS -> OS -> Bool
<= :: OS -> OS -> Bool
$c> :: OS -> OS -> Bool
> :: OS -> OS -> Bool
$c>= :: OS -> OS -> Bool
>= :: OS -> OS -> Bool
$cmax :: OS -> OS -> OS
max :: OS -> OS -> OS
$cmin :: OS -> OS -> OS
min :: OS -> OS -> OS
Ord, Eq OS
Eq OS => (Int -> OS -> Int) -> (OS -> Int) -> Hashable OS
Int -> OS -> Int
OS -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> OS -> Int
hashWithSalt :: Int -> OS -> Int
$chash :: OS -> Int
hash :: OS -> Int
Hashable, Get OS
[OS] -> Put
OS -> Put
(OS -> Put) -> Get OS -> ([OS] -> Put) -> Binary OS
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: OS -> Put
put :: OS -> Put
$cget :: Get OS
get :: Get OS
$cputList :: [OS] -> Put
putList :: [OS] -> Put
Binary, (forall x. OS -> Rep OS x)
-> (forall x. Rep OS x -> OS) -> Generic OS
forall x. Rep OS x -> OS
forall x. OS -> Rep OS x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OS -> Rep OS x
from :: forall x. OS -> Rep OS x
$cto :: forall x. Rep OS x -> OS
to :: forall x. Rep OS x -> OS
Generic, InputNormalizer -> Encoder OS
(InputNormalizer -> Encoder OS) -> ToDhall OS
forall a. (InputNormalizer -> Encoder a) -> ToDhall a
$cinjectWith :: InputNormalizer -> Encoder OS
injectWith :: InputNormalizer -> Encoder OS
ToDhall)
        -- IRIX? HP UX?

instance Pretty OS where
    pretty :: forall ann. OS -> Doc ann
pretty OS
Darwin    = Doc ann
"darwin"
    pretty OS
Dragonfly = Doc ann
"dragonfly"
    pretty OS
FreeBSD   = Doc ann
"freebsd"
    pretty OS
Linux     = Doc ann
"linux"
    pretty OS
OpenBSD   = Doc ann
"openbsd"
    pretty OS
NetBSD    = Doc ann
"netbsd"
    pretty OS
Solaris   = Doc ann
"solaris"
    pretty OS
Windows   = Doc ann
"w64"
    pretty OS
Redox     = Doc ann
"redox"
    pretty OS
Haiku     = Doc ann
"haiku"
    pretty OS
IOS       = Doc ann
"ios"
    pretty OS
AIX       = Doc ann
"aix"
    pretty OS
Hurd      = Doc ann
"hurd"
    pretty OS
Android   = Doc ann
"android"
    pretty OS
NoOs      = Doc ann
"none"