module U.Codebase.Sqlite.DbId where

import Data.Bits (Bits)
import Data.Text (Text)
import Data.UUID (UUID)
import Data.UUID.Orphans.Sqlite ()
import Data.Word (Word64)
import Unison.Sqlite (FromField, ToField)

newtype HashVersion = HashVersion Word64
  deriving stock (HashVersion -> HashVersion -> Bool
(HashVersion -> HashVersion -> Bool)
-> (HashVersion -> HashVersion -> Bool) -> Eq HashVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HashVersion -> HashVersion -> Bool
== :: HashVersion -> HashVersion -> Bool
$c/= :: HashVersion -> HashVersion -> Bool
/= :: HashVersion -> HashVersion -> Bool
Eq, Eq HashVersion
Eq HashVersion =>
(HashVersion -> HashVersion -> Ordering)
-> (HashVersion -> HashVersion -> Bool)
-> (HashVersion -> HashVersion -> Bool)
-> (HashVersion -> HashVersion -> Bool)
-> (HashVersion -> HashVersion -> Bool)
-> (HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion -> HashVersion)
-> Ord HashVersion
HashVersion -> HashVersion -> Bool
HashVersion -> HashVersion -> Ordering
HashVersion -> HashVersion -> HashVersion
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 :: HashVersion -> HashVersion -> Ordering
compare :: HashVersion -> HashVersion -> Ordering
$c< :: HashVersion -> HashVersion -> Bool
< :: HashVersion -> HashVersion -> Bool
$c<= :: HashVersion -> HashVersion -> Bool
<= :: HashVersion -> HashVersion -> Bool
$c> :: HashVersion -> HashVersion -> Bool
> :: HashVersion -> HashVersion -> Bool
$c>= :: HashVersion -> HashVersion -> Bool
>= :: HashVersion -> HashVersion -> Bool
$cmax :: HashVersion -> HashVersion -> HashVersion
max :: HashVersion -> HashVersion -> HashVersion
$cmin :: HashVersion -> HashVersion -> HashVersion
min :: HashVersion -> HashVersion -> HashVersion
Ord, Int -> HashVersion -> ShowS
[HashVersion] -> ShowS
HashVersion -> String
(Int -> HashVersion -> ShowS)
-> (HashVersion -> String)
-> ([HashVersion] -> ShowS)
-> Show HashVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HashVersion -> ShowS
showsPrec :: Int -> HashVersion -> ShowS
$cshow :: HashVersion -> String
show :: HashVersion -> String
$cshowList :: [HashVersion] -> ShowS
showList :: [HashVersion] -> ShowS
Show)
  deriving (Integer -> HashVersion
HashVersion -> HashVersion
HashVersion -> HashVersion -> HashVersion
(HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion)
-> (HashVersion -> HashVersion)
-> (HashVersion -> HashVersion)
-> (Integer -> HashVersion)
-> Num HashVersion
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: HashVersion -> HashVersion -> HashVersion
+ :: HashVersion -> HashVersion -> HashVersion
$c- :: HashVersion -> HashVersion -> HashVersion
- :: HashVersion -> HashVersion -> HashVersion
$c* :: HashVersion -> HashVersion -> HashVersion
* :: HashVersion -> HashVersion -> HashVersion
$cnegate :: HashVersion -> HashVersion
negate :: HashVersion -> HashVersion
$cabs :: HashVersion -> HashVersion
abs :: HashVersion -> HashVersion
$csignum :: HashVersion -> HashVersion
signum :: HashVersion -> HashVersion
$cfromInteger :: Integer -> HashVersion
fromInteger :: Integer -> HashVersion
Num, Num HashVersion
Ord HashVersion
(Num HashVersion, Ord HashVersion) =>
(HashVersion -> Rational) -> Real HashVersion
HashVersion -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: HashVersion -> Rational
toRational :: HashVersion -> Rational
Real, Int -> HashVersion
HashVersion -> Int
HashVersion -> [HashVersion]
HashVersion -> HashVersion
HashVersion -> HashVersion -> [HashVersion]
HashVersion -> HashVersion -> HashVersion -> [HashVersion]
(HashVersion -> HashVersion)
-> (HashVersion -> HashVersion)
-> (Int -> HashVersion)
-> (HashVersion -> Int)
-> (HashVersion -> [HashVersion])
-> (HashVersion -> HashVersion -> [HashVersion])
-> (HashVersion -> HashVersion -> [HashVersion])
-> (HashVersion -> HashVersion -> HashVersion -> [HashVersion])
-> Enum HashVersion
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 :: HashVersion -> HashVersion
succ :: HashVersion -> HashVersion
$cpred :: HashVersion -> HashVersion
pred :: HashVersion -> HashVersion
$ctoEnum :: Int -> HashVersion
toEnum :: Int -> HashVersion
$cfromEnum :: HashVersion -> Int
fromEnum :: HashVersion -> Int
$cenumFrom :: HashVersion -> [HashVersion]
enumFrom :: HashVersion -> [HashVersion]
$cenumFromThen :: HashVersion -> HashVersion -> [HashVersion]
enumFromThen :: HashVersion -> HashVersion -> [HashVersion]
$cenumFromTo :: HashVersion -> HashVersion -> [HashVersion]
enumFromTo :: HashVersion -> HashVersion -> [HashVersion]
$cenumFromThenTo :: HashVersion -> HashVersion -> HashVersion -> [HashVersion]
enumFromThenTo :: HashVersion -> HashVersion -> HashVersion -> [HashVersion]
Enum, Enum HashVersion
Real HashVersion
(Real HashVersion, Enum HashVersion) =>
(HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion -> (HashVersion, HashVersion))
-> (HashVersion -> HashVersion -> (HashVersion, HashVersion))
-> (HashVersion -> Integer)
-> Integral HashVersion
HashVersion -> Integer
HashVersion -> HashVersion -> (HashVersion, HashVersion)
HashVersion -> HashVersion -> HashVersion
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
$cquot :: HashVersion -> HashVersion -> HashVersion
quot :: HashVersion -> HashVersion -> HashVersion
$crem :: HashVersion -> HashVersion -> HashVersion
rem :: HashVersion -> HashVersion -> HashVersion
$cdiv :: HashVersion -> HashVersion -> HashVersion
div :: HashVersion -> HashVersion -> HashVersion
$cmod :: HashVersion -> HashVersion -> HashVersion
mod :: HashVersion -> HashVersion -> HashVersion
$cquotRem :: HashVersion -> HashVersion -> (HashVersion, HashVersion)
quotRem :: HashVersion -> HashVersion -> (HashVersion, HashVersion)
$cdivMod :: HashVersion -> HashVersion -> (HashVersion, HashVersion)
divMod :: HashVersion -> HashVersion -> (HashVersion, HashVersion)
$ctoInteger :: HashVersion -> Integer
toInteger :: HashVersion -> Integer
Integral, Eq HashVersion
HashVersion
Eq HashVersion =>
(HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion -> HashVersion)
-> (HashVersion -> HashVersion)
-> (HashVersion -> Int -> HashVersion)
-> (HashVersion -> Int -> HashVersion)
-> HashVersion
-> (Int -> HashVersion)
-> (HashVersion -> Int -> HashVersion)
-> (HashVersion -> Int -> HashVersion)
-> (HashVersion -> Int -> HashVersion)
-> (HashVersion -> Int -> Bool)
-> (HashVersion -> Maybe Int)
-> (HashVersion -> Int)
-> (HashVersion -> Bool)
-> (HashVersion -> Int -> HashVersion)
-> (HashVersion -> Int -> HashVersion)
-> (HashVersion -> Int -> HashVersion)
-> (HashVersion -> Int -> HashVersion)
-> (HashVersion -> Int -> HashVersion)
-> (HashVersion -> Int -> HashVersion)
-> (HashVersion -> Int)
-> Bits HashVersion
Int -> HashVersion
HashVersion -> Bool
HashVersion -> Int
HashVersion -> Maybe Int
HashVersion -> HashVersion
HashVersion -> Int -> Bool
HashVersion -> Int -> HashVersion
HashVersion -> HashVersion -> HashVersion
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: HashVersion -> HashVersion -> HashVersion
.&. :: HashVersion -> HashVersion -> HashVersion
$c.|. :: HashVersion -> HashVersion -> HashVersion
.|. :: HashVersion -> HashVersion -> HashVersion
$cxor :: HashVersion -> HashVersion -> HashVersion
xor :: HashVersion -> HashVersion -> HashVersion
$ccomplement :: HashVersion -> HashVersion
complement :: HashVersion -> HashVersion
$cshift :: HashVersion -> Int -> HashVersion
shift :: HashVersion -> Int -> HashVersion
$crotate :: HashVersion -> Int -> HashVersion
rotate :: HashVersion -> Int -> HashVersion
$czeroBits :: HashVersion
zeroBits :: HashVersion
$cbit :: Int -> HashVersion
bit :: Int -> HashVersion
$csetBit :: HashVersion -> Int -> HashVersion
setBit :: HashVersion -> Int -> HashVersion
$cclearBit :: HashVersion -> Int -> HashVersion
clearBit :: HashVersion -> Int -> HashVersion
$ccomplementBit :: HashVersion -> Int -> HashVersion
complementBit :: HashVersion -> Int -> HashVersion
$ctestBit :: HashVersion -> Int -> Bool
testBit :: HashVersion -> Int -> Bool
$cbitSizeMaybe :: HashVersion -> Maybe Int
bitSizeMaybe :: HashVersion -> Maybe Int
$cbitSize :: HashVersion -> Int
bitSize :: HashVersion -> Int
$cisSigned :: HashVersion -> Bool
isSigned :: HashVersion -> Bool
$cshiftL :: HashVersion -> Int -> HashVersion
shiftL :: HashVersion -> Int -> HashVersion
$cunsafeShiftL :: HashVersion -> Int -> HashVersion
unsafeShiftL :: HashVersion -> Int -> HashVersion
$cshiftR :: HashVersion -> Int -> HashVersion
shiftR :: HashVersion -> Int -> HashVersion
$cunsafeShiftR :: HashVersion -> Int -> HashVersion
unsafeShiftR :: HashVersion -> Int -> HashVersion
$crotateL :: HashVersion -> Int -> HashVersion
rotateL :: HashVersion -> Int -> HashVersion
$crotateR :: HashVersion -> Int -> HashVersion
rotateR :: HashVersion -> Int -> HashVersion
$cpopCount :: HashVersion -> Int
popCount :: HashVersion -> Int
Bits, FieldParser HashVersion
FieldParser HashVersion -> FromField HashVersion
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser HashVersion
fromField :: FieldParser HashVersion
FromField, HashVersion -> SQLData
(HashVersion -> SQLData) -> ToField HashVersion
forall a. (a -> SQLData) -> ToField a
$ctoField :: HashVersion -> SQLData
toField :: HashVersion -> SQLData
ToField) via Word64

