module Mensam.API.Data.Reservation where

import Mensam.API.Aeson
import Mensam.API.Data.Desk
import Mensam.API.Data.User
import Mensam.API.Pretty

import Data.Aeson qualified as A
import Data.Int
import Data.Kind
import Data.Text qualified as T
import Data.Time qualified as T
import Deriving.Aeson qualified as A
import GHC.Generics

type Reservation :: Type
data Reservation = MkReservation
  { Reservation -> IdentifierReservation
reservationId :: IdentifierReservation
  , Reservation -> IdentifierDesk
reservationDesk :: IdentifierDesk
  , Reservation -> IdentifierUser
reservationUser :: IdentifierUser
  , Reservation -> UTCTime
reservationTimeBegin :: T.UTCTime
  , Reservation -> UTCTime
reservationTimeEnd :: T.UTCTime
  , Reservation -> StatusReservation
reservationStatus :: StatusReservation
  }
  deriving stock (Reservation -> Reservation -> Bool
(Reservation -> Reservation -> Bool)
-> (Reservation -> Reservation -> Bool) -> Eq Reservation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Reservation -> Reservation -> Bool
== :: Reservation -> Reservation -> Bool
$c/= :: Reservation -> Reservation -> Bool
/= :: Reservation -> Reservation -> Bool
Eq, (forall x. Reservation -> Rep Reservation x)
-> (forall x. Rep Reservation x -> Reservation)
-> Generic Reservation
forall x. Rep Reservation x -> Reservation
forall x. Reservation -> Rep Reservation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Reservation -> Rep Reservation x
from :: forall x. Reservation -> Rep Reservation x
$cto :: forall x. Rep Reservation x -> Reservation
to :: forall x. Rep Reservation x -> Reservation
Generic, Eq Reservation
Eq Reservation =>
(Reservation -> Reservation -> Ordering)
-> (Reservation -> Reservation -> Bool)
-> (Reservation -> Reservation -> Bool)
-> (Reservation -> Reservation -> Bool)
-> (Reservation -> Reservation -> Bool)
-> (Reservation -> Reservation -> Reservation)
-> (Reservation -> Reservation -> Reservation)
-> Ord Reservation
Reservation -> Reservation -> Bool
Reservation -> Reservation -> Ordering
Reservation -> Reservation -> Reservation
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 :: Reservation -> Reservation -> Ordering
compare :: Reservation -> Reservation -> Ordering
$c< :: Reservation -> Reservation -> Bool
< :: Reservation -> Reservation -> Bool
$c<= :: Reservation -> Reservation -> Bool
<= :: Reservation -> Reservation -> Bool
$c> :: Reservation -> Reservation -> Bool
> :: Reservation -> Reservation -> Bool
$c>= :: Reservation -> Reservation -> Bool
>= :: Reservation -> Reservation -> Bool
$cmax :: Reservation -> Reservation -> Reservation
max :: Reservation -> Reservation -> Reservation
$cmin :: Reservation -> Reservation -> Reservation
min :: Reservation -> Reservation -> Reservation
Ord, ReadPrec [Reservation]
ReadPrec Reservation
Int -> ReadS Reservation
ReadS [Reservation]
(Int -> ReadS Reservation)
-> ReadS [Reservation]
-> ReadPrec Reservation
-> ReadPrec [Reservation]
-> Read Reservation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Reservation
readsPrec :: Int -> ReadS Reservation
$creadList :: ReadS [Reservation]
readList :: ReadS [Reservation]
$creadPrec :: ReadPrec Reservation
readPrec :: ReadPrec Reservation
$creadListPrec :: ReadPrec [Reservation]
readListPrec :: ReadPrec [Reservation]
Read, Int -> Reservation -> ShowS
[Reservation] -> ShowS
Reservation -> String
(Int -> Reservation -> ShowS)
-> (Reservation -> String)
-> ([Reservation] -> ShowS)
-> Show Reservation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Reservation -> ShowS
showsPrec :: Int -> Reservation -> ShowS
$cshow :: Reservation -> String
show :: Reservation -> String
$cshowList :: [Reservation] -> ShowS
showList :: [Reservation] -> ShowS
Show)
  deriving
    (Value -> Parser [Reservation]
Value -> Parser Reservation
(Value -> Parser Reservation)
-> (Value -> Parser [Reservation]) -> FromJSON Reservation
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser Reservation
parseJSON :: Value -> Parser Reservation
$cparseJSONList :: Value -> Parser [Reservation]
parseJSONList :: Value -> Parser [Reservation]
A.FromJSON, [Reservation] -> Value
[Reservation] -> Encoding
Reservation -> Value
Reservation -> Encoding
(Reservation -> Value)
-> (Reservation -> Encoding)
-> ([Reservation] -> Value)
-> ([Reservation] -> Encoding)
-> ToJSON Reservation
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: Reservation -> Value
toJSON :: Reservation -> Value
$ctoEncoding :: Reservation -> Encoding
toEncoding :: Reservation -> Encoding
$ctoJSONList :: [Reservation] -> Value
toJSONList :: [Reservation] -> Value
$ctoEncodingList :: [Reservation] -> Encoding
toEncodingList :: [Reservation] -> Encoding
A.ToJSON)
    via A.CustomJSON (JSONSettings "Mk" "reservation") Reservation

type IdentifierReservation :: Type
newtype IdentifierReservation = MkIdentifierReservation {IdentifierReservation -> Int64
unIdentifierReservation :: Int64}
  deriving stock (IdentifierReservation -> IdentifierReservation -> Bool
(IdentifierReservation -> IdentifierReservation -> Bool)
-> (IdentifierReservation -> IdentifierReservation -> Bool)
-> Eq IdentifierReservation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IdentifierReservation -> IdentifierReservation -> Bool
== :: IdentifierReservation -> IdentifierReservation -> Bool
$c/= :: IdentifierReservation -> IdentifierReservation -> Bool
/= :: IdentifierReservation -> IdentifierReservation -> Bool
Eq, (forall x. IdentifierReservation -> Rep IdentifierReservation x)
-> (forall x. Rep IdentifierReservation x -> IdentifierReservation)
-> Generic IdentifierReservation
forall x. Rep IdentifierReservation x -> IdentifierReservation
forall x. IdentifierReservation -> Rep IdentifierReservation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IdentifierReservation -> Rep IdentifierReservation x
from :: forall x. IdentifierReservation -> Rep IdentifierReservation x
$cto :: forall x. Rep IdentifierReservation x -> IdentifierReservation
to :: forall x. Rep IdentifierReservation x -> IdentifierReservation
Generic, Eq IdentifierReservation
Eq IdentifierReservation =>
(IdentifierReservation -> IdentifierReservation -> Ordering)
-> (IdentifierReservation -> IdentifierReservation -> Bool)
-> (IdentifierReservation -> IdentifierReservation -> Bool)
-> (IdentifierReservation -> IdentifierReservation -> Bool)
-> (IdentifierReservation -> IdentifierReservation -> Bool)
-> (IdentifierReservation
    -> IdentifierReservation -> IdentifierReservation)
-> (IdentifierReservation
    -> IdentifierReservation -> IdentifierReservation)
-> Ord IdentifierReservation
IdentifierReservation -> IdentifierReservation -> Bool
IdentifierReservation -> IdentifierReservation -> Ordering
IdentifierReservation
-> IdentifierReservation -> IdentifierReservation
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 :: IdentifierReservation -> IdentifierReservation -> Ordering
compare :: IdentifierReservation -> IdentifierReservation -> Ordering
$c< :: IdentifierReservation -> IdentifierReservation -> Bool
< :: IdentifierReservation -> IdentifierReservation -> Bool
$c<= :: IdentifierReservation -> IdentifierReservation -> Bool
<= :: IdentifierReservation -> IdentifierReservation -> Bool
$c> :: IdentifierReservation -> IdentifierReservation -> Bool
> :: IdentifierReservation -> IdentifierReservation -> Bool
$c>= :: IdentifierReservation -> IdentifierReservation -> Bool
>= :: IdentifierReservation -> IdentifierReservation -> Bool
$cmax :: IdentifierReservation
-> IdentifierReservation -> IdentifierReservation
max :: IdentifierReservation
-> IdentifierReservation -> IdentifierReservation
$cmin :: IdentifierReservation
-> IdentifierReservation -> IdentifierReservation
min :: IdentifierReservation
-> IdentifierReservation -> IdentifierReservation
Ord, ReadPrec [IdentifierReservation]
ReadPrec IdentifierReservation
Int -> ReadS IdentifierReservation
ReadS [IdentifierReservation]
(Int -> ReadS IdentifierReservation)
-> ReadS [IdentifierReservation]
-> ReadPrec IdentifierReservation
-> ReadPrec [IdentifierReservation]
-> Read IdentifierReservation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IdentifierReservation
readsPrec :: Int -> ReadS IdentifierReservation
$creadList :: ReadS [IdentifierReservation]
readList :: ReadS [IdentifierReservation]
$creadPrec :: ReadPrec IdentifierReservation
readPrec :: ReadPrec IdentifierReservation
$creadListPrec :: ReadPrec [IdentifierReservation]
readListPrec :: ReadPrec [IdentifierReservation]
Read, Int -> IdentifierReservation -> ShowS
[IdentifierReservation] -> ShowS
IdentifierReservation -> String
(Int -> IdentifierReservation -> ShowS)
-> (IdentifierReservation -> String)
-> ([IdentifierReservation] -> ShowS)
-> Show IdentifierReservation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IdentifierReservation -> ShowS
showsPrec :: Int -> IdentifierReservation -> ShowS
$cshow :: IdentifierReservation -> String
show :: IdentifierReservation -> String
$cshowList :: [IdentifierReservation] -> ShowS
showList :: [IdentifierReservation] -> ShowS
Show)
  deriving newtype (Value -> Parser [IdentifierReservation]
Value -> Parser IdentifierReservation
(Value -> Parser IdentifierReservation)
-> (Value -> Parser [IdentifierReservation])
-> FromJSON IdentifierReservation
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser IdentifierReservation
parseJSON :: Value -> Parser IdentifierReservation
$cparseJSONList :: Value -> Parser [IdentifierReservation]
parseJSONList :: Value -> Parser [IdentifierReservation]
A.FromJSON, [IdentifierReservation] -> Value
[IdentifierReservation] -> Encoding
IdentifierReservation -> Value
IdentifierReservation -> Encoding
(IdentifierReservation -> Value)
-> (IdentifierReservation -> Encoding)
-> ([IdentifierReservation] -> Value)
-> ([IdentifierReservation] -> Encoding)
-> ToJSON IdentifierReservation
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: IdentifierReservation -> Value
toJSON :: IdentifierReservation -> Value
$ctoEncoding :: IdentifierReservation -> Encoding
toEncoding :: IdentifierReservation -> Encoding
$ctoJSONList :: [IdentifierReservation] -> Value
toJSONList :: [IdentifierReservation] -> Value
$ctoEncodingList :: [IdentifierReservation] -> Encoding
toEncodingList :: [IdentifierReservation] -> Encoding
A.ToJSON)