newtype ObjectId = ObjectId Word64
  deriving (ObjectId -> ObjectId -> Bool
(ObjectId -> ObjectId -> Bool)
-> (ObjectId -> ObjectId -> Bool) -> Eq ObjectId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ObjectId -> ObjectId -> Bool
== :: ObjectId -> ObjectId -> Bool
$c/= :: ObjectId -> ObjectId -> Bool
/= :: ObjectId -> ObjectId -> Bool
Eq, Eq ObjectId
Eq ObjectId =>
(ObjectId -> ObjectId -> Ordering)
-> (ObjectId -> ObjectId -> Bool)
-> (ObjectId -> ObjectId -> Bool)
-> (ObjectId -> ObjectId -> Bool)
-> (ObjectId -> ObjectId -> Bool)
-> (ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId -> ObjectId)
-> Ord ObjectId
ObjectId -> ObjectId -> Bool
ObjectId -> ObjectId -> Ordering
ObjectId -> ObjectId -> ObjectId
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 :: ObjectId -> ObjectId -> Ordering
compare :: ObjectId -> ObjectId -> Ordering
$c< :: ObjectId -> ObjectId -> Bool
< :: ObjectId -> ObjectId -> Bool
$c<= :: ObjectId -> ObjectId -> Bool
<= :: ObjectId -> ObjectId -> Bool
$c> :: ObjectId -> ObjectId -> Bool
> :: ObjectId -> ObjectId -> Bool
$c>= :: ObjectId -> ObjectId -> Bool
>= :: ObjectId -> ObjectId -> Bool
$cmax :: ObjectId -> ObjectId -> ObjectId
max :: ObjectId -> ObjectId -> ObjectId
$cmin :: ObjectId -> ObjectId -> ObjectId
min :: ObjectId -> ObjectId -> ObjectId
Ord, Int -> ObjectId -> ShowS
[ObjectId] -> ShowS
ObjectId -> String
(Int -> ObjectId -> ShowS)
-> (ObjectId -> String) -> ([ObjectId] -> ShowS) -> Show ObjectId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ObjectId -> ShowS
showsPrec :: Int -> ObjectId -> ShowS
$cshow :: ObjectId -> String
show :: ObjectId -> String
$cshowList :: [ObjectId] -> ShowS
showList :: [ObjectId] -> ShowS
Show)
  deriving (Integer -> ObjectId
ObjectId -> ObjectId
ObjectId -> ObjectId -> ObjectId
(ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId)
-> (ObjectId -> ObjectId)
-> (ObjectId -> ObjectId)
-> (Integer -> ObjectId)
-> Num ObjectId
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: ObjectId -> ObjectId -> ObjectId
+ :: ObjectId -> ObjectId -> ObjectId
$c- :: ObjectId -> ObjectId -> ObjectId
- :: ObjectId -> ObjectId -> ObjectId
$c* :: ObjectId -> ObjectId -> ObjectId
* :: ObjectId -> ObjectId -> ObjectId
$cnegate :: ObjectId -> ObjectId
negate :: ObjectId -> ObjectId
$cabs :: ObjectId -> ObjectId
abs :: ObjectId -> ObjectId
$csignum :: ObjectId -> ObjectId
signum :: ObjectId -> ObjectId
$cfromInteger :: Integer -> ObjectId
fromInteger :: Integer -> ObjectId
Num, Num ObjectId
Ord ObjectId
(Num ObjectId, Ord ObjectId) =>
(ObjectId -> Rational) -> Real ObjectId
ObjectId -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: ObjectId -> Rational
toRational :: ObjectId -> Rational
Real, Int -> ObjectId
ObjectId -> Int
ObjectId -> [ObjectId]
ObjectId -> ObjectId
ObjectId -> ObjectId -> [ObjectId]
ObjectId -> ObjectId -> ObjectId -> [ObjectId]
(ObjectId -> ObjectId)
-> (ObjectId -> ObjectId)
-> (Int -> ObjectId)
-> (ObjectId -> Int)
-> (ObjectId -> [ObjectId])
-> (ObjectId -> ObjectId -> [ObjectId])
-> (ObjectId -> ObjectId -> [ObjectId])
-> (ObjectId -> ObjectId -> ObjectId -> [ObjectId])
-> Enum ObjectId
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 :: ObjectId -> ObjectId
succ :: ObjectId -> ObjectId
$cpred :: ObjectId -> ObjectId
pred :: ObjectId -> ObjectId
$ctoEnum :: Int -> ObjectId
toEnum :: Int -> ObjectId
$cfromEnum :: ObjectId -> Int
fromEnum :: ObjectId -> Int
$cenumFrom :: ObjectId -> [ObjectId]
enumFrom :: ObjectId -> [ObjectId]
$cenumFromThen :: ObjectId -> ObjectId -> [ObjectId]
enumFromThen :: ObjectId -> ObjectId -> [ObjectId]
$cenumFromTo :: ObjectId -> ObjectId -> [ObjectId]
enumFromTo :: ObjectId -> ObjectId -> [ObjectId]
$cenumFromThenTo :: ObjectId -> ObjectId -> ObjectId -> [ObjectId]
enumFromThenTo :: ObjectId -> ObjectId -> ObjectId -> [ObjectId]
Enum, Enum ObjectId
Real ObjectId
(Real ObjectId, Enum ObjectId) =>
(ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId -> (ObjectId, ObjectId))
-> (ObjectId -> ObjectId -> (ObjectId, ObjectId))
-> (ObjectId -> Integer)
-> Integral ObjectId
ObjectId -> Integer
ObjectId -> ObjectId -> (ObjectId, ObjectId)
ObjectId -> ObjectId -> ObjectId
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
$cquot :: ObjectId -> ObjectId -> ObjectId
quot :: ObjectId -> ObjectId -> ObjectId
$crem :: ObjectId -> ObjectId -> ObjectId
rem :: ObjectId -> ObjectId -> ObjectId
$cdiv :: ObjectId -> ObjectId -> ObjectId
div :: ObjectId -> ObjectId -> ObjectId
$cmod :: ObjectId -> ObjectId -> ObjectId
mod :: ObjectId -> ObjectId -> ObjectId
$cquotRem :: ObjectId -> ObjectId -> (ObjectId, ObjectId)
quotRem :: ObjectId -> ObjectId -> (ObjectId, ObjectId)
$cdivMod :: ObjectId -> ObjectId -> (ObjectId, ObjectId)
divMod :: ObjectId -> ObjectId -> (ObjectId, ObjectId)
$ctoInteger :: ObjectId -> Integer
toInteger :: ObjectId -> Integer
Integral, Eq ObjectId
ObjectId
Eq ObjectId =>
(ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId -> ObjectId)
-> (ObjectId -> ObjectId)
-> (ObjectId -> Int -> ObjectId)
-> (ObjectId -> Int -> ObjectId)
-> ObjectId
-> (Int -> ObjectId)
-> (ObjectId -> Int -> ObjectId)
-> (ObjectId -> Int -> ObjectId)
-> (ObjectId -> Int -> ObjectId)
-> (ObjectId -> Int -> Bool)
-> (ObjectId -> Maybe Int)
-> (ObjectId -> Int)
-> (ObjectId -> Bool)
-> (ObjectId -> Int -> ObjectId)
-> (ObjectId -> Int -> ObjectId)
-> (ObjectId -> Int -> ObjectId)
-> (ObjectId -> Int -> ObjectId)
-> (ObjectId -> Int -> ObjectId)
-> (ObjectId -> Int -> ObjectId)
-> (ObjectId -> Int)
-> Bits ObjectId
Int -> ObjectId
ObjectId -> Bool
ObjectId -> Int
ObjectId -> Maybe Int
ObjectId -> ObjectId
ObjectId -> Int -> Bool
ObjectId -> Int -> ObjectId
ObjectId -> ObjectId -> ObjectId
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: ObjectId -> ObjectId -> ObjectId
.&. :: ObjectId -> ObjectId -> ObjectId
$c.|. :: ObjectId -> ObjectId -> ObjectId
.|. :: ObjectId -> ObjectId -> ObjectId
$cxor :: ObjectId -> ObjectId -> ObjectId
xor :: ObjectId -> ObjectId -> ObjectId
$ccomplement :: ObjectId -> ObjectId
complement :: ObjectId -> ObjectId
$cshift :: ObjectId -> Int -> ObjectId
shift :: ObjectId -> Int -> ObjectId
$crotate :: ObjectId -> Int -> ObjectId
rotate :: ObjectId -> Int -> ObjectId
$czeroBits :: ObjectId
zeroBits :: ObjectId
$cbit :: Int -> ObjectId
bit :: Int -> ObjectId
$csetBit :: ObjectId -> Int -> ObjectId
setBit :: ObjectId -> Int -> ObjectId
$cclearBit :: ObjectId -> Int -> ObjectId
clearBit :: ObjectId -> Int -> ObjectId
$ccomplementBit :: ObjectId -> Int -> ObjectId
complementBit :: ObjectId -> Int -> ObjectId
$ctestBit :: ObjectId -> Int -> Bool
testBit :: ObjectId -> Int -> Bool
$cbitSizeMaybe :: ObjectId -> Maybe Int
bitSizeMaybe :: ObjectId -> Maybe Int
$cbitSize :: ObjectId -> Int
bitSize :: ObjectId -> Int
$cisSigned :: ObjectId -> Bool
isSigned :: ObjectId -> Bool
$cshiftL :: ObjectId -> Int -> ObjectId
shiftL :: ObjectId -> Int -> ObjectId
$cunsafeShiftL :: ObjectId -> Int -> ObjectId
unsafeShiftL :: ObjectId -> Int -> ObjectId
$cshiftR :: ObjectId -> Int -> ObjectId
shiftR :: ObjectId -> Int -> ObjectId
$cunsafeShiftR :: ObjectId -> Int -> ObjectId
unsafeShiftR :: ObjectId -> Int -> ObjectId
$crotateL :: ObjectId -> Int -> ObjectId
rotateL :: ObjectId -> Int -> ObjectId
$crotateR :: ObjectId -> Int -> ObjectId
rotateR :: ObjectId -> Int -> ObjectId
$cpopCount :: ObjectId -> Int
popCount :: ObjectId -> Int
Bits, FieldParser ObjectId
FieldParser ObjectId -> FromField ObjectId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser ObjectId
fromField :: FieldParser ObjectId
FromField, ObjectId -> SQLData
(ObjectId -> SQLData) -> ToField ObjectId
forall a. (a -> SQLData) -> ToField a
$ctoField :: ObjectId -> SQLData
toField :: ObjectId -> SQLData
ToField) via Word64

newtype TextId = TextId Word64
  deriving (TextId -> TextId -> Bool
(TextId -> TextId -> Bool)
-> (TextId -> TextId -> Bool) -> Eq TextId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextId -> TextId -> Bool
== :: TextId -> TextId -> Bool
$c/= :: TextId -> TextId -> Bool
/= :: TextId -> TextId -> Bool
Eq, Eq TextId
Eq TextId =>
(TextId -> TextId -> Ordering)
-> (TextId -> TextId -> Bool)
-> (TextId -> TextId -> Bool)
-> (TextId -> TextId -> Bool)
-> (TextId -> TextId -> Bool)
-> (TextId -> TextId -> TextId)
-> (TextId -> TextId -> TextId)
-> Ord TextId
TextId -> TextId -> Bool
TextId -> TextId -> Ordering
TextId -> TextId -> TextId
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 :: TextId -> TextId -> Ordering
compare :: TextId -> TextId -> Ordering
$c< :: TextId -> TextId -> Bool
< :: TextId -> TextId -> Bool
$c<= :: TextId -> TextId -> Bool
<= :: TextId -> TextId -> Bool
$c> :: TextId -> TextId -> Bool
> :: TextId -> TextId -> Bool
$c>= :: TextId -> TextId -> Bool
>= :: TextId -> TextId -> Bool
$cmax :: TextId -> TextId -> TextId
max :: TextId -> TextId -> TextId
$cmin :: TextId -> TextId -> TextId
min :: TextId -> TextId -> TextId
Ord, Int -> TextId -> ShowS
[TextId] -> ShowS
TextId -> String
(Int -> TextId -> ShowS)
-> (TextId -> String) -> ([TextId] -> ShowS) -> Show TextId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TextId -> ShowS
showsPrec :: Int -> TextId -> ShowS
$cshow :: TextId -> String
show :: TextId -> String
$cshowList :: [TextId] -> ShowS
showList :: [TextId] -> ShowS
Show)
  deriving (Integer -> TextId
TextId -> TextId
TextId -> TextId -> TextId
(TextId -> TextId -> TextId)
-> (TextId -> TextId -> TextId)
-> (TextId -> TextId -> TextId)
-> (TextId -> TextId)
-> (TextId -> TextId)
-> (TextId -> TextId)
-> (Integer -> TextId)
-> Num TextId
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: TextId -> TextId -> TextId
+ :: TextId -> TextId -> TextId
$c- :: TextId -> TextId -> TextId
- :: TextId -> TextId -> TextId
$c* :: TextId -> TextId -> TextId
* :: TextId -> TextId -> TextId
$cnegate :: TextId -> TextId
negate :: TextId -> TextId
$cabs :: TextId -> TextId
abs :: TextId -> TextId
$csignum :: TextId -> TextId
signum :: TextId -> TextId
$cfromInteger :: Integer -> TextId
fromInteger :: Integer -> TextId
Num, Num TextId
Ord TextId
(Num TextId, Ord TextId) => (TextId -> Rational) -> Real TextId
TextId -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: TextId -> Rational
toRational :: TextId -> Rational
Real, Int -> TextId
TextId -> Int
TextId -> [TextId]
TextId -> TextId
TextId -> TextId -> [TextId]
TextId -> TextId -> TextId -> [TextId]
(TextId -> TextId)
-> (TextId -> TextId)
-> (Int -> TextId)
-> (TextId -> Int)
-> (TextId -> [TextId])
-> (TextId -> TextId -> [TextId])
-> (TextId -> TextId -> [TextId])
-> (TextId -> TextId -> TextId -> [TextId])
-> Enum TextId
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 :: TextId -> TextId
succ :: TextId -> TextId
$cpred :: TextId -> TextId
pred :: TextId -> TextId
$ctoEnum :: Int -> TextId
toEnum :: Int -> TextId
$cfromEnum :: TextId -> Int
fromEnum :: TextId -> Int
$cenumFrom :: TextId -> [TextId]
enumFrom :: TextId -> [TextId]
$cenumFromThen :: TextId -> TextId -> [TextId]
enumFromThen :: TextId -> TextId -> [TextId]
$cenumFromTo :: TextId -> TextId -> [TextId]
enumFromTo :: TextId -> TextId -> [TextId]
$cenumFromThenTo :: TextId -> TextId -> TextId -> [TextId]
enumFromThenTo :: TextId -> TextId -> TextId -> [TextId]
Enum, Enum TextId
Real TextId
(Real TextId, Enum TextId) =>
(TextId -> TextId -> TextId)
-> (TextId -> TextId -> TextId)
-> (TextId -> TextId -> TextId)
-> (TextId -> TextId -> TextId)
-> (TextId -> TextId -> (TextId, TextId))
-> (TextId -> TextId -> (TextId, TextId))
-> (TextId -> Integer)
-> Integral TextId
TextId -> Integer
TextId -> TextId -> (TextId, TextId)
TextId -> TextId -> TextId
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
$cquot :: TextId -> TextId -> TextId
quot :: TextId -> TextId -> TextId
$crem :: TextId -> TextId -> TextId
rem :: TextId -> TextId -> TextId
$cdiv :: TextId -> TextId -> TextId
div :: TextId -> TextId -> TextId
$cmod :: TextId -> TextId -> TextId
mod :: TextId -> TextId -> TextId
$cquotRem :: TextId -> TextId -> (TextId, TextId)
quotRem :: TextId -> TextId -> (TextId, TextId)
$cdivMod :: TextId -> TextId -> (TextId, TextId)
divMod :: TextId -> TextId -> (TextId, TextId)
$ctoInteger :: TextId -> Integer
toInteger :: TextId -> Integer
Integral, Eq TextId
TextId
Eq TextId =>
(TextId -> TextId -> TextId)
-> (TextId -> TextId -> TextId)
-> (TextId -> TextId -> TextId)
-> (TextId -> TextId)
-> (TextId -> Int -> TextId)
-> (TextId -> Int -> TextId)
-> TextId
-> (Int -> TextId)
-> (TextId -> Int -> TextId)
-> (TextId -> Int -> TextId)
-> (TextId -> Int -> TextId)
-> (TextId -> Int -> Bool)
-> (TextId -> Maybe Int)
-> (TextId -> Int)
-> (TextId -> Bool)
-> (TextId -> Int -> TextId)
-> (TextId -> Int -> TextId)
-> (TextId -> Int -> TextId)
-> (TextId -> Int -> TextId)
-> (TextId -> Int -> TextId)
-> (TextId -> Int -> TextId)
-> (TextId -> Int)
-> Bits TextId
Int -> TextId
TextId -> Bool
TextId -> Int
TextId -> Maybe Int
TextId -> TextId
TextId -> Int -> Bool
TextId -> Int -> TextId
TextId -> TextId -> TextId
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: TextId -> TextId -> TextId
.&. :: TextId -> TextId -> TextId
$c.|. :: TextId -> TextId -> TextId
.|. :: TextId -> TextId -> TextId
$cxor :: TextId -> TextId -> TextId
xor :: TextId -> TextId -> TextId
$ccomplement :: TextId -> TextId
complement :: TextId -> TextId
$cshift :: TextId -> Int -> TextId
shift :: TextId -> Int -> TextId
$crotate :: TextId -> Int -> TextId
rotate :: TextId -> Int -> TextId
$czeroBits :: TextId
zeroBits :: TextId
$cbit :: Int -> TextId
bit :: Int -> TextId
$csetBit :: TextId -> Int -> TextId
setBit :: TextId -> Int -> TextId
$cclearBit :: TextId -> Int -> TextId
clearBit :: TextId -> Int -> TextId
$ccomplementBit :: TextId -> Int -> TextId
complementBit :: TextId -> Int -> TextId
$ctestBit :: TextId -> Int -> Bool
testBit :: TextId -> Int -> Bool
$cbitSizeMaybe :: TextId -> Maybe Int
bitSizeMaybe :: TextId -> Maybe Int
$cbitSize :: TextId -> Int
bitSize :: TextId -> Int
$cisSigned :: TextId -> Bool
isSigned :: TextId -> Bool
$cshiftL :: TextId -> Int -> TextId
shiftL :: TextId -> Int -> TextId
$cunsafeShiftL :: TextId -> Int -> TextId
unsafeShiftL :: TextId -> Int -> TextId
$cshiftR :: TextId -> Int -> TextId
shiftR :: TextId -> Int -> TextId
$cunsafeShiftR :: TextId -> Int -> TextId
unsafeShiftR :: TextId -> Int -> TextId
$crotateL :: TextId -> Int -> TextId
rotateL :: TextId -> Int -> TextId
$crotateR :: TextId -> Int -> TextId
rotateR :: TextId -> Int -> TextId
$cpopCount :: TextId -> Int
popCount :: TextId -> Int
Bits, FieldParser TextId
FieldParser TextId -> FromField TextId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser TextId
fromField :: FieldParser TextId
FromField, TextId -> SQLData
(TextId -> SQLData) -> ToField TextId
forall a. (a -> SQLData) -> ToField a
$ctoField :: TextId -> SQLData
toField :: TextId -> SQLData
ToField) via Word64

newtype HashId = HashId Word64
  deriving (HashId -> HashId -> Bool
(HashId -> HashId -> Bool)
-> (HashId -> HashId -> Bool) -> Eq HashId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HashId -> HashId -> Bool
== :: HashId -> HashId -> Bool
$c/= :: HashId -> HashId -> Bool
/= :: HashId -> HashId -> Bool
Eq, Eq HashId
Eq HashId =>
(HashId -> HashId -> Ordering)
-> (HashId -> HashId -> Bool)
-> (HashId -> HashId -> Bool)
-> (HashId -> HashId -> Bool)
-> (HashId -> HashId -> Bool)
-> (HashId -> HashId -> HashId)
-> (HashId -> HashId -> HashId)
-> Ord HashId
HashId -> HashId -> Bool
HashId -> HashId -> Ordering
HashId -> HashId -> HashId
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 :: HashId -> HashId -> Ordering
compare :: HashId -> HashId -> Ordering
$c< :: HashId -> HashId -> Bool
< :: HashId -> HashId -> Bool
$c<= :: HashId -> HashId -> Bool
<= :: HashId -> HashId -> Bool
$c> :: HashId -> HashId -> Bool
> :: HashId -> HashId -> Bool
$c>= :: HashId -> HashId -> Bool
>= :: HashId -> HashId -> Bool
$cmax :: HashId -> HashId -> HashId
max :: HashId -> HashId -> HashId
$cmin :: HashId -> HashId -> HashId
min :: HashId -> HashId -> HashId
Ord, Int -> HashId -> ShowS
[HashId] -> ShowS
HashId -> String
(Int -> HashId -> ShowS)
-> (HashId -> String) -> ([HashId] -> ShowS) -> Show HashId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HashId -> ShowS
showsPrec :: Int -> HashId -> ShowS
$cshow :: HashId -> String
show :: HashId -> String
$cshowList :: [HashId] -> ShowS
showList :: [HashId] -> ShowS
Show)
  deriving (Integer -> HashId
HashId -> HashId
HashId -> HashId -> HashId
(HashId -> HashId -> HashId)
-> (HashId -> HashId -> HashId)
-> (HashId -> HashId -> HashId)
-> (HashId -> HashId)
-> (HashId -> HashId)
-> (HashId -> HashId)
-> (Integer -> HashId)
-> Num HashId
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: HashId -> HashId -> HashId
+ :: HashId -> HashId -> HashId
$c- :: HashId -> HashId -> HashId
- :: HashId -> HashId -> HashId
$c* :: HashId -> HashId -> HashId
* :: HashId -> HashId -> HashId
$cnegate :: HashId -> HashId
negate :: HashId -> HashId
$cabs :: HashId -> HashId
abs :: HashId -> HashId
$csignum :: HashId -> HashId
signum :: HashId -> HashId
$cfromInteger :: Integer -> HashId
fromInteger :: Integer -> HashId
Num, Num HashId
Ord HashId
(Num HashId, Ord HashId) => (HashId -> Rational) -> Real HashId
HashId -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: HashId -> Rational
toRational :: HashId -> Rational
Real, Int -> HashId
HashId -> Int
HashId -> [HashId]
HashId -> HashId
HashId -> HashId -> [HashId]
HashId -> HashId -> HashId -> [HashId]
(HashId -> HashId)
-> (HashId -> HashId)
-> (Int -> HashId)
-> (HashId -> Int)
-> (HashId -> [HashId])
-> (HashId -> HashId -> [HashId])
-> (HashId -> HashId -> [HashId])
-> (HashId -> HashId -> HashId -> [HashId])
-> Enum HashId
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 :: HashId -> HashId
succ :: HashId -> HashId
$cpred :: HashId -> HashId
pred :: HashId -> HashId
$ctoEnum :: Int -> HashId
toEnum :: Int -> HashId
$cfromEnum :: HashId -> Int
fromEnum :: HashId -> Int
$cenumFrom :: HashId -> [HashId]
enumFrom :: HashId -> [HashId]
$cenumFromThen :: HashId -> HashId -> [HashId]
enumFromThen :: HashId -> HashId -> [HashId]
$cenumFromTo :: HashId -> HashId -> [HashId]
enumFromTo :: HashId -> HashId -> [HashId]
$cenumFromThenTo :: HashId -> HashId -> HashId -> [HashId]
enumFromThenTo :: HashId -> HashId -> HashId -> [HashId]
Enum, Enum HashId
Real HashId
(Real HashId, Enum HashId) =>
(HashId -> HashId -> HashId)
-> (HashId -> HashId -> HashId)
-> (HashId -> HashId -> HashId)
-> (HashId -> HashId -> HashId)
-> (HashId -> HashId -> (HashId, HashId))
-> (HashId -> HashId -> (HashId, HashId))
-> (HashId -> Integer)
-> Integral HashId
HashId -> Integer
HashId -> HashId -> (HashId, HashId)
HashId -> HashId -> HashId
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
$cquot :: HashId -> HashId -> HashId
quot :: HashId -> HashId -> HashId
$crem :: HashId -> HashId -> HashId
rem :: HashId -> HashId -> HashId
$cdiv :: HashId -> HashId -> HashId
div :: HashId -> HashId -> HashId
$cmod :: HashId -> HashId -> HashId
mod :: HashId -> HashId -> HashId
$cquotRem :: HashId -> HashId -> (HashId, HashId)
quotRem :: HashId -> HashId -> (HashId, HashId)
$cdivMod :: HashId -> HashId -> (HashId, HashId)
divMod :: HashId -> HashId -> (HashId, HashId)
$ctoInteger :: HashId -> Integer
toInteger :: HashId -> Integer
Integral, Eq HashId
HashId
Eq HashId =>
(HashId -> HashId -> HashId)
-> (HashId -> HashId -> HashId)
-> (HashId -> HashId -> HashId)
-> (HashId -> HashId)
-> (HashId -> Int -> HashId)
-> (HashId -> Int -> HashId)
-> HashId
-> (Int -> HashId)
-> (HashId -> Int -> HashId)
-> (HashId -> Int -> HashId)
-> (HashId -> Int -> HashId)
-> (HashId -> Int -> Bool)
-> (HashId -> Maybe Int)
-> (HashId -> Int)
-> (HashId -> Bool)
-> (HashId -> Int -> HashId)
-> (HashId -> Int -> HashId)
-> (HashId -> Int -> HashId)
-> (HashId -> Int -> HashId)
-> (HashId -> Int -> HashId)
-> (HashId -> Int -> HashId)
-> (HashId -> Int)
-> Bits HashId
Int -> HashId
HashId -> Bool
HashId -> Int
HashId -> Maybe Int
HashId -> HashId
HashId -> Int -> Bool
HashId -> Int -> HashId
HashId -> HashId -> HashId
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: HashId -> HashId -> HashId
.&. :: HashId -> HashId -> HashId
$c.|. :: HashId -> HashId -> HashId
.|. :: HashId -> HashId -> HashId
$cxor :: HashId -> HashId -> HashId
xor :: HashId -> HashId -> HashId
$ccomplement :: HashId -> HashId
complement :: HashId -> HashId
$cshift :: HashId -> Int -> HashId
shift :: HashId -> Int -> HashId
$crotate :: HashId -> Int -> HashId
rotate :: HashId -> Int -> HashId
$czeroBits :: HashId
zeroBits :: HashId
$cbit :: Int -> HashId
bit :: Int -> HashId
$csetBit :: HashId -> Int -> HashId
setBit :: HashId -> Int -> HashId
$cclearBit :: HashId -> Int -> HashId
clearBit :: HashId -> Int -> HashId
$ccomplementBit :: HashId -> Int -> HashId
complementBit :: HashId -> Int -> HashId
$ctestBit :: HashId -> Int -> Bool
testBit :: HashId -> Int -> Bool
$cbitSizeMaybe :: HashId -> Maybe Int
bitSizeMaybe :: HashId -> Maybe Int
$cbitSize :: HashId -> Int
bitSize :: HashId -> Int
$cisSigned :: HashId -> Bool
isSigned :: HashId -> Bool
$cshiftL :: HashId -> Int -> HashId
shiftL :: HashId -> Int -> HashId
$cunsafeShiftL :: HashId -> Int -> HashId
unsafeShiftL :: HashId -> Int -> HashId
$cshiftR :: HashId -> Int -> HashId
shiftR :: HashId -> Int -> HashId
$cunsafeShiftR :: HashId -> Int -> HashId
unsafeShiftR :: HashId -> Int -> HashId
$crotateL :: HashId -> Int -> HashId
rotateL :: HashId -> Int -> HashId
$crotateR :: HashId -> Int -> HashId
rotateR :: HashId -> Int -> HashId
$cpopCount :: HashId -> Int
popCount :: HashId -> Int
Bits, FieldParser HashId
FieldParser HashId -> FromField HashId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser HashId
fromField :: FieldParser HashId
FromField, HashId -> SQLData
(HashId -> SQLData) -> ToField HashId
forall a. (a -> SQLData) -> ToField a
$ctoField :: HashId -> SQLData
toField :: HashId -> SQLData
ToField) via Word64