instance ToPrettyText IdentifierReservation where
  toPrettyText :: IdentifierReservation -> Text
toPrettyText = (Text
"#" <>) (Text -> Text)
-> (IdentifierReservation -> Text) -> IdentifierReservation -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack (String -> Text)
-> (IdentifierReservation -> String)
-> IdentifierReservation
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> String
forall a. Show a => a -> String
show (Int64 -> String)
-> (IdentifierReservation -> Int64)
-> IdentifierReservation
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IdentifierReservation -> Int64
unIdentifierReservation

deriving via PrettyHtml5ViaPrettyText IdentifierReservation instance ToPrettyHtml5 IdentifierReservation

type StatusReservation :: Type
data StatusReservation
  = MkStatusReservationPlanned
  | MkStatusReservationCancelled
  deriving stock (StatusReservation
StatusReservation -> StatusReservation -> Bounded StatusReservation
forall a. a -> a -> Bounded a
$cminBound :: StatusReservation
minBound :: StatusReservation
$cmaxBound :: StatusReservation
maxBound :: StatusReservation
Bounded, Int -> StatusReservation
StatusReservation -> Int
StatusReservation -> [StatusReservation]
StatusReservation -> StatusReservation
StatusReservation -> StatusReservation -> [StatusReservation]
StatusReservation
-> StatusReservation -> StatusReservation -> [StatusReservation]
(StatusReservation -> StatusReservation)
-> (StatusReservation -> StatusReservation)
-> (Int -> StatusReservation)
-> (StatusReservation -> Int)
-> (StatusReservation -> [StatusReservation])
-> (StatusReservation -> StatusReservation -> [StatusReservation])
-> (StatusReservation -> StatusReservation -> [StatusReservation])
-> (StatusReservation
    -> StatusReservation -> StatusReservation -> [StatusReservation])
-> Enum StatusReservation
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: StatusReservation -> StatusReservation
succ :: StatusReservation -> StatusReservation
$cpred :: StatusReservation -> StatusReservation
pred :: StatusReservation -> StatusReservation
$ctoEnum :: Int -> StatusReservation
toEnum :: Int -> StatusReservation
$cfromEnum :: StatusReservation -> Int
fromEnum :: StatusReservation -> Int
$cenumFrom :: StatusReservation -> [StatusReservation]
enumFrom :: StatusReservation -> [StatusReservation]
$cenumFromThen :: StatusReservation -> StatusReservation -> [StatusReservation]
enumFromThen :: StatusReservation -> StatusReservation -> [StatusReservation]
$cenumFromTo :: StatusReservation -> StatusReservation -> [StatusReservation]
enumFromTo :: StatusReservation -> StatusReservation -> [StatusReservation]
$cenumFromThenTo :: StatusReservation
-> StatusReservation -> StatusReservation -> [StatusReservation]
enumFromThenTo :: StatusReservation
-> StatusReservation -> StatusReservation -> [StatusReservation]
Enum, StatusReservation -> StatusReservation -> Bool
(StatusReservation -> StatusReservation -> Bool)
-> (StatusReservation -> StatusReservation -> Bool)
-> Eq StatusReservation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatusReservation -> StatusReservation -> Bool
== :: StatusReservation -> StatusReservation -> Bool
$c/= :: StatusReservation -> StatusReservation -> Bool
/= :: StatusReservation -> StatusReservation -> Bool
Eq, (forall x. StatusReservation -> Rep StatusReservation x)
-> (forall x. Rep StatusReservation x -> StatusReservation)
-> Generic StatusReservation
forall x. Rep StatusReservation x -> StatusReservation
forall x. StatusReservation -> Rep StatusReservation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. StatusReservation -> Rep StatusReservation x
from :: forall x. StatusReservation -> Rep StatusReservation x
$cto :: forall x. Rep StatusReservation x -> StatusReservation
to :: forall x. Rep StatusReservation x -> StatusReservation
Generic, Eq StatusReservation
Eq StatusReservation =>
(StatusReservation -> StatusReservation -> Ordering)
-> (StatusReservation -> StatusReservation -> Bool)
-> (StatusReservation -> StatusReservation -> Bool)
-> (StatusReservation -> StatusReservation -> Bool)
-> (StatusReservation -> StatusReservation -> Bool)
-> (StatusReservation -> StatusReservation -> StatusReservation)
-> (StatusReservation -> StatusReservation -> StatusReservation)
-> Ord StatusReservation
StatusReservation -> StatusReservation -> Bool
StatusReservation -> StatusReservation -> Ordering
StatusReservation -> StatusReservation -> StatusReservation
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 :: StatusReservation -> StatusReservation -> Ordering
compare :: StatusReservation -> StatusReservation -> Ordering
$c< :: StatusReservation -> StatusReservation -> Bool
< :: StatusReservation -> StatusReservation -> Bool
$c<= :: StatusReservation -> StatusReservation -> Bool
<= :: StatusReservation -> StatusReservation -> Bool
$c> :: StatusReservation -> StatusReservation -> Bool
> :: StatusReservation -> StatusReservation -> Bool
$c>= :: StatusReservation -> StatusReservation -> Bool
>= :: StatusReservation -> StatusReservation -> Bool
$cmax :: StatusReservation -> StatusReservation -> StatusReservation
max :: StatusReservation -> StatusReservation -> StatusReservation
$cmin :: StatusReservation -> StatusReservation -> StatusReservation
min :: StatusReservation -> StatusReservation -> StatusReservation
Ord, ReadPrec [StatusReservation]
ReadPrec StatusReservation
Int -> ReadS StatusReservation
ReadS [StatusReservation]
(Int -> ReadS StatusReservation)
-> ReadS [StatusReservation]
-> ReadPrec StatusReservation
-> ReadPrec [StatusReservation]
-> Read StatusReservation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StatusReservation
readsPrec :: Int -> ReadS StatusReservation
$creadList :: ReadS [StatusReservation]
readList :: ReadS [StatusReservation]
$creadPrec :: ReadPrec StatusReservation
readPrec :: ReadPrec StatusReservation
$creadListPrec :: ReadPrec [StatusReservation]
readListPrec :: ReadPrec [StatusReservation]
Read, Int -> StatusReservation -> ShowS
[StatusReservation] -> ShowS
StatusReservation -> String
(Int -> StatusReservation -> ShowS)
-> (StatusReservation -> String)
-> ([StatusReservation] -> ShowS)
-> Show StatusReservation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StatusReservation -> ShowS
showsPrec :: Int -> StatusReservation -> ShowS
$cshow :: StatusReservation -> String
show :: StatusReservation -> String
$cshowList :: [StatusReservation] -> ShowS
showList :: [StatusReservation] -> ShowS
Show)
  deriving
    (Value -> Parser [StatusReservation]
Value -> Parser StatusReservation
(Value -> Parser StatusReservation)
-> (Value -> Parser [StatusReservation])
-> FromJSON StatusReservation
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser StatusReservation
parseJSON :: Value -> Parser StatusReservation
$cparseJSONList :: Value -> Parser [StatusReservation]
parseJSONList :: Value -> Parser [StatusReservation]
A.FromJSON, [StatusReservation] -> Value
[StatusReservation] -> Encoding
StatusReservation -> Value
StatusReservation -> Encoding
(StatusReservation -> Value)
-> (StatusReservation -> Encoding)
-> ([StatusReservation] -> Value)
-> ([StatusReservation] -> Encoding)
-> ToJSON StatusReservation
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: StatusReservation -> Value
toJSON :: StatusReservation -> Value
$ctoEncoding :: StatusReservation -> Encoding
toEncoding :: StatusReservation -> Encoding
$ctoJSONList :: [StatusReservation] -> Value
toJSONList :: [StatusReservation] -> Value
$ctoEncodingList :: [StatusReservation] -> Encoding
toEncodingList :: [StatusReservation] -> Encoding
A.ToJSON)
    via A.CustomJSON (JSONSettings "MkStatusReservation" "") StatusReservation