newtype PatchObjectId = PatchObjectId {PatchObjectId -> ObjectId
unPatchObjectId :: ObjectId}
  deriving (PatchObjectId -> PatchObjectId -> Bool
(PatchObjectId -> PatchObjectId -> Bool)
-> (PatchObjectId -> PatchObjectId -> Bool) -> Eq PatchObjectId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PatchObjectId -> PatchObjectId -> Bool
== :: PatchObjectId -> PatchObjectId -> Bool
$c/= :: PatchObjectId -> PatchObjectId -> Bool
/= :: PatchObjectId -> PatchObjectId -> Bool
Eq, Eq PatchObjectId
Eq PatchObjectId =>
(PatchObjectId -> PatchObjectId -> Ordering)
-> (PatchObjectId -> PatchObjectId -> Bool)
-> (PatchObjectId -> PatchObjectId -> Bool)
-> (PatchObjectId -> PatchObjectId -> Bool)
-> (PatchObjectId -> PatchObjectId -> Bool)
-> (PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId -> PatchObjectId)
-> Ord PatchObjectId
PatchObjectId -> PatchObjectId -> Bool
PatchObjectId -> PatchObjectId -> Ordering
PatchObjectId -> PatchObjectId -> PatchObjectId
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 :: PatchObjectId -> PatchObjectId -> Ordering
compare :: PatchObjectId -> PatchObjectId -> Ordering
$c< :: PatchObjectId -> PatchObjectId -> Bool
< :: PatchObjectId -> PatchObjectId -> Bool
$c<= :: PatchObjectId -> PatchObjectId -> Bool
<= :: PatchObjectId -> PatchObjectId -> Bool
$c> :: PatchObjectId -> PatchObjectId -> Bool
> :: PatchObjectId -> PatchObjectId -> Bool
$c>= :: PatchObjectId -> PatchObjectId -> Bool
>= :: PatchObjectId -> PatchObjectId -> Bool
$cmax :: PatchObjectId -> PatchObjectId -> PatchObjectId
max :: PatchObjectId -> PatchObjectId -> PatchObjectId
$cmin :: PatchObjectId -> PatchObjectId -> PatchObjectId
min :: PatchObjectId -> PatchObjectId -> PatchObjectId
Ord)
  deriving (Integer -> PatchObjectId
PatchObjectId -> PatchObjectId
PatchObjectId -> PatchObjectId -> PatchObjectId
(PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId)
-> (Integer -> PatchObjectId)
-> Num PatchObjectId
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: PatchObjectId -> PatchObjectId -> PatchObjectId
+ :: PatchObjectId -> PatchObjectId -> PatchObjectId
$c- :: PatchObjectId -> PatchObjectId -> PatchObjectId
- :: PatchObjectId -> PatchObjectId -> PatchObjectId
$c* :: PatchObjectId -> PatchObjectId -> PatchObjectId
* :: PatchObjectId -> PatchObjectId -> PatchObjectId
$cnegate :: PatchObjectId -> PatchObjectId
negate :: PatchObjectId -> PatchObjectId
$cabs :: PatchObjectId -> PatchObjectId
abs :: PatchObjectId -> PatchObjectId
$csignum :: PatchObjectId -> PatchObjectId
signum :: PatchObjectId -> PatchObjectId
$cfromInteger :: Integer -> PatchObjectId
fromInteger :: Integer -> PatchObjectId
Num, Num PatchObjectId
Ord PatchObjectId
(Num PatchObjectId, Ord PatchObjectId) =>
(PatchObjectId -> Rational) -> Real PatchObjectId
PatchObjectId -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: PatchObjectId -> Rational
toRational :: PatchObjectId -> Rational
Real, Int -> PatchObjectId
PatchObjectId -> Int
PatchObjectId -> [PatchObjectId]
PatchObjectId -> PatchObjectId
PatchObjectId -> PatchObjectId -> [PatchObjectId]
PatchObjectId -> PatchObjectId -> PatchObjectId -> [PatchObjectId]
(PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId)
-> (Int -> PatchObjectId)
-> (PatchObjectId -> Int)
-> (PatchObjectId -> [PatchObjectId])
-> (PatchObjectId -> PatchObjectId -> [PatchObjectId])
-> (PatchObjectId -> PatchObjectId -> [PatchObjectId])
-> (PatchObjectId
    -> PatchObjectId -> PatchObjectId -> [PatchObjectId])
-> Enum PatchObjectId
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 :: PatchObjectId -> PatchObjectId
succ :: PatchObjectId -> PatchObjectId
$cpred :: PatchObjectId -> PatchObjectId
pred :: PatchObjectId -> PatchObjectId
$ctoEnum :: Int -> PatchObjectId
toEnum :: Int -> PatchObjectId
$cfromEnum :: PatchObjectId -> Int
fromEnum :: PatchObjectId -> Int
$cenumFrom :: PatchObjectId -> [PatchObjectId]
enumFrom :: PatchObjectId -> [PatchObjectId]
$cenumFromThen :: PatchObjectId -> PatchObjectId -> [PatchObjectId]
enumFromThen :: PatchObjectId -> PatchObjectId -> [PatchObjectId]
$cenumFromTo :: PatchObjectId -> PatchObjectId -> [PatchObjectId]
enumFromTo :: PatchObjectId -> PatchObjectId -> [PatchObjectId]
$cenumFromThenTo :: PatchObjectId -> PatchObjectId -> PatchObjectId -> [PatchObjectId]
enumFromThenTo :: PatchObjectId -> PatchObjectId -> PatchObjectId -> [PatchObjectId]
Enum, Enum PatchObjectId
Real PatchObjectId
(Real PatchObjectId, Enum PatchObjectId) =>
(PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId
    -> PatchObjectId -> (PatchObjectId, PatchObjectId))
-> (PatchObjectId
    -> PatchObjectId -> (PatchObjectId, PatchObjectId))
-> (PatchObjectId -> Integer)
-> Integral PatchObjectId
PatchObjectId -> Integer
PatchObjectId -> PatchObjectId -> (PatchObjectId, PatchObjectId)
PatchObjectId -> PatchObjectId -> PatchObjectId
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
$cquot :: PatchObjectId -> PatchObjectId -> PatchObjectId
quot :: PatchObjectId -> PatchObjectId -> PatchObjectId
$crem :: PatchObjectId -> PatchObjectId -> PatchObjectId
rem :: PatchObjectId -> PatchObjectId -> PatchObjectId
$cdiv :: PatchObjectId -> PatchObjectId -> PatchObjectId
div :: PatchObjectId -> PatchObjectId -> PatchObjectId
$cmod :: PatchObjectId -> PatchObjectId -> PatchObjectId
mod :: PatchObjectId -> PatchObjectId -> PatchObjectId
$cquotRem :: PatchObjectId -> PatchObjectId -> (PatchObjectId, PatchObjectId)
quotRem :: PatchObjectId -> PatchObjectId -> (PatchObjectId, PatchObjectId)
$cdivMod :: PatchObjectId -> PatchObjectId -> (PatchObjectId, PatchObjectId)
divMod :: PatchObjectId -> PatchObjectId -> (PatchObjectId, PatchObjectId)
$ctoInteger :: PatchObjectId -> Integer
toInteger :: PatchObjectId -> Integer
Integral, Eq PatchObjectId
PatchObjectId
Eq PatchObjectId =>
(PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> PatchObjectId)
-> (PatchObjectId -> Int -> PatchObjectId)
-> (PatchObjectId -> Int -> PatchObjectId)
-> PatchObjectId
-> (Int -> PatchObjectId)
-> (PatchObjectId -> Int -> PatchObjectId)
-> (PatchObjectId -> Int -> PatchObjectId)
-> (PatchObjectId -> Int -> PatchObjectId)
-> (PatchObjectId -> Int -> Bool)
-> (PatchObjectId -> Maybe Int)
-> (PatchObjectId -> Int)
-> (PatchObjectId -> Bool)
-> (PatchObjectId -> Int -> PatchObjectId)
-> (PatchObjectId -> Int -> PatchObjectId)
-> (PatchObjectId -> Int -> PatchObjectId)
-> (PatchObjectId -> Int -> PatchObjectId)
-> (PatchObjectId -> Int -> PatchObjectId)
-> (PatchObjectId -> Int -> PatchObjectId)
-> (PatchObjectId -> Int)
-> Bits PatchObjectId
Int -> PatchObjectId
PatchObjectId -> Bool
PatchObjectId -> Int
PatchObjectId -> Maybe Int
PatchObjectId -> PatchObjectId
PatchObjectId -> Int -> Bool
PatchObjectId -> Int -> PatchObjectId
PatchObjectId -> PatchObjectId -> PatchObjectId
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: PatchObjectId -> PatchObjectId -> PatchObjectId
.&. :: PatchObjectId -> PatchObjectId -> PatchObjectId
$c.|. :: PatchObjectId -> PatchObjectId -> PatchObjectId
.|. :: PatchObjectId -> PatchObjectId -> PatchObjectId
$cxor :: PatchObjectId -> PatchObjectId -> PatchObjectId
xor :: PatchObjectId -> PatchObjectId -> PatchObjectId
$ccomplement :: PatchObjectId -> PatchObjectId
complement :: PatchObjectId -> PatchObjectId
$cshift :: PatchObjectId -> Int -> PatchObjectId
shift :: PatchObjectId -> Int -> PatchObjectId
$crotate :: PatchObjectId -> Int -> PatchObjectId
rotate :: PatchObjectId -> Int -> PatchObjectId
$czeroBits :: PatchObjectId
zeroBits :: PatchObjectId
$cbit :: Int -> PatchObjectId
bit :: Int -> PatchObjectId
$csetBit :: PatchObjectId -> Int -> PatchObjectId
setBit :: PatchObjectId -> Int -> PatchObjectId
$cclearBit :: PatchObjectId -> Int -> PatchObjectId
clearBit :: PatchObjectId -> Int -> PatchObjectId
$ccomplementBit :: PatchObjectId -> Int -> PatchObjectId
complementBit :: PatchObjectId -> Int -> PatchObjectId
$ctestBit :: PatchObjectId -> Int -> Bool
testBit :: PatchObjectId -> Int -> Bool
$cbitSizeMaybe :: PatchObjectId -> Maybe Int
bitSizeMaybe :: PatchObjectId -> Maybe Int
$cbitSize :: PatchObjectId -> Int
bitSize :: PatchObjectId -> Int
$cisSigned :: PatchObjectId -> Bool
isSigned :: PatchObjectId -> Bool
$cshiftL :: PatchObjectId -> Int -> PatchObjectId
shiftL :: PatchObjectId -> Int -> PatchObjectId
$cunsafeShiftL :: PatchObjectId -> Int -> PatchObjectId
unsafeShiftL :: PatchObjectId -> Int -> PatchObjectId
$cshiftR :: PatchObjectId -> Int -> PatchObjectId
shiftR :: PatchObjectId -> Int -> PatchObjectId
$cunsafeShiftR :: PatchObjectId -> Int -> PatchObjectId
unsafeShiftR :: PatchObjectId -> Int -> PatchObjectId
$crotateL :: PatchObjectId -> Int -> PatchObjectId
rotateL :: PatchObjectId -> Int -> PatchObjectId
$crotateR :: PatchObjectId -> Int -> PatchObjectId
rotateR :: PatchObjectId -> Int -> PatchObjectId
$cpopCount :: PatchObjectId -> Int
popCount :: PatchObjectId -> Int
Bits, FieldParser PatchObjectId
FieldParser PatchObjectId -> FromField PatchObjectId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser PatchObjectId
fromField :: FieldParser PatchObjectId
FromField, PatchObjectId -> SQLData
(PatchObjectId -> SQLData) -> ToField PatchObjectId
forall a. (a -> SQLData) -> ToField a
$ctoField :: PatchObjectId -> SQLData
toField :: PatchObjectId -> SQLData
ToField) via ObjectId

newtype BranchObjectId = BranchObjectId {BranchObjectId -> ObjectId
unBranchObjectId :: ObjectId}
  deriving (BranchObjectId -> BranchObjectId -> Bool
(BranchObjectId -> BranchObjectId -> Bool)
-> (BranchObjectId -> BranchObjectId -> Bool) -> Eq BranchObjectId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BranchObjectId -> BranchObjectId -> Bool
== :: BranchObjectId -> BranchObjectId -> Bool
$c/= :: BranchObjectId -> BranchObjectId -> Bool
/= :: BranchObjectId -> BranchObjectId -> Bool
Eq, Eq BranchObjectId
Eq BranchObjectId =>
(BranchObjectId -> BranchObjectId -> Ordering)
-> (BranchObjectId -> BranchObjectId -> Bool)
-> (BranchObjectId -> BranchObjectId -> Bool)
-> (BranchObjectId -> BranchObjectId -> Bool)
-> (BranchObjectId -> BranchObjectId -> Bool)
-> (BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId -> BranchObjectId)
-> Ord BranchObjectId
BranchObjectId -> BranchObjectId -> Bool
BranchObjectId -> BranchObjectId -> Ordering
BranchObjectId -> BranchObjectId -> BranchObjectId
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 :: BranchObjectId -> BranchObjectId -> Ordering
compare :: BranchObjectId -> BranchObjectId -> Ordering
$c< :: BranchObjectId -> BranchObjectId -> Bool
< :: BranchObjectId -> BranchObjectId -> Bool
$c<= :: BranchObjectId -> BranchObjectId -> Bool
<= :: BranchObjectId -> BranchObjectId -> Bool
$c> :: BranchObjectId -> BranchObjectId -> Bool
> :: BranchObjectId -> BranchObjectId -> Bool
$c>= :: BranchObjectId -> BranchObjectId -> Bool
>= :: BranchObjectId -> BranchObjectId -> Bool
$cmax :: BranchObjectId -> BranchObjectId -> BranchObjectId
max :: BranchObjectId -> BranchObjectId -> BranchObjectId
$cmin :: BranchObjectId -> BranchObjectId -> BranchObjectId
min :: BranchObjectId -> BranchObjectId -> BranchObjectId
Ord)
  deriving (Integer -> BranchObjectId
BranchObjectId -> BranchObjectId
BranchObjectId -> BranchObjectId -> BranchObjectId
(BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId)
-> (Integer -> BranchObjectId)
-> Num BranchObjectId
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: BranchObjectId -> BranchObjectId -> BranchObjectId
+ :: BranchObjectId -> BranchObjectId -> BranchObjectId
$c- :: BranchObjectId -> BranchObjectId -> BranchObjectId
- :: BranchObjectId -> BranchObjectId -> BranchObjectId
$c* :: BranchObjectId -> BranchObjectId -> BranchObjectId
* :: BranchObjectId -> BranchObjectId -> BranchObjectId
$cnegate :: BranchObjectId -> BranchObjectId
negate :: BranchObjectId -> BranchObjectId
$cabs :: BranchObjectId -> BranchObjectId
abs :: BranchObjectId -> BranchObjectId
$csignum :: BranchObjectId -> BranchObjectId
signum :: BranchObjectId -> BranchObjectId
$cfromInteger :: Integer -> BranchObjectId
fromInteger :: Integer -> BranchObjectId
Num, Num BranchObjectId
Ord BranchObjectId
(Num BranchObjectId, Ord BranchObjectId) =>
(BranchObjectId -> Rational) -> Real BranchObjectId
BranchObjectId -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: BranchObjectId -> Rational
toRational :: BranchObjectId -> Rational
Real, Int -> BranchObjectId
BranchObjectId -> Int
BranchObjectId -> [BranchObjectId]
BranchObjectId -> BranchObjectId
BranchObjectId -> BranchObjectId -> [BranchObjectId]
BranchObjectId
-> BranchObjectId -> BranchObjectId -> [BranchObjectId]
(BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId)
-> (Int -> BranchObjectId)
-> (BranchObjectId -> Int)
-> (BranchObjectId -> [BranchObjectId])
-> (BranchObjectId -> BranchObjectId -> [BranchObjectId])
-> (BranchObjectId -> BranchObjectId -> [BranchObjectId])
-> (BranchObjectId
    -> BranchObjectId -> BranchObjectId -> [BranchObjectId])
-> Enum BranchObjectId
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 :: BranchObjectId -> BranchObjectId
succ :: BranchObjectId -> BranchObjectId
$cpred :: BranchObjectId -> BranchObjectId
pred :: BranchObjectId -> BranchObjectId
$ctoEnum :: Int -> BranchObjectId
toEnum :: Int -> BranchObjectId
$cfromEnum :: BranchObjectId -> Int
fromEnum :: BranchObjectId -> Int
$cenumFrom :: BranchObjectId -> [BranchObjectId]
enumFrom :: BranchObjectId -> [BranchObjectId]
$cenumFromThen :: BranchObjectId -> BranchObjectId -> [BranchObjectId]
enumFromThen :: BranchObjectId -> BranchObjectId -> [BranchObjectId]
$cenumFromTo :: BranchObjectId -> BranchObjectId -> [BranchObjectId]
enumFromTo :: BranchObjectId -> BranchObjectId -> [BranchObjectId]
$cenumFromThenTo :: BranchObjectId
-> BranchObjectId -> BranchObjectId -> [BranchObjectId]
enumFromThenTo :: BranchObjectId
-> BranchObjectId -> BranchObjectId -> [BranchObjectId]
Enum, Enum BranchObjectId
Real BranchObjectId
(Real BranchObjectId, Enum BranchObjectId) =>
(BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId
    -> BranchObjectId -> (BranchObjectId, BranchObjectId))
-> (BranchObjectId
    -> BranchObjectId -> (BranchObjectId, BranchObjectId))
-> (BranchObjectId -> Integer)
-> Integral BranchObjectId
BranchObjectId -> Integer
BranchObjectId
-> BranchObjectId -> (BranchObjectId, BranchObjectId)
BranchObjectId -> BranchObjectId -> BranchObjectId
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
$cquot :: BranchObjectId -> BranchObjectId -> BranchObjectId
quot :: BranchObjectId -> BranchObjectId -> BranchObjectId
$crem :: BranchObjectId -> BranchObjectId -> BranchObjectId
rem :: BranchObjectId -> BranchObjectId -> BranchObjectId
$cdiv :: BranchObjectId -> BranchObjectId -> BranchObjectId
div :: BranchObjectId -> BranchObjectId -> BranchObjectId
$cmod :: BranchObjectId -> BranchObjectId -> BranchObjectId
mod :: BranchObjectId -> BranchObjectId -> BranchObjectId
$cquotRem :: BranchObjectId
-> BranchObjectId -> (BranchObjectId, BranchObjectId)
quotRem :: BranchObjectId
-> BranchObjectId -> (BranchObjectId, BranchObjectId)
$cdivMod :: BranchObjectId
-> BranchObjectId -> (BranchObjectId, BranchObjectId)
divMod :: BranchObjectId
-> BranchObjectId -> (BranchObjectId, BranchObjectId)
$ctoInteger :: BranchObjectId -> Integer
toInteger :: BranchObjectId -> Integer
Integral, Eq BranchObjectId
BranchObjectId
Eq BranchObjectId =>
(BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> BranchObjectId)
-> (BranchObjectId -> Int -> BranchObjectId)
-> (BranchObjectId -> Int -> BranchObjectId)
-> BranchObjectId
-> (Int -> BranchObjectId)
-> (BranchObjectId -> Int -> BranchObjectId)
-> (BranchObjectId -> Int -> BranchObjectId)
-> (BranchObjectId -> Int -> BranchObjectId)
-> (BranchObjectId -> Int -> Bool)
-> (BranchObjectId -> Maybe Int)
-> (BranchObjectId -> Int)
-> (BranchObjectId -> Bool)
-> (BranchObjectId -> Int -> BranchObjectId)
-> (BranchObjectId -> Int -> BranchObjectId)
-> (BranchObjectId -> Int -> BranchObjectId)
-> (BranchObjectId -> Int -> BranchObjectId)
-> (BranchObjectId -> Int -> BranchObjectId)
-> (BranchObjectId -> Int -> BranchObjectId)
-> (BranchObjectId -> Int)
-> Bits BranchObjectId
Int -> BranchObjectId
BranchObjectId -> Bool
BranchObjectId -> Int
BranchObjectId -> Maybe Int
BranchObjectId -> BranchObjectId
BranchObjectId -> Int -> Bool
BranchObjectId -> Int -> BranchObjectId
BranchObjectId -> BranchObjectId -> BranchObjectId
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: BranchObjectId -> BranchObjectId -> BranchObjectId
.&. :: BranchObjectId -> BranchObjectId -> BranchObjectId
$c.|. :: BranchObjectId -> BranchObjectId -> BranchObjectId
.|. :: BranchObjectId -> BranchObjectId -> BranchObjectId
$cxor :: BranchObjectId -> BranchObjectId -> BranchObjectId
xor :: BranchObjectId -> BranchObjectId -> BranchObjectId
$ccomplement :: BranchObjectId -> BranchObjectId
complement :: BranchObjectId -> BranchObjectId
$cshift :: BranchObjectId -> Int -> BranchObjectId
shift :: BranchObjectId -> Int -> BranchObjectId
$crotate :: BranchObjectId -> Int -> BranchObjectId
rotate :: BranchObjectId -> Int -> BranchObjectId
$czeroBits :: BranchObjectId
zeroBits :: BranchObjectId
$cbit :: Int -> BranchObjectId
bit :: Int -> BranchObjectId
$csetBit :: BranchObjectId -> Int -> BranchObjectId
setBit :: BranchObjectId -> Int -> BranchObjectId
$cclearBit :: BranchObjectId -> Int -> BranchObjectId
clearBit :: BranchObjectId -> Int -> BranchObjectId
$ccomplementBit :: BranchObjectId -> Int -> BranchObjectId
complementBit :: BranchObjectId -> Int -> BranchObjectId
$ctestBit :: BranchObjectId -> Int -> Bool
testBit :: BranchObjectId -> Int -> Bool
$cbitSizeMaybe :: BranchObjectId -> Maybe Int
bitSizeMaybe :: BranchObjectId -> Maybe Int
$cbitSize :: BranchObjectId -> Int
bitSize :: BranchObjectId -> Int
$cisSigned :: BranchObjectId -> Bool
isSigned :: BranchObjectId -> Bool
$cshiftL :: BranchObjectId -> Int -> BranchObjectId
shiftL :: BranchObjectId -> Int -> BranchObjectId
$cunsafeShiftL :: BranchObjectId -> Int -> BranchObjectId
unsafeShiftL :: BranchObjectId -> Int -> BranchObjectId
$cshiftR :: BranchObjectId -> Int -> BranchObjectId
shiftR :: BranchObjectId -> Int -> BranchObjectId
$cunsafeShiftR :: BranchObjectId -> Int -> BranchObjectId
unsafeShiftR :: BranchObjectId -> Int -> BranchObjectId
$crotateL :: BranchObjectId -> Int -> BranchObjectId
rotateL :: BranchObjectId -> Int -> BranchObjectId
$crotateR :: BranchObjectId -> Int -> BranchObjectId
rotateR :: BranchObjectId -> Int -> BranchObjectId
$cpopCount :: BranchObjectId -> Int
popCount :: BranchObjectId -> Int
Bits, FieldParser BranchObjectId
FieldParser BranchObjectId -> FromField BranchObjectId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser BranchObjectId
fromField :: FieldParser BranchObjectId
FromField, BranchObjectId -> SQLData
(BranchObjectId -> SQLData) -> ToField BranchObjectId
forall a. (a -> SQLData) -> ToField a
$ctoField :: BranchObjectId -> SQLData
toField :: BranchObjectId -> SQLData
ToField) via ObjectId

newtype BranchHashId = BranchHashId {BranchHashId -> HashId
unBranchHashId :: HashId}
  deriving (BranchHashId -> BranchHashId -> Bool
(BranchHashId -> BranchHashId -> Bool)
-> (BranchHashId -> BranchHashId -> Bool) -> Eq BranchHashId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BranchHashId -> BranchHashId -> Bool
== :: BranchHashId -> BranchHashId -> Bool
$c/= :: BranchHashId -> BranchHashId -> Bool
/= :: BranchHashId -> BranchHashId -> Bool
Eq, Eq BranchHashId
Eq BranchHashId =>
(BranchHashId -> BranchHashId -> Ordering)
-> (BranchHashId -> BranchHashId -> Bool)
-> (BranchHashId -> BranchHashId -> Bool)
-> (BranchHashId -> BranchHashId -> Bool)
-> (BranchHashId -> BranchHashId -> Bool)
-> (BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId -> BranchHashId)
-> Ord BranchHashId
BranchHashId -> BranchHashId -> Bool
BranchHashId -> BranchHashId -> Ordering
BranchHashId -> BranchHashId -> BranchHashId
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 :: BranchHashId -> BranchHashId -> Ordering
compare :: BranchHashId -> BranchHashId -> Ordering
$c< :: BranchHashId -> BranchHashId -> Bool
< :: BranchHashId -> BranchHashId -> Bool
$c<= :: BranchHashId -> BranchHashId -> Bool
<= :: BranchHashId -> BranchHashId -> Bool
$c> :: BranchHashId -> BranchHashId -> Bool
> :: BranchHashId -> BranchHashId -> Bool
$c>= :: BranchHashId -> BranchHashId -> Bool
>= :: BranchHashId -> BranchHashId -> Bool
$cmax :: BranchHashId -> BranchHashId -> BranchHashId
max :: BranchHashId -> BranchHashId -> BranchHashId
$cmin :: BranchHashId -> BranchHashId -> BranchHashId
min :: BranchHashId -> BranchHashId -> BranchHashId
Ord)
  deriving (Integer -> BranchHashId
BranchHashId -> BranchHashId
BranchHashId -> BranchHashId -> BranchHashId
(BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId)
-> (Integer -> BranchHashId)
-> Num BranchHashId
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: BranchHashId -> BranchHashId -> BranchHashId
+ :: BranchHashId -> BranchHashId -> BranchHashId
$c- :: BranchHashId -> BranchHashId -> BranchHashId
- :: BranchHashId -> BranchHashId -> BranchHashId
$c* :: BranchHashId -> BranchHashId -> BranchHashId
* :: BranchHashId -> BranchHashId -> BranchHashId
$cnegate :: BranchHashId -> BranchHashId
negate :: BranchHashId -> BranchHashId
$cabs :: BranchHashId -> BranchHashId
abs :: BranchHashId -> BranchHashId
$csignum :: BranchHashId -> BranchHashId
signum :: BranchHashId -> BranchHashId
$cfromInteger :: Integer -> BranchHashId
fromInteger :: Integer -> BranchHashId
Num, Num BranchHashId
Ord BranchHashId
(Num BranchHashId, Ord BranchHashId) =>
(BranchHashId -> Rational) -> Real BranchHashId
BranchHashId -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: BranchHashId -> Rational
toRational :: BranchHashId -> Rational
Real, Int -> BranchHashId
BranchHashId -> Int
BranchHashId -> [BranchHashId]
BranchHashId -> BranchHashId
BranchHashId -> BranchHashId -> [BranchHashId]
BranchHashId -> BranchHashId -> BranchHashId -> [BranchHashId]
(BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId)
-> (Int -> BranchHashId)
-> (BranchHashId -> Int)
-> (BranchHashId -> [BranchHashId])
-> (BranchHashId -> BranchHashId -> [BranchHashId])
-> (BranchHashId -> BranchHashId -> [BranchHashId])
-> (BranchHashId -> BranchHashId -> BranchHashId -> [BranchHashId])
-> Enum BranchHashId
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 :: BranchHashId -> BranchHashId
succ :: BranchHashId -> BranchHashId
$cpred :: BranchHashId -> BranchHashId
pred :: BranchHashId -> BranchHashId
$ctoEnum :: Int -> BranchHashId
toEnum :: Int -> BranchHashId
$cfromEnum :: BranchHashId -> Int
fromEnum :: BranchHashId -> Int
$cenumFrom :: BranchHashId -> [BranchHashId]
enumFrom :: BranchHashId -> [BranchHashId]
$cenumFromThen :: BranchHashId -> BranchHashId -> [BranchHashId]
enumFromThen :: BranchHashId -> BranchHashId -> [BranchHashId]
$cenumFromTo :: BranchHashId -> BranchHashId -> [BranchHashId]
enumFromTo :: BranchHashId -> BranchHashId -> [BranchHashId]
$cenumFromThenTo :: BranchHashId -> BranchHashId -> BranchHashId -> [BranchHashId]
enumFromThenTo :: BranchHashId -> BranchHashId -> BranchHashId -> [BranchHashId]
Enum, Enum BranchHashId
Real BranchHashId
(Real BranchHashId, Enum BranchHashId) =>
(BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId -> (BranchHashId, BranchHashId))
-> (BranchHashId -> BranchHashId -> (BranchHashId, BranchHashId))
-> (BranchHashId -> Integer)
-> Integral BranchHashId
BranchHashId -> Integer
BranchHashId -> BranchHashId -> (BranchHashId, BranchHashId)
BranchHashId -> BranchHashId -> BranchHashId
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
$cquot :: BranchHashId -> BranchHashId -> BranchHashId
quot :: BranchHashId -> BranchHashId -> BranchHashId
$crem :: BranchHashId -> BranchHashId -> BranchHashId
rem :: BranchHashId -> BranchHashId -> BranchHashId
$cdiv :: BranchHashId -> BranchHashId -> BranchHashId
div :: BranchHashId -> BranchHashId -> BranchHashId
$cmod :: BranchHashId -> BranchHashId -> BranchHashId
mod :: BranchHashId -> BranchHashId -> BranchHashId
$cquotRem :: BranchHashId -> BranchHashId -> (BranchHashId, BranchHashId)
quotRem :: BranchHashId -> BranchHashId -> (BranchHashId, BranchHashId)
$cdivMod :: BranchHashId -> BranchHashId -> (BranchHashId, BranchHashId)
divMod :: BranchHashId -> BranchHashId -> (BranchHashId, BranchHashId)
$ctoInteger :: BranchHashId -> Integer
toInteger :: BranchHashId -> Integer
Integral, Eq BranchHashId
BranchHashId
Eq BranchHashId =>
(BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId -> BranchHashId)
-> (BranchHashId -> BranchHashId)
-> (BranchHashId -> Int -> BranchHashId)
-> (BranchHashId -> Int -> BranchHashId)
-> BranchHashId
-> (Int -> BranchHashId)
-> (BranchHashId -> Int -> BranchHashId)
-> (BranchHashId -> Int -> BranchHashId)
-> (BranchHashId -> Int -> BranchHashId)
-> (BranchHashId -> Int -> Bool)
-> (BranchHashId -> Maybe Int)
-> (BranchHashId -> Int)
-> (BranchHashId -> Bool)
-> (BranchHashId -> Int -> BranchHashId)
-> (BranchHashId -> Int -> BranchHashId)
-> (BranchHashId -> Int -> BranchHashId)
-> (BranchHashId -> Int -> BranchHashId)
-> (BranchHashId -> Int -> BranchHashId)
-> (BranchHashId -> Int -> BranchHashId)
-> (BranchHashId -> Int)
-> Bits BranchHashId
Int -> BranchHashId
BranchHashId -> Bool
BranchHashId -> Int
BranchHashId -> Maybe Int
BranchHashId -> BranchHashId
BranchHashId -> Int -> Bool
BranchHashId -> Int -> BranchHashId
BranchHashId -> BranchHashId -> BranchHashId
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: BranchHashId -> BranchHashId -> BranchHashId
.&. :: BranchHashId -> BranchHashId -> BranchHashId
$c.|. :: BranchHashId -> BranchHashId -> BranchHashId
.|. :: BranchHashId -> BranchHashId -> BranchHashId
$cxor :: BranchHashId -> BranchHashId -> BranchHashId
xor :: BranchHashId -> BranchHashId -> BranchHashId
$ccomplement :: BranchHashId -> BranchHashId
complement :: BranchHashId -> BranchHashId
$cshift :: BranchHashId -> Int -> BranchHashId
shift :: BranchHashId -> Int -> BranchHashId
$crotate :: BranchHashId -> Int -> BranchHashId
rotate :: BranchHashId -> Int -> BranchHashId
$czeroBits :: BranchHashId
zeroBits :: BranchHashId
$cbit :: Int -> BranchHashId
bit :: Int -> BranchHashId
$csetBit :: BranchHashId -> Int -> BranchHashId
setBit :: BranchHashId -> Int -> BranchHashId
$cclearBit :: BranchHashId -> Int -> BranchHashId
clearBit :: BranchHashId -> Int -> BranchHashId
$ccomplementBit :: BranchHashId -> Int -> BranchHashId
complementBit :: BranchHashId -> Int -> BranchHashId
$ctestBit :: BranchHashId -> Int -> Bool
testBit :: BranchHashId -> Int -> Bool
$cbitSizeMaybe :: BranchHashId -> Maybe Int
bitSizeMaybe :: BranchHashId -> Maybe Int
$cbitSize :: BranchHashId -> Int
bitSize :: BranchHashId -> Int
$cisSigned :: BranchHashId -> Bool
isSigned :: BranchHashId -> Bool
$cshiftL :: BranchHashId -> Int -> BranchHashId
shiftL :: BranchHashId -> Int -> BranchHashId
$cunsafeShiftL :: BranchHashId -> Int -> BranchHashId
unsafeShiftL :: BranchHashId -> Int -> BranchHashId
$cshiftR :: BranchHashId -> Int -> BranchHashId
shiftR :: BranchHashId -> Int -> BranchHashId
$cunsafeShiftR :: BranchHashId -> Int -> BranchHashId
unsafeShiftR :: BranchHashId -> Int -> BranchHashId
$crotateL :: BranchHashId -> Int -> BranchHashId
rotateL :: BranchHashId -> Int -> BranchHashId
$crotateR :: BranchHashId -> Int -> BranchHashId
rotateR :: BranchHashId -> Int -> BranchHashId
$cpopCount :: BranchHashId -> Int
popCount :: BranchHashId -> Int
Bits, FieldParser BranchHashId
FieldParser BranchHashId -> FromField BranchHashId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser BranchHashId
fromField :: FieldParser BranchHashId
FromField, BranchHashId -> SQLData
(BranchHashId -> SQLData) -> ToField BranchHashId
forall a. (a -> SQLData) -> ToField a
$ctoField :: BranchHashId -> SQLData
toField :: BranchHashId -> SQLData
ToField) via HashId