type Interval :: Type -> Type
data Interval a = MkIntervalUnsafe
  { forall a. Interval a -> a
intervalStart :: a
  , forall a. Interval a -> a
intervalEnd :: a
  }
  deriving stock (Interval a -> Interval a -> Bool
(Interval a -> Interval a -> Bool)
-> (Interval a -> Interval a -> Bool) -> Eq (Interval a)
forall a. Eq a => Interval a -> Interval a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Interval a -> Interval a -> Bool
== :: Interval a -> Interval a -> Bool
$c/= :: forall a. Eq a => Interval a -> Interval a -> Bool
/= :: Interval a -> Interval a -> Bool
Eq, (forall x. Interval a -> Rep (Interval a) x)
-> (forall x. Rep (Interval a) x -> Interval a)
-> Generic (Interval a)
forall x. Rep (Interval a) x -> Interval a
forall x. Interval a -> Rep (Interval a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Interval a) x -> Interval a
forall a x. Interval a -> Rep (Interval a) x
$cfrom :: forall a x. Interval a -> Rep (Interval a) x
from :: forall x. Interval a -> Rep (Interval a) x
$cto :: forall a x. Rep (Interval a) x -> Interval a
to :: forall x. Rep (Interval a) x -> Interval a
Generic, Eq (Interval a)
Eq (Interval a) =>
(Interval a -> Interval a -> Ordering)
-> (Interval a -> Interval a -> Bool)
-> (Interval a -> Interval a -> Bool)
-> (Interval a -> Interval a -> Bool)
-> (Interval a -> Interval a -> Bool)
-> (Interval a -> Interval a -> Interval a)
-> (Interval a -> Interval a -> Interval a)
-> Ord (Interval a)
Interval a -> Interval a -> Bool
Interval a -> Interval a -> Ordering
Interval a -> Interval a -> Interval a
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
forall a. Ord a => Eq (Interval a)
forall a. Ord a => Interval a -> Interval a -> Bool
forall a. Ord a => Interval a -> Interval a -> Ordering
forall a. Ord a => Interval a -> Interval a -> Interval a
$ccompare :: forall a. Ord a => Interval a -> Interval a -> Ordering
compare :: Interval a -> Interval a -> Ordering
$c< :: forall a. Ord a => Interval a -> Interval a -> Bool
< :: Interval a -> Interval a -> Bool
$c<= :: forall a. Ord a => Interval a -> Interval a -> Bool
<= :: Interval a -> Interval a -> Bool
$c> :: forall a. Ord a => Interval a -> Interval a -> Bool
> :: Interval a -> Interval a -> Bool
$c>= :: forall a. Ord a => Interval a -> Interval a -> Bool
>= :: Interval a -> Interval a -> Bool
$cmax :: forall a. Ord a => Interval a -> Interval a -> Interval a
max :: Interval a -> Interval a -> Interval a
$cmin :: forall a. Ord a => Interval a -> Interval a -> Interval a
min :: Interval a -> Interval a -> Interval a
Ord, ReadPrec [Interval a]
ReadPrec (Interval a)
Int -> ReadS (Interval a)
ReadS [Interval a]
(Int -> ReadS (Interval a))
-> ReadS [Interval a]
-> ReadPrec (Interval a)
-> ReadPrec [Interval a]
-> Read (Interval a)
forall a. Read a => ReadPrec [Interval a]
forall a. Read a => ReadPrec (Interval a)
forall a. Read a => Int -> ReadS (Interval a)
forall a. Read a => ReadS [Interval a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (Interval a)
readsPrec :: Int -> ReadS (Interval a)
$creadList :: forall a. Read a => ReadS [Interval a]
readList :: ReadS [Interval a]
$creadPrec :: forall a. Read a => ReadPrec (Interval a)
readPrec :: ReadPrec (Interval a)
$creadListPrec :: forall a. Read a => ReadPrec [Interval a]
readListPrec :: ReadPrec [Interval a]
Read, Int -> Interval a -> ShowS
[Interval a] -> ShowS
Interval a -> String
(Int -> Interval a -> ShowS)
-> (Interval a -> String)
-> ([Interval a] -> ShowS)
-> Show (Interval a)
forall a. Show a => Int -> Interval a -> ShowS
forall a. Show a => [Interval a] -> ShowS
forall a. Show a => Interval a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Interval a -> ShowS
showsPrec :: Int -> Interval a -> ShowS
$cshow :: forall a. Show a => Interval a -> String
show :: Interval a -> String
$cshowList :: forall a. Show a => [Interval a] -> ShowS
showList :: [Interval a] -> ShowS
Show)

instance (A.FromJSON a, Ord a) => A.FromJSON (Interval a) where
  parseJSON :: Value -> Parser (Interval a)
parseJSON Value
value = do
    A.CustomJSON Interval a
intervalUnsafe <- forall a. FromJSON a => Value -> Parser a
A.parseJSON @(A.CustomJSON (JSONSettings "Mk" "interval") (Interval a)) Value
value
    case a -> a -> Maybe (Interval a)
forall a. Ord a => a -> a -> Maybe (Interval a)
mkInterval (Interval a -> a
forall a. Interval a -> a
intervalStart Interval a
intervalUnsafe) (Interval a -> a
forall a. Interval a -> a
intervalEnd Interval a
intervalUnsafe) of
      Maybe (Interval a)
Nothing -> String -> Parser (Interval a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"expected ordered interval, but encountered boundaries in the wrong order"
      Just Interval a
interval -> Interval a -> Parser (Interval a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Interval a
interval
deriving via A.CustomJSON (JSONSettings "Mk" "interval") (Interval a) instance A.ToJSON a => A.ToJSON (Interval a)

mkInterval :: Ord a => a -> a -> Maybe (Interval a)
mkInterval :: forall a. Ord a => a -> a -> Maybe (Interval a)
mkInterval a
intervalStart a
intervalEnd =
  if a
intervalStart a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<= a
intervalEnd
    then Interval a -> Maybe (Interval a)
forall a. a -> Maybe a
Just MkIntervalUnsafe {a
intervalStart :: a
intervalStart :: a
intervalStart, a
intervalEnd :: a
intervalEnd :: a
intervalEnd}
    else Maybe (Interval a)
forall a. Maybe a
Nothing

mkIntervalFromNonDegenerate :: IntervalNonDegenerate a -> Interval a
mkIntervalFromNonDegenerate :: forall a. IntervalNonDegenerate a -> Interval a
mkIntervalFromNonDegenerate = IntervalNonDegenerate a -> Interval a
forall a. IntervalNonDegenerate a -> Interval a
unIntervalNonDegenerate

intervalIsDegenerate :: Ord a => Interval a -> Bool
intervalIsDegenerate :: forall a. Ord a => Interval a -> Bool
intervalIsDegenerate Interval a
interval = Interval a -> a
forall a. Interval a -> a
intervalStart Interval a
interval a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== Interval a -> a
forall a. Interval a -> a
intervalEnd Interval a
interval

type IntervalNonDegenerate :: Type -> Type
newtype IntervalNonDegenerate a = MkIntervalNonDegenerateUnsafe {forall a. IntervalNonDegenerate a -> Interval a
unIntervalNonDegenerate :: Interval a}
  deriving stock (IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
(IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool)
-> (IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool)
-> Eq (IntervalNonDegenerate a)
forall a.
Eq a =>
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
== :: IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
$c/= :: forall a.
Eq a =>
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
/= :: IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
Eq, (forall x.
 IntervalNonDegenerate a -> Rep (IntervalNonDegenerate a) x)
-> (forall x.
    Rep (IntervalNonDegenerate a) x -> IntervalNonDegenerate a)
-> Generic (IntervalNonDegenerate a)
forall x.
Rep (IntervalNonDegenerate a) x -> IntervalNonDegenerate a
forall x.
IntervalNonDegenerate a -> Rep (IntervalNonDegenerate a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x.
Rep (IntervalNonDegenerate a) x -> IntervalNonDegenerate a
forall a x.
IntervalNonDegenerate a -> Rep (IntervalNonDegenerate a) x
$cfrom :: forall a x.
IntervalNonDegenerate a -> Rep (IntervalNonDegenerate a) x
from :: forall x.
IntervalNonDegenerate a -> Rep (IntervalNonDegenerate a) x
$cto :: forall a x.
Rep (IntervalNonDegenerate a) x -> IntervalNonDegenerate a
to :: forall x.
Rep (IntervalNonDegenerate a) x -> IntervalNonDegenerate a
Generic, Eq (IntervalNonDegenerate a)
Eq (IntervalNonDegenerate a) =>
(IntervalNonDegenerate a -> IntervalNonDegenerate a -> Ordering)
-> (IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool)
-> (IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool)
-> (IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool)
-> (IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool)
-> (IntervalNonDegenerate a
    -> IntervalNonDegenerate a -> IntervalNonDegenerate a)
-> (IntervalNonDegenerate a
    -> IntervalNonDegenerate a -> IntervalNonDegenerate a)
-> Ord (IntervalNonDegenerate a)
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Ordering
IntervalNonDegenerate a
-> IntervalNonDegenerate a -> IntervalNonDegenerate a
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
forall a. Ord a => Eq (IntervalNonDegenerate a)
forall a.
Ord a =>
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
forall a.
Ord a =>
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Ordering
forall a.
Ord a =>
IntervalNonDegenerate a
-> IntervalNonDegenerate a -> IntervalNonDegenerate a
$ccompare :: forall a.
Ord a =>
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Ordering
compare :: IntervalNonDegenerate a -> IntervalNonDegenerate a -> Ordering
$c< :: forall a.
Ord a =>
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
< :: IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
$c<= :: forall a.
Ord a =>
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
<= :: IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
$c> :: forall a.
Ord a =>
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
> :: IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
$c>= :: forall a.
Ord a =>
IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
>= :: IntervalNonDegenerate a -> IntervalNonDegenerate a -> Bool
$cmax :: forall a.
Ord a =>
IntervalNonDegenerate a
-> IntervalNonDegenerate a -> IntervalNonDegenerate a
max :: IntervalNonDegenerate a
-> IntervalNonDegenerate a -> IntervalNonDegenerate a
$cmin :: forall a.
Ord a =>
IntervalNonDegenerate a
-> IntervalNonDegenerate a -> IntervalNonDegenerate a
min :: IntervalNonDegenerate a
-> IntervalNonDegenerate a -> IntervalNonDegenerate a
Ord, ReadPrec [IntervalNonDegenerate a]
ReadPrec (IntervalNonDegenerate a)
Int -> ReadS (IntervalNonDegenerate a)
ReadS [IntervalNonDegenerate a]
(Int -> ReadS (IntervalNonDegenerate a))
-> ReadS [IntervalNonDegenerate a]
-> ReadPrec (IntervalNonDegenerate a)
-> ReadPrec [IntervalNonDegenerate a]
-> Read (IntervalNonDegenerate a)
forall a. Read a => ReadPrec [IntervalNonDegenerate a]
forall a. Read a => ReadPrec (IntervalNonDegenerate a)
forall a. Read a => Int -> ReadS (IntervalNonDegenerate a)
forall a. Read a => ReadS [IntervalNonDegenerate a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (IntervalNonDegenerate a)
readsPrec :: Int -> ReadS (IntervalNonDegenerate a)
$creadList :: forall a. Read a => ReadS [IntervalNonDegenerate a]
readList :: ReadS [IntervalNonDegenerate a]
$creadPrec :: forall a. Read a => ReadPrec (IntervalNonDegenerate a)
readPrec :: ReadPrec (IntervalNonDegenerate a)
$creadListPrec :: forall a. Read a => ReadPrec [IntervalNonDegenerate a]
readListPrec :: ReadPrec [IntervalNonDegenerate a]
Read, Int -> IntervalNonDegenerate a -> ShowS
[IntervalNonDegenerate a] -> ShowS
IntervalNonDegenerate a -> String
(Int -> IntervalNonDegenerate a -> ShowS)
-> (IntervalNonDegenerate a -> String)
-> ([IntervalNonDegenerate a] -> ShowS)
-> Show (IntervalNonDegenerate a)
forall a. Show a => Int -> IntervalNonDegenerate a -> ShowS
forall a. Show a => [IntervalNonDegenerate a] -> ShowS
forall a. Show a => IntervalNonDegenerate a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> IntervalNonDegenerate a -> ShowS
showsPrec :: Int -> IntervalNonDegenerate a -> ShowS
$cshow :: forall a. Show a => IntervalNonDegenerate a -> String
show :: IntervalNonDegenerate a -> String
$cshowList :: forall a. Show a => [IntervalNonDegenerate a] -> ShowS
showList :: [IntervalNonDegenerate a] -> ShowS
Show)

instance (A.FromJSON a, Ord a) => A.FromJSON (IntervalNonDegenerate a) where
  parseJSON :: Value -> Parser (IntervalNonDegenerate a)
parseJSON Value
value = do
    Interval a
interval <- Value -> Parser (Interval a)
forall a. FromJSON a => Value -> Parser a
A.parseJSON Value
value
    if Interval a -> Bool
forall a. Ord a => Interval a -> Bool
intervalIsDegenerate Interval a
interval
      then String -> Parser (IntervalNonDegenerate a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"expected non-degenerate interval, but boundaries are equal"
      else IntervalNonDegenerate a -> Parser (IntervalNonDegenerate a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (IntervalNonDegenerate a -> Parser (IntervalNonDegenerate a))
-> IntervalNonDegenerate a -> Parser (IntervalNonDegenerate a)
forall a b. (a -> b) -> a -> b
$ Interval a -> IntervalNonDegenerate a
forall a. Interval a -> IntervalNonDegenerate a
MkIntervalNonDegenerateUnsafe Interval a
interval
deriving newtype instance A.ToJSON a => A.ToJSON (IntervalNonDegenerate a)

type IntervalUnbounded :: Type -> Type
data IntervalUnbounded a = MkIntervalUnboundedUnsafe
  { forall a. IntervalUnbounded a -> MaybeUnboundedLow a
intervalUnboundedStart :: MaybeUnboundedLow a
  , forall a. IntervalUnbounded a -> MaybeUnboundedHigh a
intervalUnboundedEnd :: MaybeUnboundedHigh a
  }
  deriving stock (IntervalUnbounded a -> IntervalUnbounded a -> Bool
(IntervalUnbounded a -> IntervalUnbounded a -> Bool)
-> (IntervalUnbounded a -> IntervalUnbounded a -> Bool)
-> Eq (IntervalUnbounded a)
forall a.
Eq a =>
IntervalUnbounded a -> IntervalUnbounded a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
IntervalUnbounded a -> IntervalUnbounded a -> Bool
== :: IntervalUnbounded a -> IntervalUnbounded a -> Bool
$c/= :: forall a.
Eq a =>
IntervalUnbounded a -> IntervalUnbounded a -> Bool
/= :: IntervalUnbounded a -> IntervalUnbounded a -> Bool
Eq, (forall x. IntervalUnbounded a -> Rep (IntervalUnbounded a) x)
-> (forall x. Rep (IntervalUnbounded a) x -> IntervalUnbounded a)
-> Generic (IntervalUnbounded a)
forall x. Rep (IntervalUnbounded a) x -> IntervalUnbounded a
forall x. IntervalUnbounded a -> Rep (IntervalUnbounded a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (IntervalUnbounded a) x -> IntervalUnbounded a
forall a x. IntervalUnbounded a -> Rep (IntervalUnbounded a) x
$cfrom :: forall a x. IntervalUnbounded a -> Rep (IntervalUnbounded a) x
from :: forall x. IntervalUnbounded a -> Rep (IntervalUnbounded a) x
$cto :: forall a x. Rep (IntervalUnbounded a) x -> IntervalUnbounded a
to :: forall x. Rep (IntervalUnbounded a) x -> IntervalUnbounded a
Generic, Eq (IntervalUnbounded a)
Eq (IntervalUnbounded a) =>
(IntervalUnbounded a -> IntervalUnbounded a -> Ordering)
-> (IntervalUnbounded a -> IntervalUnbounded a -> Bool)
-> (IntervalUnbounded a -> IntervalUnbounded a -> Bool)
-> (IntervalUnbounded a -> IntervalUnbounded a -> Bool)
-> (IntervalUnbounded a -> IntervalUnbounded a -> Bool)
-> (IntervalUnbounded a
    -> IntervalUnbounded a -> IntervalUnbounded a)
-> (IntervalUnbounded a
    -> IntervalUnbounded a -> IntervalUnbounded a)
-> Ord (IntervalUnbounded a)
IntervalUnbounded a -> IntervalUnbounded a -> Bool
IntervalUnbounded a -> IntervalUnbounded a -> Ordering
IntervalUnbounded a -> IntervalUnbounded a -> IntervalUnbounded a
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
forall a. Ord a => Eq (IntervalUnbounded a)
forall a.
Ord a =>
IntervalUnbounded a -> IntervalUnbounded a -> Bool
forall a.
Ord a =>
IntervalUnbounded a -> IntervalUnbounded a -> Ordering
forall a.
Ord a =>
IntervalUnbounded a -> IntervalUnbounded a -> IntervalUnbounded a
$ccompare :: forall a.
Ord a =>
IntervalUnbounded a -> IntervalUnbounded a -> Ordering
compare :: IntervalUnbounded a -> IntervalUnbounded a -> Ordering
$c< :: forall a.
Ord a =>
IntervalUnbounded a -> IntervalUnbounded a -> Bool
< :: IntervalUnbounded a -> IntervalUnbounded a -> Bool
$c<= :: forall a.
Ord a =>
IntervalUnbounded a -> IntervalUnbounded a -> Bool
<= :: IntervalUnbounded a -> IntervalUnbounded a -> Bool
$c> :: forall a.
Ord a =>
IntervalUnbounded a -> IntervalUnbounded a -> Bool
> :: IntervalUnbounded a -> IntervalUnbounded a -> Bool
$c>= :: forall a.
Ord a =>
IntervalUnbounded a -> IntervalUnbounded a -> Bool
>= :: IntervalUnbounded a -> IntervalUnbounded a -> Bool
$cmax :: forall a.
Ord a =>
IntervalUnbounded a -> IntervalUnbounded a -> IntervalUnbounded a
max :: IntervalUnbounded a -> IntervalUnbounded a -> IntervalUnbounded a
$cmin :: forall a.
Ord a =>
IntervalUnbounded a -> IntervalUnbounded a -> IntervalUnbounded a
min :: IntervalUnbounded a -> IntervalUnbounded a -> IntervalUnbounded a
Ord, ReadPrec [IntervalUnbounded a]
ReadPrec (IntervalUnbounded a)
Int -> ReadS (IntervalUnbounded a)
ReadS [IntervalUnbounded a]
(Int -> ReadS (IntervalUnbounded a))
-> ReadS [IntervalUnbounded a]
-> ReadPrec (IntervalUnbounded a)
-> ReadPrec [IntervalUnbounded a]
-> Read (IntervalUnbounded a)
forall a. Read a => ReadPrec [IntervalUnbounded a]
forall a. Read a => ReadPrec (IntervalUnbounded a)
forall a. Read a => Int -> ReadS (IntervalUnbounded a)
forall a. Read a => ReadS [IntervalUnbounded a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (IntervalUnbounded a)
readsPrec :: Int -> ReadS (IntervalUnbounded a)
$creadList :: forall a. Read a => ReadS [IntervalUnbounded a]
readList :: ReadS [IntervalUnbounded a]
$creadPrec :: forall a. Read a => ReadPrec (IntervalUnbounded a)
readPrec :: ReadPrec (IntervalUnbounded a)
$creadListPrec :: forall a. Read a => ReadPrec [IntervalUnbounded a]
readListPrec :: ReadPrec [IntervalUnbounded a]
Read, Int -> IntervalUnbounded a -> ShowS
[IntervalUnbounded a] -> ShowS
IntervalUnbounded a -> String
(Int -> IntervalUnbounded a -> ShowS)
-> (IntervalUnbounded a -> String)
-> ([IntervalUnbounded a] -> ShowS)
-> Show (IntervalUnbounded a)
forall a. Show a => Int -> IntervalUnbounded a -> ShowS
forall a. Show a => [IntervalUnbounded a] -> ShowS
forall a. Show a => IntervalUnbounded a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> IntervalUnbounded a -> ShowS
showsPrec :: Int -> IntervalUnbounded a -> ShowS
$cshow :: forall a. Show a => IntervalUnbounded a -> String
show :: IntervalUnbounded a -> String
$cshowList :: forall a. Show a => [IntervalUnbounded a] -> ShowS
showList :: [IntervalUnbounded a] -> ShowS
Show)

instance (A.FromJSON a, Ord a) => A.FromJSON (IntervalUnbounded a) where
  parseJSON :: Value -> Parser (IntervalUnbounded a)
parseJSON Value
value = do
    A.CustomJSON Interval (Maybe a)
intervalUnsafe <- forall a. FromJSON a => Value -> Parser a
A.parseJSON @(A.CustomJSON (JSONSettings "Mk" "interval") (Interval (Maybe a))) Value
value
    let
      low :: MaybeUnboundedLow a
low = MaybeUnboundedLow a
-> (a -> MaybeUnboundedLow a) -> Maybe a -> MaybeUnboundedLow a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe MaybeUnboundedLow a
forall a. MaybeUnboundedLow a
NothingUnboundedLow a -> MaybeUnboundedLow a
forall a. a -> MaybeUnboundedLow a
JustUnboundedLow (Maybe a -> MaybeUnboundedLow a) -> Maybe a -> MaybeUnboundedLow a
forall a b. (a -> b) -> a -> b
$ Interval (Maybe a) -> Maybe a
forall a. Interval a -> a
intervalStart Interval (Maybe a)
intervalUnsafe
      high :: MaybeUnboundedHigh a
high = MaybeUnboundedHigh a
-> (a -> MaybeUnboundedHigh a) -> Maybe a -> MaybeUnboundedHigh a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe MaybeUnboundedHigh a
forall a. MaybeUnboundedHigh a
NothingUnboundedHigh a -> MaybeUnboundedHigh a
forall a. a -> MaybeUnboundedHigh a
JustUnboundedHigh (Maybe a -> MaybeUnboundedHigh a)
-> Maybe a -> MaybeUnboundedHigh a
forall a b. (a -> b) -> a -> b
$ Interval (Maybe a) -> Maybe a
forall a. Interval a -> a
intervalEnd Interval (Maybe a)
intervalUnsafe
    case MaybeUnboundedLow a
-> MaybeUnboundedHigh a -> Maybe (IntervalUnbounded a)
forall a.
Ord a =>
MaybeUnboundedLow a
-> MaybeUnboundedHigh a -> Maybe (IntervalUnbounded a)
mkIntervalUnbounded MaybeUnboundedLow a
low MaybeUnboundedHigh a
high of
      Maybe (IntervalUnbounded a)
Nothing -> String -> Parser (IntervalUnbounded a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"expected ordered (potentially unbounded) interval, but encountered boundaries in the wrong order"
      Just IntervalUnbounded a
interval -> IntervalUnbounded a -> Parser (IntervalUnbounded a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure IntervalUnbounded a
interval
instance A.ToJSON a => A.ToJSON (IntervalUnbounded a) where
  toJSON :: IntervalUnbounded a -> Value
toJSON IntervalUnbounded a
value =
    Interval (Maybe a) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (Interval (Maybe a) -> Value) -> Interval (Maybe a) -> Value
forall a b. (a -> b) -> a -> b
$
      MkIntervalUnsafe
        { intervalStart :: Maybe a
intervalStart =
            case IntervalUnbounded a -> MaybeUnboundedLow a
forall a. IntervalUnbounded a -> MaybeUnboundedLow a
intervalUnboundedStart IntervalUnbounded a
value of
              MaybeUnboundedLow a
NothingUnboundedLow -> Maybe a
forall a. Maybe a
Nothing
              JustUnboundedLow a
x -> a -> Maybe a
forall a. a -> Maybe a
Just a
x
        , intervalEnd :: Maybe a
intervalEnd =
            case IntervalUnbounded a -> MaybeUnboundedHigh a
forall a. IntervalUnbounded a -> MaybeUnboundedHigh a
intervalUnboundedEnd IntervalUnbounded a
value of
              MaybeUnboundedHigh a
NothingUnboundedHigh -> Maybe a
forall a. Maybe a
Nothing
              JustUnboundedHigh a
x -> a -> Maybe a
forall a. a -> Maybe a
Just a
x
        }

mkIntervalUnbounded :: Ord a => MaybeUnboundedLow a -> MaybeUnboundedHigh a -> Maybe (IntervalUnbounded a)
mkIntervalUnbounded :: forall a.
Ord a =>
MaybeUnboundedLow a
-> MaybeUnboundedHigh a -> Maybe (IntervalUnbounded a)
mkIntervalUnbounded MaybeUnboundedLow a
intervalUnboundedStart MaybeUnboundedHigh a
intervalUnboundedEnd =
  if MaybeUnboundedLow a -> MaybeUnbounded a
forall a. MaybeUnboundedLow a -> MaybeUnbounded a
MkMaybeUnboundedLow MaybeUnboundedLow a
intervalUnboundedStart MaybeUnbounded a -> MaybeUnbounded a -> Bool
forall a. Ord a => a -> a -> Bool
<= MaybeUnboundedHigh a -> MaybeUnbounded a
forall a. MaybeUnboundedHigh a -> MaybeUnbounded a
MkMaybeUnboundedHigh MaybeUnboundedHigh a
intervalUnboundedEnd
    then IntervalUnbounded a -> Maybe (IntervalUnbounded a)
forall a. a -> Maybe a
Just MkIntervalUnboundedUnsafe {MaybeUnboundedLow a
intervalUnboundedStart :: MaybeUnboundedLow a
intervalUnboundedStart :: MaybeUnboundedLow a
intervalUnboundedStart, MaybeUnboundedHigh a
intervalUnboundedEnd :: MaybeUnboundedHigh a
intervalUnboundedEnd :: MaybeUnboundedHigh a
intervalUnboundedEnd}
    else Maybe (IntervalUnbounded a)
forall a. Maybe a
Nothing

mkIntervalUnboundedFromBounded :: Interval a -> IntervalUnbounded a
mkIntervalUnboundedFromBounded :: forall a. Interval a -> IntervalUnbounded a
mkIntervalUnboundedFromBounded Interval a
interval =
  MkIntervalUnboundedUnsafe
    { intervalUnboundedStart :: MaybeUnboundedLow a
intervalUnboundedStart = a -> MaybeUnboundedLow a
forall a. a -> MaybeUnboundedLow a
JustUnboundedLow (a -> MaybeUnboundedLow a) -> a -> MaybeUnboundedLow a
forall a b. (a -> b) -> a -> b
$ Interval a -> a
forall a. Interval a -> a
intervalStart Interval a
interval
    , intervalUnboundedEnd :: MaybeUnboundedHigh a
intervalUnboundedEnd = a -> MaybeUnboundedHigh a
forall a. a -> MaybeUnboundedHigh a
JustUnboundedHigh (a -> MaybeUnboundedHigh a) -> a -> MaybeUnboundedHigh a
forall a b. (a -> b) -> a -> b
$ Interval a -> a
forall a. Interval a -> a
intervalEnd Interval a
interval
    }

unbounded :: IntervalUnbounded a
unbounded :: forall a. IntervalUnbounded a
unbounded =
  MkIntervalUnboundedUnsafe
    { intervalUnboundedStart :: MaybeUnboundedLow a
intervalUnboundedStart = MaybeUnboundedLow a
forall a. MaybeUnboundedLow a
NothingUnboundedLow
    , intervalUnboundedEnd :: MaybeUnboundedHigh a
intervalUnboundedEnd = MaybeUnboundedHigh a
forall a. MaybeUnboundedHigh a
NothingUnboundedHigh
    }

intervalUnboundedIsDegenerate :: Ord a => IntervalUnbounded a -> Bool
intervalUnboundedIsDegenerate :: forall a. Ord a => IntervalUnbounded a -> Bool
intervalUnboundedIsDegenerate IntervalUnbounded a
intervalUnbounded = MaybeUnboundedLow a -> MaybeUnbounded a
forall a. MaybeUnboundedLow a -> MaybeUnbounded a
MkMaybeUnboundedLow (IntervalUnbounded a -> MaybeUnboundedLow a
forall a. IntervalUnbounded a -> MaybeUnboundedLow a
intervalUnboundedStart IntervalUnbounded a
intervalUnbounded) MaybeUnbounded a -> MaybeUnbounded a -> Bool
forall a. Eq a => a -> a -> Bool
== MaybeUnboundedHigh a -> MaybeUnbounded a
forall a. MaybeUnboundedHigh a -> MaybeUnbounded a
MkMaybeUnboundedHigh (IntervalUnbounded a -> MaybeUnboundedHigh a
forall a. IntervalUnbounded a -> MaybeUnboundedHigh a
intervalUnboundedEnd IntervalUnbounded a
intervalUnbounded)

type IntervalUnboundedNonDegenerate :: Type -> Type
newtype IntervalUnboundedNonDegenerate a = MkIntervalUnboundedNonDegenerateUnsafe {forall a. IntervalUnboundedNonDegenerate a -> IntervalUnbounded a
unIntervalUnboundedNonDegenerate :: IntervalUnbounded a}
  deriving stock (IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
(IntervalUnboundedNonDegenerate a
 -> IntervalUnboundedNonDegenerate a -> Bool)
-> (IntervalUnboundedNonDegenerate a
    -> IntervalUnboundedNonDegenerate a -> Bool)
-> Eq (IntervalUnboundedNonDegenerate a)
forall a.
Eq a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
== :: IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
$c/= :: forall a.
Eq a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
/= :: IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
Eq, (forall x.
 IntervalUnboundedNonDegenerate a
 -> Rep (IntervalUnboundedNonDegenerate a) x)
-> (forall x.
    Rep (IntervalUnboundedNonDegenerate a) x
    -> IntervalUnboundedNonDegenerate a)
-> Generic (IntervalUnboundedNonDegenerate a)
forall x.
Rep (IntervalUnboundedNonDegenerate a) x
-> IntervalUnboundedNonDegenerate a
forall x.
IntervalUnboundedNonDegenerate a
-> Rep (IntervalUnboundedNonDegenerate a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x.
Rep (IntervalUnboundedNonDegenerate a) x
-> IntervalUnboundedNonDegenerate a
forall a x.
IntervalUnboundedNonDegenerate a
-> Rep (IntervalUnboundedNonDegenerate a) x
$cfrom :: forall a x.
IntervalUnboundedNonDegenerate a
-> Rep (IntervalUnboundedNonDegenerate a) x
from :: forall x.
IntervalUnboundedNonDegenerate a
-> Rep (IntervalUnboundedNonDegenerate a) x
$cto :: forall a x.
Rep (IntervalUnboundedNonDegenerate a) x
-> IntervalUnboundedNonDegenerate a
to :: forall x.
Rep (IntervalUnboundedNonDegenerate a) x
-> IntervalUnboundedNonDegenerate a
Generic, Eq (IntervalUnboundedNonDegenerate a)
Eq (IntervalUnboundedNonDegenerate a) =>
(IntervalUnboundedNonDegenerate a
 -> IntervalUnboundedNonDegenerate a -> Ordering)
-> (IntervalUnboundedNonDegenerate a
    -> IntervalUnboundedNonDegenerate a -> Bool)
-> (IntervalUnboundedNonDegenerate a
    -> IntervalUnboundedNonDegenerate a -> Bool)
-> (IntervalUnboundedNonDegenerate a
    -> IntervalUnboundedNonDegenerate a -> Bool)
-> (IntervalUnboundedNonDegenerate a
    -> IntervalUnboundedNonDegenerate a -> Bool)
-> (IntervalUnboundedNonDegenerate a
    -> IntervalUnboundedNonDegenerate a
    -> IntervalUnboundedNonDegenerate a)
-> (IntervalUnboundedNonDegenerate a
    -> IntervalUnboundedNonDegenerate a
    -> IntervalUnboundedNonDegenerate a)
-> Ord (IntervalUnboundedNonDegenerate a)
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Ordering
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
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
forall a. Ord a => Eq (IntervalUnboundedNonDegenerate a)
forall a.
Ord a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
forall a.
Ord a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Ordering
forall a.
Ord a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
$ccompare :: forall a.
Ord a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Ordering
compare :: IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Ordering
$c< :: forall a.
Ord a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
< :: IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
$c<= :: forall a.
Ord a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
<= :: IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
$c> :: forall a.
Ord a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
> :: IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
$c>= :: forall a.
Ord a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
>= :: IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a -> Bool
$cmax :: forall a.
Ord a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
max :: IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
$cmin :: forall a.
Ord a =>
IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
min :: IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
-> IntervalUnboundedNonDegenerate a
Ord, ReadPrec [IntervalUnboundedNonDegenerate a]
ReadPrec (IntervalUnboundedNonDegenerate a)
Int -> ReadS (IntervalUnboundedNonDegenerate a)
ReadS [IntervalUnboundedNonDegenerate a]
(Int -> ReadS (IntervalUnboundedNonDegenerate a))
-> ReadS [IntervalUnboundedNonDegenerate a]
-> ReadPrec (IntervalUnboundedNonDegenerate a)
-> ReadPrec [IntervalUnboundedNonDegenerate a]
-> Read (IntervalUnboundedNonDegenerate a)
forall a. Read a => ReadPrec [IntervalUnboundedNonDegenerate a]
forall a. Read a => ReadPrec (IntervalUnboundedNonDegenerate a)
forall a. Read a => Int -> ReadS (IntervalUnboundedNonDegenerate a)
forall a. Read a => ReadS [IntervalUnboundedNonDegenerate a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (IntervalUnboundedNonDegenerate a)
readsPrec :: Int -> ReadS (IntervalUnboundedNonDegenerate a)
$creadList :: forall a. Read a => ReadS [IntervalUnboundedNonDegenerate a]
readList :: ReadS [IntervalUnboundedNonDegenerate a]
$creadPrec :: forall a. Read a => ReadPrec (IntervalUnboundedNonDegenerate a)
readPrec :: ReadPrec (IntervalUnboundedNonDegenerate a)
$creadListPrec :: forall a. Read a => ReadPrec [IntervalUnboundedNonDegenerate a]
readListPrec :: ReadPrec [IntervalUnboundedNonDegenerate a]
Read, Int -> IntervalUnboundedNonDegenerate a -> ShowS
[IntervalUnboundedNonDegenerate a] -> ShowS
IntervalUnboundedNonDegenerate a -> String
(Int -> IntervalUnboundedNonDegenerate a -> ShowS)
-> (IntervalUnboundedNonDegenerate a -> String)
-> ([IntervalUnboundedNonDegenerate a] -> ShowS)
-> Show (IntervalUnboundedNonDegenerate a)
forall a.
Show a =>
Int -> IntervalUnboundedNonDegenerate a -> ShowS
forall a. Show a => [IntervalUnboundedNonDegenerate a] -> ShowS
forall a. Show a => IntervalUnboundedNonDegenerate a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a.
Show a =>
Int -> IntervalUnboundedNonDegenerate a -> ShowS
showsPrec :: Int -> IntervalUnboundedNonDegenerate a -> ShowS
$cshow :: forall a. Show a => IntervalUnboundedNonDegenerate a -> String
show :: IntervalUnboundedNonDegenerate a -> String
$cshowList :: forall a. Show a => [IntervalUnboundedNonDegenerate a] -> ShowS
showList :: [IntervalUnboundedNonDegenerate a] -> ShowS
Show)

instance (A.FromJSON a, Ord a) => A.FromJSON (IntervalUnboundedNonDegenerate a) where
  parseJSON :: Value -> Parser (IntervalUnboundedNonDegenerate a)
parseJSON Value
value = do
    IntervalUnbounded a
intervalUnbounded <- Value -> Parser (IntervalUnbounded a)
forall a. FromJSON a => Value -> Parser a
A.parseJSON Value
value
    if IntervalUnbounded a -> Bool
forall a. Ord a => IntervalUnbounded a -> Bool
intervalUnboundedIsDegenerate IntervalUnbounded a
intervalUnbounded
      then String -> Parser (IntervalUnboundedNonDegenerate a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"expected non-degenerate (potentially unbounded) interval, but boundaries are equal"
      else IntervalUnboundedNonDegenerate a
-> Parser (IntervalUnboundedNonDegenerate a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (IntervalUnboundedNonDegenerate a
 -> Parser (IntervalUnboundedNonDegenerate a))
-> IntervalUnboundedNonDegenerate a
-> Parser (IntervalUnboundedNonDegenerate a)
forall a b. (a -> b) -> a -> b
$ IntervalUnbounded a -> IntervalUnboundedNonDegenerate a
forall a. IntervalUnbounded a -> IntervalUnboundedNonDegenerate a
MkIntervalUnboundedNonDegenerateUnsafe IntervalUnbounded a
intervalUnbounded
deriving newtype instance A.ToJSON a => A.ToJSON (IntervalUnboundedNonDegenerate a)

type MaybeUnbounded :: Type -> Type
data MaybeUnbounded a
  = MkMaybeUnboundedLow (MaybeUnboundedLow a)
  | MkMaybeUnboundedHigh (MaybeUnboundedHigh a)
  deriving stock ((forall x. MaybeUnbounded a -> Rep (MaybeUnbounded a) x)
-> (forall x. Rep (MaybeUnbounded a) x -> MaybeUnbounded a)
-> Generic (MaybeUnbounded a)
forall x. Rep (MaybeUnbounded a) x -> MaybeUnbounded a
forall x. MaybeUnbounded a -> Rep (MaybeUnbounded a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (MaybeUnbounded a) x -> MaybeUnbounded a
forall a x. MaybeUnbounded a -> Rep (MaybeUnbounded a) x
$cfrom :: forall a x. MaybeUnbounded a -> Rep (MaybeUnbounded a) x
from :: forall x. MaybeUnbounded a -> Rep (MaybeUnbounded a) x
$cto :: forall a x. Rep (MaybeUnbounded a) x -> MaybeUnbounded a
to :: forall x. Rep (MaybeUnbounded a) x -> MaybeUnbounded a
Generic, ReadPrec [MaybeUnbounded a]
ReadPrec (MaybeUnbounded a)
Int -> ReadS (MaybeUnbounded a)
ReadS [MaybeUnbounded a]
(Int -> ReadS (MaybeUnbounded a))
-> ReadS [MaybeUnbounded a]
-> ReadPrec (MaybeUnbounded a)
-> ReadPrec [MaybeUnbounded a]
-> Read (MaybeUnbounded a)
forall a. Read a => ReadPrec [MaybeUnbounded a]
forall a. Read a => ReadPrec (MaybeUnbounded a)
forall a. Read a => Int -> ReadS (MaybeUnbounded a)
forall a. Read a => ReadS [MaybeUnbounded a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (MaybeUnbounded a)
readsPrec :: Int -> ReadS (MaybeUnbounded a)
$creadList :: forall a. Read a => ReadS [MaybeUnbounded a]
readList :: ReadS [MaybeUnbounded a]
$creadPrec :: forall a. Read a => ReadPrec (MaybeUnbounded a)
readPrec :: ReadPrec (MaybeUnbounded a)
$creadListPrec :: forall a. Read a => ReadPrec [MaybeUnbounded a]
readListPrec :: ReadPrec [MaybeUnbounded a]
Read, Int -> MaybeUnbounded a -> ShowS
[MaybeUnbounded a] -> ShowS
MaybeUnbounded a -> String
(Int -> MaybeUnbounded a -> ShowS)
-> (MaybeUnbounded a -> String)
-> ([MaybeUnbounded a] -> ShowS)
-> Show (MaybeUnbounded a)
forall a. Show a => Int -> MaybeUnbounded a -> ShowS
forall a. Show a => [MaybeUnbounded a] -> ShowS
forall a. Show a => MaybeUnbounded a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> MaybeUnbounded a -> ShowS
showsPrec :: Int -> MaybeUnbounded a -> ShowS
$cshow :: forall a. Show a => MaybeUnbounded a -> String
show :: MaybeUnbounded a -> String
$cshowList :: forall a. Show a => [MaybeUnbounded a] -> ShowS
showList :: [MaybeUnbounded a] -> ShowS
Show)

instance Eq a => Eq (MaybeUnbounded a) where
  == :: MaybeUnbounded a -> MaybeUnbounded a -> Bool
(==) = \cases
    (MkMaybeUnboundedLow MaybeUnboundedLow a
x) (MkMaybeUnboundedLow MaybeUnboundedLow a
y) -> MaybeUnboundedLow a -> MaybeUnboundedLow a -> Bool
forall a. Eq a => a -> a -> Bool
(==) MaybeUnboundedLow a
x MaybeUnboundedLow a
y
    (MkMaybeUnboundedHigh MaybeUnboundedHigh a
x) (MkMaybeUnboundedHigh MaybeUnboundedHigh a
y) -> MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Bool
forall a. Eq a => a -> a -> Bool
(==) MaybeUnboundedHigh a
x MaybeUnboundedHigh a
y
    (MkMaybeUnboundedLow MaybeUnboundedLow a
NothingUnboundedLow) (MkMaybeUnboundedHigh MaybeUnboundedHigh a
_) -> Bool
False
    (MkMaybeUnboundedLow (JustUnboundedLow a
_)) (MkMaybeUnboundedHigh MaybeUnboundedHigh a
NothingUnboundedHigh) -> Bool
False
    (MkMaybeUnboundedHigh MaybeUnboundedHigh a
NothingUnboundedHigh) (MkMaybeUnboundedLow MaybeUnboundedLow a
_) -> Bool
False
    (MkMaybeUnboundedHigh MaybeUnboundedHigh a
_) (MkMaybeUnboundedLow MaybeUnboundedLow a
NothingUnboundedLow) -> Bool
False
    (MkMaybeUnboundedLow (JustUnboundedLow a
x)) (MkMaybeUnboundedHigh (JustUnboundedHigh a
y)) -> a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==) a
x a
y
    (MkMaybeUnboundedHigh (JustUnboundedHigh a
x)) (MkMaybeUnboundedLow (JustUnboundedLow a
y)) -> a -> a -> Bool
forall a. Eq a => a -> a -> Bool
(==) a
x a
y
instance Ord a => Ord (MaybeUnbounded a) where
  compare :: MaybeUnbounded a -> MaybeUnbounded a -> Ordering
compare = \cases
    (MkMaybeUnboundedLow MaybeUnboundedLow a
x) (MkMaybeUnboundedLow MaybeUnboundedLow a
y) -> MaybeUnboundedLow a -> MaybeUnboundedLow a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare MaybeUnboundedLow a
x MaybeUnboundedLow a
y
    (MkMaybeUnboundedHigh MaybeUnboundedHigh a
x) (MkMaybeUnboundedHigh MaybeUnboundedHigh a
y) -> MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare MaybeUnboundedHigh a
x MaybeUnboundedHigh a
y
    (MkMaybeUnboundedLow MaybeUnboundedLow a
NothingUnboundedLow) (MkMaybeUnboundedHigh MaybeUnboundedHigh a
_) -> Ordering
LT
    (MkMaybeUnboundedLow (JustUnboundedLow a
_)) (MkMaybeUnboundedHigh MaybeUnboundedHigh a
NothingUnboundedHigh) -> Ordering
LT
    (MkMaybeUnboundedHigh MaybeUnboundedHigh a
NothingUnboundedHigh) (MkMaybeUnboundedLow MaybeUnboundedLow a
_) -> Ordering
GT
    (MkMaybeUnboundedHigh MaybeUnboundedHigh a
_) (MkMaybeUnboundedLow MaybeUnboundedLow a
NothingUnboundedLow) -> Ordering
GT
    (MkMaybeUnboundedLow (JustUnboundedLow a
x)) (MkMaybeUnboundedHigh (JustUnboundedHigh a
y)) -> a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare a
x a
y
    (MkMaybeUnboundedHigh (JustUnboundedHigh a
x)) (MkMaybeUnboundedLow (JustUnboundedLow a
y)) -> a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare a
x a
y

type MaybeUnboundedLow :: Type -> Type
data MaybeUnboundedLow a
  = NothingUnboundedLow
  | JustUnboundedLow a
  deriving stock (MaybeUnboundedLow a -> MaybeUnboundedLow a -> Bool
(MaybeUnboundedLow a -> MaybeUnboundedLow a -> Bool)
-> (MaybeUnboundedLow a -> MaybeUnboundedLow a -> Bool)
-> Eq (MaybeUnboundedLow a)
forall a.
Eq a =>
MaybeUnboundedLow a -> MaybeUnboundedLow a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
MaybeUnboundedLow a -> MaybeUnboundedLow a -> Bool
== :: MaybeUnboundedLow a -> MaybeUnboundedLow a -> Bool
$c/= :: forall a.
Eq a =>
MaybeUnboundedLow a -> MaybeUnboundedLow a -> Bool
/= :: MaybeUnboundedLow a -> MaybeUnboundedLow a -> Bool
Eq, (forall x. MaybeUnboundedLow a -> Rep (MaybeUnboundedLow a) x)
-> (forall x. Rep (MaybeUnboundedLow a) x -> MaybeUnboundedLow a)
-> Generic (MaybeUnboundedLow a)
forall x. Rep (MaybeUnboundedLow a) x -> MaybeUnboundedLow a
forall x. MaybeUnboundedLow a -> Rep (MaybeUnboundedLow a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (MaybeUnboundedLow a) x -> MaybeUnboundedLow a
forall a x. MaybeUnboundedLow a -> Rep (MaybeUnboundedLow a) x
$cfrom :: forall a x. MaybeUnboundedLow a -> Rep (MaybeUnboundedLow a) x
from :: forall x. MaybeUnboundedLow a -> Rep (MaybeUnboundedLow a) x
$cto :: forall a x. Rep (MaybeUnboundedLow a) x -> MaybeUnboundedLow a
to :: forall x. Rep (MaybeUnboundedLow a) x -> MaybeUnboundedLow a
Generic, ReadPrec [MaybeUnboundedLow a]
ReadPrec (MaybeUnboundedLow a)
Int -> ReadS (MaybeUnboundedLow a)
ReadS [MaybeUnboundedLow a]
(Int -> ReadS (MaybeUnboundedLow a))
-> ReadS [MaybeUnboundedLow a]
-> ReadPrec (MaybeUnboundedLow a)
-> ReadPrec [MaybeUnboundedLow a]
-> Read (MaybeUnboundedLow a)
forall a. Read a => ReadPrec [MaybeUnboundedLow a]
forall a. Read a => ReadPrec (MaybeUnboundedLow a)
forall a. Read a => Int -> ReadS (MaybeUnboundedLow a)
forall a. Read a => ReadS [MaybeUnboundedLow a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (MaybeUnboundedLow a)
readsPrec :: Int -> ReadS (MaybeUnboundedLow a)
$creadList :: forall a. Read a => ReadS [MaybeUnboundedLow a]
readList :: ReadS [MaybeUnboundedLow a]
$creadPrec :: forall a. Read a => ReadPrec (MaybeUnboundedLow a)
readPrec :: ReadPrec (MaybeUnboundedLow a)
$creadListPrec :: forall a. Read a => ReadPrec [MaybeUnboundedLow a]
readListPrec :: ReadPrec [MaybeUnboundedLow a]
Read, Int -> MaybeUnboundedLow a -> ShowS
[MaybeUnboundedLow a] -> ShowS
MaybeUnboundedLow a -> String
(Int -> MaybeUnboundedLow a -> ShowS)
-> (MaybeUnboundedLow a -> String)
-> ([MaybeUnboundedLow a] -> ShowS)
-> Show (MaybeUnboundedLow a)
forall a. Show a => Int -> MaybeUnboundedLow a -> ShowS
forall a. Show a => [MaybeUnboundedLow a] -> ShowS
forall a. Show a => MaybeUnboundedLow a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> MaybeUnboundedLow a -> ShowS
showsPrec :: Int -> MaybeUnboundedLow a -> ShowS
$cshow :: forall a. Show a => MaybeUnboundedLow a -> String
show :: MaybeUnboundedLow a -> String
$cshowList :: forall a. Show a => [MaybeUnboundedLow a] -> ShowS
showList :: [MaybeUnboundedLow a] -> ShowS
Show)

instance Ord a => Ord (MaybeUnboundedLow a) where
  compare :: MaybeUnboundedLow a -> MaybeUnboundedLow a -> Ordering
compare = \cases
    MaybeUnboundedLow a
NothingUnboundedLow MaybeUnboundedLow a
NothingUnboundedLow -> Ordering
EQ
    MaybeUnboundedLow a
NothingUnboundedLow (JustUnboundedLow a
_) -> Ordering
LT
    (JustUnboundedLow a
x) (JustUnboundedLow a
y) -> a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare a
x a
y
    (JustUnboundedLow a
_) MaybeUnboundedLow a
NothingUnboundedLow -> Ordering
GT

type MaybeUnboundedHigh :: Type -> Type
data MaybeUnboundedHigh a
  = NothingUnboundedHigh
  | JustUnboundedHigh a
  deriving stock (MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Bool
(MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Bool)
-> (MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Bool)
-> Eq (MaybeUnboundedHigh a)
forall a.
Eq a =>
MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Bool
== :: MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Bool
$c/= :: forall a.
Eq a =>
MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Bool
/= :: MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Bool
Eq, (forall x. MaybeUnboundedHigh a -> Rep (MaybeUnboundedHigh a) x)
-> (forall x. Rep (MaybeUnboundedHigh a) x -> MaybeUnboundedHigh a)
-> Generic (MaybeUnboundedHigh a)
forall x. Rep (MaybeUnboundedHigh a) x -> MaybeUnboundedHigh a
forall x. MaybeUnboundedHigh a -> Rep (MaybeUnboundedHigh a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (MaybeUnboundedHigh a) x -> MaybeUnboundedHigh a
forall a x. MaybeUnboundedHigh a -> Rep (MaybeUnboundedHigh a) x
$cfrom :: forall a x. MaybeUnboundedHigh a -> Rep (MaybeUnboundedHigh a) x
from :: forall x. MaybeUnboundedHigh a -> Rep (MaybeUnboundedHigh a) x
$cto :: forall a x. Rep (MaybeUnboundedHigh a) x -> MaybeUnboundedHigh a
to :: forall x. Rep (MaybeUnboundedHigh a) x -> MaybeUnboundedHigh a
Generic, ReadPrec [MaybeUnboundedHigh a]
ReadPrec (MaybeUnboundedHigh a)
Int -> ReadS (MaybeUnboundedHigh a)
ReadS [MaybeUnboundedHigh a]
(Int -> ReadS (MaybeUnboundedHigh a))
-> ReadS [MaybeUnboundedHigh a]
-> ReadPrec (MaybeUnboundedHigh a)
-> ReadPrec [MaybeUnboundedHigh a]
-> Read (MaybeUnboundedHigh a)
forall a. Read a => ReadPrec [MaybeUnboundedHigh a]
forall a. Read a => ReadPrec (MaybeUnboundedHigh a)
forall a. Read a => Int -> ReadS (MaybeUnboundedHigh a)
forall a. Read a => ReadS [MaybeUnboundedHigh a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (MaybeUnboundedHigh a)
readsPrec :: Int -> ReadS (MaybeUnboundedHigh a)
$creadList :: forall a. Read a => ReadS [MaybeUnboundedHigh a]
readList :: ReadS [MaybeUnboundedHigh a]
$creadPrec :: forall a. Read a => ReadPrec (MaybeUnboundedHigh a)
readPrec :: ReadPrec (MaybeUnboundedHigh a)
$creadListPrec :: forall a. Read a => ReadPrec [MaybeUnboundedHigh a]
readListPrec :: ReadPrec [MaybeUnboundedHigh a]
Read, Int -> MaybeUnboundedHigh a -> ShowS
[MaybeUnboundedHigh a] -> ShowS
MaybeUnboundedHigh a -> String
(Int -> MaybeUnboundedHigh a -> ShowS)
-> (MaybeUnboundedHigh a -> String)
-> ([MaybeUnboundedHigh a] -> ShowS)
-> Show (MaybeUnboundedHigh a)
forall a. Show a => Int -> MaybeUnboundedHigh a -> ShowS
forall a. Show a => [MaybeUnboundedHigh a] -> ShowS
forall a. Show a => MaybeUnboundedHigh a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> MaybeUnboundedHigh a -> ShowS
showsPrec :: Int -> MaybeUnboundedHigh a -> ShowS
$cshow :: forall a. Show a => MaybeUnboundedHigh a -> String
show :: MaybeUnboundedHigh a -> String
$cshowList :: forall a. Show a => [MaybeUnboundedHigh a] -> ShowS
showList :: [MaybeUnboundedHigh a] -> ShowS
Show)

instance Ord a => Ord (MaybeUnboundedHigh a) where
  compare :: MaybeUnboundedHigh a -> MaybeUnboundedHigh a -> Ordering
compare = \cases
    MaybeUnboundedHigh a
NothingUnboundedHigh MaybeUnboundedHigh a
NothingUnboundedHigh -> Ordering
EQ
    MaybeUnboundedHigh a
NothingUnboundedHigh (JustUnboundedHigh a
_) -> Ordering
GT
    (JustUnboundedHigh a
x) (JustUnboundedHigh a
y) -> a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare a
x a
y
    (JustUnboundedHigh a
_) MaybeUnboundedHigh a
NothingUnboundedHigh -> Ordering
LT