newtype CausalHashId = CausalHashId {CausalHashId -> HashId
unCausalHashId :: HashId}
  deriving (CausalHashId -> CausalHashId -> Bool
(CausalHashId -> CausalHashId -> Bool)
-> (CausalHashId -> CausalHashId -> Bool) -> Eq CausalHashId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CausalHashId -> CausalHashId -> Bool
== :: CausalHashId -> CausalHashId -> Bool
$c/= :: CausalHashId -> CausalHashId -> Bool
/= :: CausalHashId -> CausalHashId -> Bool
Eq, Eq CausalHashId
Eq CausalHashId =>
(CausalHashId -> CausalHashId -> Ordering)
-> (CausalHashId -> CausalHashId -> Bool)
-> (CausalHashId -> CausalHashId -> Bool)
-> (CausalHashId -> CausalHashId -> Bool)
-> (CausalHashId -> CausalHashId -> Bool)
-> (CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId -> CausalHashId)
-> Ord CausalHashId
CausalHashId -> CausalHashId -> Bool
CausalHashId -> CausalHashId -> Ordering
CausalHashId -> CausalHashId -> CausalHashId
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 :: CausalHashId -> CausalHashId -> Ordering
compare :: CausalHashId -> CausalHashId -> Ordering
$c< :: CausalHashId -> CausalHashId -> Bool
< :: CausalHashId -> CausalHashId -> Bool
$c<= :: CausalHashId -> CausalHashId -> Bool
<= :: CausalHashId -> CausalHashId -> Bool
$c> :: CausalHashId -> CausalHashId -> Bool
> :: CausalHashId -> CausalHashId -> Bool
$c>= :: CausalHashId -> CausalHashId -> Bool
>= :: CausalHashId -> CausalHashId -> Bool
$cmax :: CausalHashId -> CausalHashId -> CausalHashId
max :: CausalHashId -> CausalHashId -> CausalHashId
$cmin :: CausalHashId -> CausalHashId -> CausalHashId
min :: CausalHashId -> CausalHashId -> CausalHashId
Ord)
  deriving (Integer -> CausalHashId
CausalHashId -> CausalHashId
CausalHashId -> CausalHashId -> CausalHashId
(CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId)
-> (Integer -> CausalHashId)
-> Num CausalHashId
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: CausalHashId -> CausalHashId -> CausalHashId
+ :: CausalHashId -> CausalHashId -> CausalHashId
$c- :: CausalHashId -> CausalHashId -> CausalHashId
- :: CausalHashId -> CausalHashId -> CausalHashId
$c* :: CausalHashId -> CausalHashId -> CausalHashId
* :: CausalHashId -> CausalHashId -> CausalHashId
$cnegate :: CausalHashId -> CausalHashId
negate :: CausalHashId -> CausalHashId
$cabs :: CausalHashId -> CausalHashId
abs :: CausalHashId -> CausalHashId
$csignum :: CausalHashId -> CausalHashId
signum :: CausalHashId -> CausalHashId
$cfromInteger :: Integer -> CausalHashId
fromInteger :: Integer -> CausalHashId
Num, Num CausalHashId
Ord CausalHashId
(Num CausalHashId, Ord CausalHashId) =>
(CausalHashId -> Rational) -> Real CausalHashId
CausalHashId -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: CausalHashId -> Rational
toRational :: CausalHashId -> Rational
Real, Int -> CausalHashId
CausalHashId -> Int
CausalHashId -> [CausalHashId]
CausalHashId -> CausalHashId
CausalHashId -> CausalHashId -> [CausalHashId]
CausalHashId -> CausalHashId -> CausalHashId -> [CausalHashId]
(CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId)
-> (Int -> CausalHashId)
-> (CausalHashId -> Int)
-> (CausalHashId -> [CausalHashId])
-> (CausalHashId -> CausalHashId -> [CausalHashId])
-> (CausalHashId -> CausalHashId -> [CausalHashId])
-> (CausalHashId -> CausalHashId -> CausalHashId -> [CausalHashId])
-> Enum CausalHashId
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 :: CausalHashId -> CausalHashId
succ :: CausalHashId -> CausalHashId
$cpred :: CausalHashId -> CausalHashId
pred :: CausalHashId -> CausalHashId
$ctoEnum :: Int -> CausalHashId
toEnum :: Int -> CausalHashId
$cfromEnum :: CausalHashId -> Int
fromEnum :: CausalHashId -> Int
$cenumFrom :: CausalHashId -> [CausalHashId]
enumFrom :: CausalHashId -> [CausalHashId]
$cenumFromThen :: CausalHashId -> CausalHashId -> [CausalHashId]
enumFromThen :: CausalHashId -> CausalHashId -> [CausalHashId]
$cenumFromTo :: CausalHashId -> CausalHashId -> [CausalHashId]
enumFromTo :: CausalHashId -> CausalHashId -> [CausalHashId]
$cenumFromThenTo :: CausalHashId -> CausalHashId -> CausalHashId -> [CausalHashId]
enumFromThenTo :: CausalHashId -> CausalHashId -> CausalHashId -> [CausalHashId]
Enum, Enum CausalHashId
Real CausalHashId
(Real CausalHashId, Enum CausalHashId) =>
(CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId -> (CausalHashId, CausalHashId))
-> (CausalHashId -> CausalHashId -> (CausalHashId, CausalHashId))
-> (CausalHashId -> Integer)
-> Integral CausalHashId
CausalHashId -> Integer
CausalHashId -> CausalHashId -> (CausalHashId, CausalHashId)
CausalHashId -> CausalHashId -> CausalHashId
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
$cquot :: CausalHashId -> CausalHashId -> CausalHashId
quot :: CausalHashId -> CausalHashId -> CausalHashId
$crem :: CausalHashId -> CausalHashId -> CausalHashId
rem :: CausalHashId -> CausalHashId -> CausalHashId
$cdiv :: CausalHashId -> CausalHashId -> CausalHashId
div :: CausalHashId -> CausalHashId -> CausalHashId
$cmod :: CausalHashId -> CausalHashId -> CausalHashId
mod :: CausalHashId -> CausalHashId -> CausalHashId
$cquotRem :: CausalHashId -> CausalHashId -> (CausalHashId, CausalHashId)
quotRem :: CausalHashId -> CausalHashId -> (CausalHashId, CausalHashId)
$cdivMod :: CausalHashId -> CausalHashId -> (CausalHashId, CausalHashId)
divMod :: CausalHashId -> CausalHashId -> (CausalHashId, CausalHashId)
$ctoInteger :: CausalHashId -> Integer
toInteger :: CausalHashId -> Integer
Integral, Eq CausalHashId
CausalHashId
Eq CausalHashId =>
(CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId -> CausalHashId)
-> (CausalHashId -> CausalHashId)
-> (CausalHashId -> Int -> CausalHashId)
-> (CausalHashId -> Int -> CausalHashId)
-> CausalHashId
-> (Int -> CausalHashId)
-> (CausalHashId -> Int -> CausalHashId)
-> (CausalHashId -> Int -> CausalHashId)
-> (CausalHashId -> Int -> CausalHashId)
-> (CausalHashId -> Int -> Bool)
-> (CausalHashId -> Maybe Int)
-> (CausalHashId -> Int)
-> (CausalHashId -> Bool)
-> (CausalHashId -> Int -> CausalHashId)
-> (CausalHashId -> Int -> CausalHashId)
-> (CausalHashId -> Int -> CausalHashId)
-> (CausalHashId -> Int -> CausalHashId)
-> (CausalHashId -> Int -> CausalHashId)
-> (CausalHashId -> Int -> CausalHashId)
-> (CausalHashId -> Int)
-> Bits CausalHashId
Int -> CausalHashId
CausalHashId -> Bool
CausalHashId -> Int
CausalHashId -> Maybe Int
CausalHashId -> CausalHashId
CausalHashId -> Int -> Bool
CausalHashId -> Int -> CausalHashId
CausalHashId -> CausalHashId -> CausalHashId
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: CausalHashId -> CausalHashId -> CausalHashId
.&. :: CausalHashId -> CausalHashId -> CausalHashId
$c.|. :: CausalHashId -> CausalHashId -> CausalHashId
.|. :: CausalHashId -> CausalHashId -> CausalHashId
$cxor :: CausalHashId -> CausalHashId -> CausalHashId
xor :: CausalHashId -> CausalHashId -> CausalHashId
$ccomplement :: CausalHashId -> CausalHashId
complement :: CausalHashId -> CausalHashId
$cshift :: CausalHashId -> Int -> CausalHashId
shift :: CausalHashId -> Int -> CausalHashId
$crotate :: CausalHashId -> Int -> CausalHashId
rotate :: CausalHashId -> Int -> CausalHashId
$czeroBits :: CausalHashId
zeroBits :: CausalHashId
$cbit :: Int -> CausalHashId
bit :: Int -> CausalHashId
$csetBit :: CausalHashId -> Int -> CausalHashId
setBit :: CausalHashId -> Int -> CausalHashId
$cclearBit :: CausalHashId -> Int -> CausalHashId
clearBit :: CausalHashId -> Int -> CausalHashId
$ccomplementBit :: CausalHashId -> Int -> CausalHashId
complementBit :: CausalHashId -> Int -> CausalHashId
$ctestBit :: CausalHashId -> Int -> Bool
testBit :: CausalHashId -> Int -> Bool
$cbitSizeMaybe :: CausalHashId -> Maybe Int
bitSizeMaybe :: CausalHashId -> Maybe Int
$cbitSize :: CausalHashId -> Int
bitSize :: CausalHashId -> Int
$cisSigned :: CausalHashId -> Bool
isSigned :: CausalHashId -> Bool
$cshiftL :: CausalHashId -> Int -> CausalHashId
shiftL :: CausalHashId -> Int -> CausalHashId
$cunsafeShiftL :: CausalHashId -> Int -> CausalHashId
unsafeShiftL :: CausalHashId -> Int -> CausalHashId
$cshiftR :: CausalHashId -> Int -> CausalHashId
shiftR :: CausalHashId -> Int -> CausalHashId
$cunsafeShiftR :: CausalHashId -> Int -> CausalHashId
unsafeShiftR :: CausalHashId -> Int -> CausalHashId
$crotateL :: CausalHashId -> Int -> CausalHashId
rotateL :: CausalHashId -> Int -> CausalHashId
$crotateR :: CausalHashId -> Int -> CausalHashId
rotateR :: CausalHashId -> Int -> CausalHashId
$cpopCount :: CausalHashId -> Int
popCount :: CausalHashId -> Int
Bits, FieldParser CausalHashId
FieldParser CausalHashId -> FromField CausalHashId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser CausalHashId
fromField :: FieldParser CausalHashId
FromField, CausalHashId -> SQLData
(CausalHashId -> SQLData) -> ToField CausalHashId
forall a. (a -> SQLData) -> ToField a
$ctoField :: CausalHashId -> SQLData
toField :: CausalHashId -> SQLData
ToField) via HashId

newtype ProjectBranchId = ProjectBranchId {ProjectBranchId -> UUID
unProjectBranchId :: UUID}
  deriving newtype (ProjectBranchId -> ProjectBranchId -> Bool
(ProjectBranchId -> ProjectBranchId -> Bool)
-> (ProjectBranchId -> ProjectBranchId -> Bool)
-> Eq ProjectBranchId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectBranchId -> ProjectBranchId -> Bool
== :: ProjectBranchId -> ProjectBranchId -> Bool
$c/= :: ProjectBranchId -> ProjectBranchId -> Bool
/= :: ProjectBranchId -> ProjectBranchId -> Bool
Eq, FieldParser ProjectBranchId
FieldParser ProjectBranchId -> FromField ProjectBranchId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser ProjectBranchId
fromField :: FieldParser ProjectBranchId
FromField, Eq ProjectBranchId
Eq ProjectBranchId =>
(ProjectBranchId -> ProjectBranchId -> Ordering)
-> (ProjectBranchId -> ProjectBranchId -> Bool)
-> (ProjectBranchId -> ProjectBranchId -> Bool)
-> (ProjectBranchId -> ProjectBranchId -> Bool)
-> (ProjectBranchId -> ProjectBranchId -> Bool)
-> (ProjectBranchId -> ProjectBranchId -> ProjectBranchId)
-> (ProjectBranchId -> ProjectBranchId -> ProjectBranchId)
-> Ord ProjectBranchId
ProjectBranchId -> ProjectBranchId -> Bool
ProjectBranchId -> ProjectBranchId -> Ordering
ProjectBranchId -> ProjectBranchId -> ProjectBranchId
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 :: ProjectBranchId -> ProjectBranchId -> Ordering
compare :: ProjectBranchId -> ProjectBranchId -> Ordering
$c< :: ProjectBranchId -> ProjectBranchId -> Bool
< :: ProjectBranchId -> ProjectBranchId -> Bool
$c<= :: ProjectBranchId -> ProjectBranchId -> Bool
<= :: ProjectBranchId -> ProjectBranchId -> Bool
$c> :: ProjectBranchId -> ProjectBranchId -> Bool
> :: ProjectBranchId -> ProjectBranchId -> Bool
$c>= :: ProjectBranchId -> ProjectBranchId -> Bool
>= :: ProjectBranchId -> ProjectBranchId -> Bool
$cmax :: ProjectBranchId -> ProjectBranchId -> ProjectBranchId
max :: ProjectBranchId -> ProjectBranchId -> ProjectBranchId
$cmin :: ProjectBranchId -> ProjectBranchId -> ProjectBranchId
min :: ProjectBranchId -> ProjectBranchId -> ProjectBranchId
Ord, Int -> ProjectBranchId -> ShowS
[ProjectBranchId] -> ShowS
ProjectBranchId -> String
(Int -> ProjectBranchId -> ShowS)
-> (ProjectBranchId -> String)
-> ([ProjectBranchId] -> ShowS)
-> Show ProjectBranchId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectBranchId -> ShowS
showsPrec :: Int -> ProjectBranchId -> ShowS
$cshow :: ProjectBranchId -> String
show :: ProjectBranchId -> String
$cshowList :: [ProjectBranchId] -> ShowS
showList :: [ProjectBranchId] -> ShowS
Show, ProjectBranchId -> SQLData
(ProjectBranchId -> SQLData) -> ToField ProjectBranchId
forall a. (a -> SQLData) -> ToField a
$ctoField :: ProjectBranchId -> SQLData
toField :: ProjectBranchId -> SQLData
ToField)

newtype ProjectId = ProjectId {ProjectId -> UUID
unProjectId :: UUID}
  deriving newtype (ProjectId -> ProjectId -> Bool
(ProjectId -> ProjectId -> Bool)
-> (ProjectId -> ProjectId -> Bool) -> Eq ProjectId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectId -> ProjectId -> Bool
== :: ProjectId -> ProjectId -> Bool
$c/= :: ProjectId -> ProjectId -> Bool
/= :: ProjectId -> ProjectId -> Bool
Eq, FieldParser ProjectId
FieldParser ProjectId -> FromField ProjectId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser ProjectId
fromField :: FieldParser ProjectId
FromField, Eq ProjectId
Eq ProjectId =>
(ProjectId -> ProjectId -> Ordering)
-> (ProjectId -> ProjectId -> Bool)
-> (ProjectId -> ProjectId -> Bool)
-> (ProjectId -> ProjectId -> Bool)
-> (ProjectId -> ProjectId -> Bool)
-> (ProjectId -> ProjectId -> ProjectId)
-> (ProjectId -> ProjectId -> ProjectId)
-> Ord ProjectId
ProjectId -> ProjectId -> Bool
ProjectId -> ProjectId -> Ordering
ProjectId -> ProjectId -> ProjectId
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 :: ProjectId -> ProjectId -> Ordering
compare :: ProjectId -> ProjectId -> Ordering
$c< :: ProjectId -> ProjectId -> Bool
< :: ProjectId -> ProjectId -> Bool
$c<= :: ProjectId -> ProjectId -> Bool
<= :: ProjectId -> ProjectId -> Bool
$c> :: ProjectId -> ProjectId -> Bool
> :: ProjectId -> ProjectId -> Bool
$c>= :: ProjectId -> ProjectId -> Bool
>= :: ProjectId -> ProjectId -> Bool
$cmax :: ProjectId -> ProjectId -> ProjectId
max :: ProjectId -> ProjectId -> ProjectId
$cmin :: ProjectId -> ProjectId -> ProjectId
min :: ProjectId -> ProjectId -> ProjectId
Ord, Int -> ProjectId -> ShowS
[ProjectId] -> ShowS
ProjectId -> String
(Int -> ProjectId -> ShowS)
-> (ProjectId -> String)
-> ([ProjectId] -> ShowS)
-> Show ProjectId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectId -> ShowS
showsPrec :: Int -> ProjectId -> ShowS
$cshow :: ProjectId -> String
show :: ProjectId -> String
$cshowList :: [ProjectId] -> ShowS
showList :: [ProjectId] -> ShowS
Show, ProjectId -> SQLData
(ProjectId -> SQLData) -> ToField ProjectId
forall a. (a -> SQLData) -> ToField a
$ctoField :: ProjectId -> SQLData
toField :: ProjectId -> SQLData
ToField)

newtype RemoteProjectBranchId = RemoteProjectBranchId {RemoteProjectBranchId -> Text
unRemoteProjectBranchId :: Text}
  deriving newtype (RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
(RemoteProjectBranchId -> RemoteProjectBranchId -> Bool)
-> (RemoteProjectBranchId -> RemoteProjectBranchId -> Bool)
-> Eq RemoteProjectBranchId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
== :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
$c/= :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
/= :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
Eq, FieldParser RemoteProjectBranchId
FieldParser RemoteProjectBranchId
-> FromField RemoteProjectBranchId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser RemoteProjectBranchId
fromField :: FieldParser RemoteProjectBranchId
FromField, Eq RemoteProjectBranchId
Eq RemoteProjectBranchId =>
(RemoteProjectBranchId -> RemoteProjectBranchId -> Ordering)
-> (RemoteProjectBranchId -> RemoteProjectBranchId -> Bool)
-> (RemoteProjectBranchId -> RemoteProjectBranchId -> Bool)
-> (RemoteProjectBranchId -> RemoteProjectBranchId -> Bool)
-> (RemoteProjectBranchId -> RemoteProjectBranchId -> Bool)
-> (RemoteProjectBranchId
    -> RemoteProjectBranchId -> RemoteProjectBranchId)
-> (RemoteProjectBranchId
    -> RemoteProjectBranchId -> RemoteProjectBranchId)
-> Ord RemoteProjectBranchId
RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
RemoteProjectBranchId -> RemoteProjectBranchId -> Ordering
RemoteProjectBranchId
-> RemoteProjectBranchId -> RemoteProjectBranchId
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 :: RemoteProjectBranchId -> RemoteProjectBranchId -> Ordering
compare :: RemoteProjectBranchId -> RemoteProjectBranchId -> Ordering
$c< :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
< :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
$c<= :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
<= :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
$c> :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
> :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
$c>= :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
>= :: RemoteProjectBranchId -> RemoteProjectBranchId -> Bool
$cmax :: RemoteProjectBranchId
-> RemoteProjectBranchId -> RemoteProjectBranchId
max :: RemoteProjectBranchId
-> RemoteProjectBranchId -> RemoteProjectBranchId
$cmin :: RemoteProjectBranchId
-> RemoteProjectBranchId -> RemoteProjectBranchId
min :: RemoteProjectBranchId
-> RemoteProjectBranchId -> RemoteProjectBranchId
Ord, Int -> RemoteProjectBranchId -> ShowS
[RemoteProjectBranchId] -> ShowS
RemoteProjectBranchId -> String
(Int -> RemoteProjectBranchId -> ShowS)
-> (RemoteProjectBranchId -> String)
-> ([RemoteProjectBranchId] -> ShowS)
-> Show RemoteProjectBranchId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RemoteProjectBranchId -> ShowS
showsPrec :: Int -> RemoteProjectBranchId -> ShowS
$cshow :: RemoteProjectBranchId -> String
show :: RemoteProjectBranchId -> String
$cshowList :: [RemoteProjectBranchId] -> ShowS
showList :: [RemoteProjectBranchId] -> ShowS
Show, RemoteProjectBranchId -> SQLData
(RemoteProjectBranchId -> SQLData) -> ToField RemoteProjectBranchId
forall a. (a -> SQLData) -> ToField a
$ctoField :: RemoteProjectBranchId -> SQLData
toField :: RemoteProjectBranchId -> SQLData
ToField)

newtype RemoteProjectId = RemoteProjectId {RemoteProjectId -> Text
unRemoteProjectId :: Text}
  deriving newtype (RemoteProjectId -> RemoteProjectId -> Bool
(RemoteProjectId -> RemoteProjectId -> Bool)
-> (RemoteProjectId -> RemoteProjectId -> Bool)
-> Eq RemoteProjectId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RemoteProjectId -> RemoteProjectId -> Bool
== :: RemoteProjectId -> RemoteProjectId -> Bool
$c/= :: RemoteProjectId -> RemoteProjectId -> Bool
/= :: RemoteProjectId -> RemoteProjectId -> Bool
Eq, FieldParser RemoteProjectId
FieldParser RemoteProjectId -> FromField RemoteProjectId
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser RemoteProjectId
fromField :: FieldParser RemoteProjectId
FromField, Eq RemoteProjectId
Eq RemoteProjectId =>
(RemoteProjectId -> RemoteProjectId -> Ordering)
-> (RemoteProjectId -> RemoteProjectId -> Bool)
-> (RemoteProjectId -> RemoteProjectId -> Bool)
-> (RemoteProjectId -> RemoteProjectId -> Bool)
-> (RemoteProjectId -> RemoteProjectId -> Bool)
-> (RemoteProjectId -> RemoteProjectId -> RemoteProjectId)
-> (RemoteProjectId -> RemoteProjectId -> RemoteProjectId)
-> Ord RemoteProjectId
RemoteProjectId -> RemoteProjectId -> Bool
RemoteProjectId -> RemoteProjectId -> Ordering
RemoteProjectId -> RemoteProjectId -> RemoteProjectId
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 :: RemoteProjectId -> RemoteProjectId -> Ordering
compare :: RemoteProjectId -> RemoteProjectId -> Ordering
$c< :: RemoteProjectId -> RemoteProjectId -> Bool
< :: RemoteProjectId -> RemoteProjectId -> Bool
$c<= :: RemoteProjectId -> RemoteProjectId -> Bool
<= :: RemoteProjectId -> RemoteProjectId -> Bool
$c> :: RemoteProjectId -> RemoteProjectId -> Bool
> :: RemoteProjectId -> RemoteProjectId -> Bool
$c>= :: RemoteProjectId -> RemoteProjectId -> Bool
>= :: RemoteProjectId -> RemoteProjectId -> Bool
$cmax :: RemoteProjectId -> RemoteProjectId -> RemoteProjectId
max :: RemoteProjectId -> RemoteProjectId -> RemoteProjectId
$cmin :: RemoteProjectId -> RemoteProjectId -> RemoteProjectId
min :: RemoteProjectId -> RemoteProjectId -> RemoteProjectId
Ord, Int -> RemoteProjectId -> ShowS
[RemoteProjectId] -> ShowS
RemoteProjectId -> String
(Int -> RemoteProjectId -> ShowS)
-> (RemoteProjectId -> String)
-> ([RemoteProjectId] -> ShowS)
-> Show RemoteProjectId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RemoteProjectId -> ShowS
showsPrec :: Int -> RemoteProjectId -> ShowS
$cshow :: RemoteProjectId -> String
show :: RemoteProjectId -> String
$cshowList :: [RemoteProjectId] -> ShowS
showList :: [RemoteProjectId] -> ShowS
Show, RemoteProjectId -> SQLData
(RemoteProjectId -> SQLData) -> ToField RemoteProjectId
forall a. (a -> SQLData) -> ToField a
$ctoField :: RemoteProjectId -> SQLData
toField :: RemoteProjectId -> SQLData
ToField)

newtype SchemaVersion = SchemaVersion Word64
  deriving (SchemaVersion -> SchemaVersion -> Bool
(SchemaVersion -> SchemaVersion -> Bool)
-> (SchemaVersion -> SchemaVersion -> Bool) -> Eq SchemaVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SchemaVersion -> SchemaVersion -> Bool
== :: SchemaVersion -> SchemaVersion -> Bool
$c/= :: SchemaVersion -> SchemaVersion -> Bool
/= :: SchemaVersion -> SchemaVersion -> Bool
Eq, Eq SchemaVersion
Eq SchemaVersion =>
(SchemaVersion -> SchemaVersion -> Ordering)
-> (SchemaVersion -> SchemaVersion -> Bool)
-> (SchemaVersion -> SchemaVersion -> Bool)
-> (SchemaVersion -> SchemaVersion -> Bool)
-> (SchemaVersion -> SchemaVersion -> Bool)
-> (SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion -> SchemaVersion)
-> Ord SchemaVersion
SchemaVersion -> SchemaVersion -> Bool
SchemaVersion -> SchemaVersion -> Ordering
SchemaVersion -> SchemaVersion -> SchemaVersion
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 :: SchemaVersion -> SchemaVersion -> Ordering
compare :: SchemaVersion -> SchemaVersion -> Ordering
$c< :: SchemaVersion -> SchemaVersion -> Bool
< :: SchemaVersion -> SchemaVersion -> Bool
$c<= :: SchemaVersion -> SchemaVersion -> Bool
<= :: SchemaVersion -> SchemaVersion -> Bool
$c> :: SchemaVersion -> SchemaVersion -> Bool
> :: SchemaVersion -> SchemaVersion -> Bool
$c>= :: SchemaVersion -> SchemaVersion -> Bool
>= :: SchemaVersion -> SchemaVersion -> Bool
$cmax :: SchemaVersion -> SchemaVersion -> SchemaVersion
max :: SchemaVersion -> SchemaVersion -> SchemaVersion
$cmin :: SchemaVersion -> SchemaVersion -> SchemaVersion
min :: SchemaVersion -> SchemaVersion -> SchemaVersion
Ord, Int -> SchemaVersion -> ShowS
[SchemaVersion] -> ShowS
SchemaVersion -> String
(Int -> SchemaVersion -> ShowS)
-> (SchemaVersion -> String)
-> ([SchemaVersion] -> ShowS)
-> Show SchemaVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SchemaVersion -> ShowS
showsPrec :: Int -> SchemaVersion -> ShowS
$cshow :: SchemaVersion -> String
show :: SchemaVersion -> String
$cshowList :: [SchemaVersion] -> ShowS
showList :: [SchemaVersion] -> ShowS
Show)
  deriving (Integer -> SchemaVersion
SchemaVersion -> SchemaVersion
SchemaVersion -> SchemaVersion -> SchemaVersion
(SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion)
-> (Integer -> SchemaVersion)
-> Num SchemaVersion
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: SchemaVersion -> SchemaVersion -> SchemaVersion
+ :: SchemaVersion -> SchemaVersion -> SchemaVersion
$c- :: SchemaVersion -> SchemaVersion -> SchemaVersion
- :: SchemaVersion -> SchemaVersion -> SchemaVersion
$c* :: SchemaVersion -> SchemaVersion -> SchemaVersion
* :: SchemaVersion -> SchemaVersion -> SchemaVersion
$cnegate :: SchemaVersion -> SchemaVersion
negate :: SchemaVersion -> SchemaVersion
$cabs :: SchemaVersion -> SchemaVersion
abs :: SchemaVersion -> SchemaVersion
$csignum :: SchemaVersion -> SchemaVersion
signum :: SchemaVersion -> SchemaVersion
$cfromInteger :: Integer -> SchemaVersion
fromInteger :: Integer -> SchemaVersion
Num, Num SchemaVersion
Ord SchemaVersion
(Num SchemaVersion, Ord SchemaVersion) =>
(SchemaVersion -> Rational) -> Real SchemaVersion
SchemaVersion -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: SchemaVersion -> Rational
toRational :: SchemaVersion -> Rational
Real, Int -> SchemaVersion
SchemaVersion -> Int
SchemaVersion -> [SchemaVersion]
SchemaVersion -> SchemaVersion
SchemaVersion -> SchemaVersion -> [SchemaVersion]
SchemaVersion -> SchemaVersion -> SchemaVersion -> [SchemaVersion]
(SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion)
-> (Int -> SchemaVersion)
-> (SchemaVersion -> Int)
-> (SchemaVersion -> [SchemaVersion])
-> (SchemaVersion -> SchemaVersion -> [SchemaVersion])
-> (SchemaVersion -> SchemaVersion -> [SchemaVersion])
-> (SchemaVersion
    -> SchemaVersion -> SchemaVersion -> [SchemaVersion])
-> Enum SchemaVersion
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 :: SchemaVersion -> SchemaVersion
succ :: SchemaVersion -> SchemaVersion
$cpred :: SchemaVersion -> SchemaVersion
pred :: SchemaVersion -> SchemaVersion
$ctoEnum :: Int -> SchemaVersion
toEnum :: Int -> SchemaVersion
$cfromEnum :: SchemaVersion -> Int
fromEnum :: SchemaVersion -> Int
$cenumFrom :: SchemaVersion -> [SchemaVersion]
enumFrom :: SchemaVersion -> [SchemaVersion]
$cenumFromThen :: SchemaVersion -> SchemaVersion -> [SchemaVersion]
enumFromThen :: SchemaVersion -> SchemaVersion -> [SchemaVersion]
$cenumFromTo :: SchemaVersion -> SchemaVersion -> [SchemaVersion]
enumFromTo :: SchemaVersion -> SchemaVersion -> [SchemaVersion]
$cenumFromThenTo :: SchemaVersion -> SchemaVersion -> SchemaVersion -> [SchemaVersion]
enumFromThenTo :: SchemaVersion -> SchemaVersion -> SchemaVersion -> [SchemaVersion]
Enum, Enum SchemaVersion
Real SchemaVersion
(Real SchemaVersion, Enum SchemaVersion) =>
(SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion
    -> SchemaVersion -> (SchemaVersion, SchemaVersion))
-> (SchemaVersion
    -> SchemaVersion -> (SchemaVersion, SchemaVersion))
-> (SchemaVersion -> Integer)
-> Integral SchemaVersion
SchemaVersion -> Integer
SchemaVersion -> SchemaVersion -> (SchemaVersion, SchemaVersion)
SchemaVersion -> SchemaVersion -> SchemaVersion
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
$cquot :: SchemaVersion -> SchemaVersion -> SchemaVersion
quot :: SchemaVersion -> SchemaVersion -> SchemaVersion
$crem :: SchemaVersion -> SchemaVersion -> SchemaVersion
rem :: SchemaVersion -> SchemaVersion -> SchemaVersion
$cdiv :: SchemaVersion -> SchemaVersion -> SchemaVersion
div :: SchemaVersion -> SchemaVersion -> SchemaVersion
$cmod :: SchemaVersion -> SchemaVersion -> SchemaVersion
mod :: SchemaVersion -> SchemaVersion -> SchemaVersion
$cquotRem :: SchemaVersion -> SchemaVersion -> (SchemaVersion, SchemaVersion)
quotRem :: SchemaVersion -> SchemaVersion -> (SchemaVersion, SchemaVersion)
$cdivMod :: SchemaVersion -> SchemaVersion -> (SchemaVersion, SchemaVersion)
divMod :: SchemaVersion -> SchemaVersion -> (SchemaVersion, SchemaVersion)
$ctoInteger :: SchemaVersion -> Integer
toInteger :: SchemaVersion -> Integer
Integral, Eq SchemaVersion
SchemaVersion
Eq SchemaVersion =>
(SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> SchemaVersion)
-> (SchemaVersion -> Int -> SchemaVersion)
-> (SchemaVersion -> Int -> SchemaVersion)
-> SchemaVersion
-> (Int -> SchemaVersion)
-> (SchemaVersion -> Int -> SchemaVersion)
-> (SchemaVersion -> Int -> SchemaVersion)
-> (SchemaVersion -> Int -> SchemaVersion)
-> (SchemaVersion -> Int -> Bool)
-> (SchemaVersion -> Maybe Int)
-> (SchemaVersion -> Int)
-> (SchemaVersion -> Bool)
-> (SchemaVersion -> Int -> SchemaVersion)
-> (SchemaVersion -> Int -> SchemaVersion)
-> (SchemaVersion -> Int -> SchemaVersion)
-> (SchemaVersion -> Int -> SchemaVersion)
-> (SchemaVersion -> Int -> SchemaVersion)
-> (SchemaVersion -> Int -> SchemaVersion)
-> (SchemaVersion -> Int)
-> Bits SchemaVersion
Int -> SchemaVersion
SchemaVersion -> Bool
SchemaVersion -> Int
SchemaVersion -> Maybe Int
SchemaVersion -> SchemaVersion
SchemaVersion -> Int -> Bool
SchemaVersion -> Int -> SchemaVersion
SchemaVersion -> SchemaVersion -> SchemaVersion
forall a.
Eq a =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
$c.&. :: SchemaVersion -> SchemaVersion -> SchemaVersion
.&. :: SchemaVersion -> SchemaVersion -> SchemaVersion
$c.|. :: SchemaVersion -> SchemaVersion -> SchemaVersion
.|. :: SchemaVersion -> SchemaVersion -> SchemaVersion
$cxor :: SchemaVersion -> SchemaVersion -> SchemaVersion
xor :: SchemaVersion -> SchemaVersion -> SchemaVersion
$ccomplement :: SchemaVersion -> SchemaVersion
complement :: SchemaVersion -> SchemaVersion
$cshift :: SchemaVersion -> Int -> SchemaVersion
shift :: SchemaVersion -> Int -> SchemaVersion
$crotate :: SchemaVersion -> Int -> SchemaVersion
rotate :: SchemaVersion -> Int -> SchemaVersion
$czeroBits :: SchemaVersion
zeroBits :: SchemaVersion
$cbit :: Int -> SchemaVersion
bit :: Int -> SchemaVersion
$csetBit :: SchemaVersion -> Int -> SchemaVersion
setBit :: SchemaVersion -> Int -> SchemaVersion
$cclearBit :: SchemaVersion -> Int -> SchemaVersion
clearBit :: SchemaVersion -> Int -> SchemaVersion
$ccomplementBit :: SchemaVersion -> Int -> SchemaVersion
complementBit :: SchemaVersion -> Int -> SchemaVersion
$ctestBit :: SchemaVersion -> Int -> Bool
testBit :: SchemaVersion -> Int -> Bool
$cbitSizeMaybe :: SchemaVersion -> Maybe Int
bitSizeMaybe :: SchemaVersion -> Maybe Int
$cbitSize :: SchemaVersion -> Int
bitSize :: SchemaVersion -> Int
$cisSigned :: SchemaVersion -> Bool
isSigned :: SchemaVersion -> Bool
$cshiftL :: SchemaVersion -> Int -> SchemaVersion
shiftL :: SchemaVersion -> Int -> SchemaVersion
$cunsafeShiftL :: SchemaVersion -> Int -> SchemaVersion
unsafeShiftL :: SchemaVersion -> Int -> SchemaVersion
$cshiftR :: SchemaVersion -> Int -> SchemaVersion
shiftR :: SchemaVersion -> Int -> SchemaVersion
$cunsafeShiftR :: SchemaVersion -> Int -> SchemaVersion
unsafeShiftR :: SchemaVersion -> Int -> SchemaVersion
$crotateL :: SchemaVersion -> Int -> SchemaVersion
rotateL :: SchemaVersion -> Int -> SchemaVersion
$crotateR :: SchemaVersion -> Int -> SchemaVersion
rotateR :: SchemaVersion -> Int -> SchemaVersion
$cpopCount :: SchemaVersion -> Int
popCount :: SchemaVersion -> Int
Bits, FieldParser SchemaVersion
FieldParser SchemaVersion -> FromField SchemaVersion
forall a. FieldParser a -> FromField a
$cfromField :: FieldParser SchemaVersion
fromField :: FieldParser SchemaVersion
FromField, SchemaVersion -> SQLData
(SchemaVersion -> SQLData) -> ToField SchemaVersion
forall a. (a -> SQLData) -> ToField a
$ctoField :: SchemaVersion -> SQLData
toField :: SchemaVersion -> SQLData
ToField) via Word64

instance Show PatchObjectId where
  show :: PatchObjectId -> String
show PatchObjectId
h = String
"PatchObjectId (" String -> ShowS
forall a. [a] -> [a] -> [a]
++ ObjectId -> String
forall a. Show a => a -> String
show (PatchObjectId -> ObjectId
unPatchObjectId PatchObjectId
h) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"

instance Show BranchObjectId where
  show :: BranchObjectId -> String
show BranchObjectId
h = String
"BranchObjectId (" String -> ShowS
forall a. [a] -> [a] -> [a]
++ ObjectId -> String
forall a. Show a => a -> String
show (BranchObjectId -> ObjectId
unBranchObjectId BranchObjectId
h) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"

instance Show BranchHashId where
  show :: BranchHashId -> String
show BranchHashId
h = String
"BranchHashId (" String -> ShowS
forall a. [a] -> [a] -> [a]
++ HashId -> String
forall a. Show a => a -> String
show (BranchHashId -> HashId
unBranchHashId BranchHashId
h) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"

instance Show CausalHashId where
  show :: CausalHashId -> String
show CausalHashId
h = String
"CausalHashId (" String -> ShowS
forall a. [a] -> [a] -> [a]
++ HashId -> String
forall a. Show a => a -> String
show (CausalHashId -> HashId
unCausalHashId CausalHashId
h) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
")"