    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    module Bindings.HDF5.Core
        ( module Bindings.HDF5.Core
        , module Bindings.HDF5.Core.HId
        , module Bindings.HDF5.Core.HDFResultType
        ) where

    import Bindings.HDF5.Raw.H5

    import Bindings.HDF5.Core.HId
    import Bindings.HDF5.Core.HDFResultType

    import Data.Bits
    import Foreign.Storable

    {-# ANN module "HLint: ignore Use camelCase" #-}

    newtype HSize = HSize HSize_t
        deriving (HSize -> HSize -> Bool
    (HSize -> HSize -> Bool) -> (HSize -> HSize -> Bool) -> Eq HSize
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HSize -> HSize -> Bool
    == :: HSize -> HSize -> Bool
    $c/= :: HSize -> HSize -> Bool
    /= :: HSize -> HSize -> Bool
    Eq, Eq HSize
    Eq HSize =>
    (HSize -> HSize -> Ordering)
    -> (HSize -> HSize -> Bool)
    -> (HSize -> HSize -> Bool)
    -> (HSize -> HSize -> Bool)
    -> (HSize -> HSize -> Bool)
    -> (HSize -> HSize -> HSize)
    -> (HSize -> HSize -> HSize)
    -> Ord HSize
    HSize -> HSize -> Bool
    HSize -> HSize -> Ordering
    HSize -> HSize -> HSize
    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 :: HSize -> HSize -> Ordering
    compare :: HSize -> HSize -> Ordering
    $c< :: HSize -> HSize -> Bool
    < :: HSize -> HSize -> Bool
    $c<= :: HSize -> HSize -> Bool
    <= :: HSize -> HSize -> Bool
    $c> :: HSize -> HSize -> Bool
    > :: HSize -> HSize -> Bool
    $c>= :: HSize -> HSize -> Bool
    >= :: HSize -> HSize -> Bool
    $cmax :: HSize -> HSize -> HSize
    max :: HSize -> HSize -> HSize
    $cmin :: HSize -> HSize -> HSize
    min :: HSize -> HSize -> HSize
    Ord, Int -> HSize
    HSize -> Int
    HSize -> [HSize]
    HSize -> HSize
    HSize -> HSize -> [HSize]
    HSize -> HSize -> HSize -> [HSize]
    (HSize -> HSize)
    -> (HSize -> HSize)
    -> (Int -> HSize)
    -> (HSize -> Int)
    -> (HSize -> [HSize])
    -> (HSize -> HSize -> [HSize])
    -> (HSize -> HSize -> [HSize])
    -> (HSize -> HSize -> HSize -> [HSize])
    -> Enum HSize
    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 :: HSize -> HSize
    succ :: HSize -> HSize
    $cpred :: HSize -> HSize
    pred :: HSize -> HSize
    $ctoEnum :: Int -> HSize
    toEnum :: Int -> HSize
    $cfromEnum :: HSize -> Int
    fromEnum :: HSize -> Int
    $cenumFrom :: HSize -> [HSize]
    enumFrom :: HSize -> [HSize]
    $cenumFromThen :: HSize -> HSize -> [HSize]
    enumFromThen :: HSize -> HSize -> [HSize]
    $cenumFromTo :: HSize -> HSize -> [HSize]
    enumFromTo :: HSize -> HSize -> [HSize]
    $cenumFromThenTo :: HSize -> HSize -> HSize -> [HSize]
    enumFromThenTo :: HSize -> HSize -> HSize -> [HSize]
    Enum, HSize
    HSize -> HSize -> Bounded HSize
    forall a. a -> a -> Bounded a
    $cminBound :: HSize
    minBound :: HSize
    $cmaxBound :: HSize
    maxBound :: HSize
    Bounded, Integer -> HSize
    HSize -> HSize
    HSize -> HSize -> HSize
    (HSize -> HSize -> HSize)
    -> (HSize -> HSize -> HSize)
    -> (HSize -> HSize -> HSize)
    -> (HSize -> HSize)
    -> (HSize -> HSize)
    -> (HSize -> HSize)
    -> (Integer -> HSize)
    -> Num HSize
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: HSize -> HSize -> HSize
    + :: HSize -> HSize -> HSize
    $c- :: HSize -> HSize -> HSize
    - :: HSize -> HSize -> HSize
    $c* :: HSize -> HSize -> HSize
    * :: HSize -> HSize -> HSize
    $cnegate :: HSize -> HSize
    negate :: HSize -> HSize
    $cabs :: HSize -> HSize
    abs :: HSize -> HSize
    $csignum :: HSize -> HSize
    signum :: HSize -> HSize
    $cfromInteger :: Integer -> HSize
    fromInteger :: Integer -> HSize
    Num, Num HSize
    Ord HSize
    (Num HSize, Ord HSize) => (HSize -> Rational) -> Real HSize
    HSize -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: HSize -> Rational
    toRational :: HSize -> Rational
    Real, Enum HSize
    Real HSize
    (Real HSize, Enum HSize) =>
    (HSize -> HSize -> HSize)
    -> (HSize -> HSize -> HSize)
    -> (HSize -> HSize -> HSize)
    -> (HSize -> HSize -> HSize)
    -> (HSize -> HSize -> (HSize, HSize))
    -> (HSize -> HSize -> (HSize, HSize))
    -> (HSize -> Integer)
    -> Integral HSize
    HSize -> Integer
    HSize -> HSize -> (HSize, HSize)
    HSize -> HSize -> HSize
    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 :: HSize -> HSize -> HSize
    quot :: HSize -> HSize -> HSize
    $crem :: HSize -> HSize -> HSize
    rem :: HSize -> HSize -> HSize
    $cdiv :: HSize -> HSize -> HSize
    div :: HSize -> HSize -> HSize
    $cmod :: HSize -> HSize -> HSize
    mod :: HSize -> HSize -> HSize
    $cquotRem :: HSize -> HSize -> (HSize, HSize)
    quotRem :: HSize -> HSize -> (HSize, HSize)
    $cdivMod :: HSize -> HSize -> (HSize, HSize)
    divMod :: HSize -> HSize -> (HSize, HSize)
    $ctoInteger :: HSize -> Integer
    toInteger :: HSize -> Integer
    Integral, Eq HSize
    HSize
    Eq HSize =>
    (HSize -> HSize -> HSize)
    -> (HSize -> HSize -> HSize)
    -> (HSize -> HSize -> HSize)
    -> (HSize -> HSize)
    -> (HSize -> Int -> HSize)
    -> (HSize -> Int -> HSize)
    -> HSize
    -> (Int -> HSize)
    -> (HSize -> Int -> HSize)
    -> (HSize -> Int -> HSize)
    -> (HSize -> Int -> HSize)
    -> (HSize -> Int -> Bool)
    -> (HSize -> Maybe Int)
    -> (HSize -> Int)
    -> (HSize -> Bool)
    -> (HSize -> Int -> HSize)
    -> (HSize -> Int -> HSize)
    -> (HSize -> Int -> HSize)
    -> (HSize -> Int -> HSize)
    -> (HSize -> Int -> HSize)
    -> (HSize -> Int -> HSize)
    -> (HSize -> Int)
    -> Bits HSize
    Int -> HSize
    HSize -> Bool
    HSize -> Int
    HSize -> Maybe Int
    HSize -> HSize
    HSize -> Int -> Bool
    HSize -> Int -> HSize
    HSize -> HSize -> HSize
    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.&. :: HSize -> HSize -> HSize
    .&. :: HSize -> HSize -> HSize
    $c.|. :: HSize -> HSize -> HSize
    .|. :: HSize -> HSize -> HSize
    $cxor :: HSize -> HSize -> HSize
    xor :: HSize -> HSize -> HSize
    $ccomplement :: HSize -> HSize
    complement :: HSize -> HSize
    $cshift :: HSize -> Int -> HSize
    shift :: HSize -> Int -> HSize
    $crotate :: HSize -> Int -> HSize
    rotate :: HSize -> Int -> HSize
    $czeroBits :: HSize
    zeroBits :: HSize
    $cbit :: Int -> HSize
    bit :: Int -> HSize
    $csetBit :: HSize -> Int -> HSize
    setBit :: HSize -> Int -> HSize
    $cclearBit :: HSize -> Int -> HSize
    clearBit :: HSize -> Int -> HSize
    $ccomplementBit :: HSize -> Int -> HSize
    complementBit :: HSize -> Int -> HSize
    $ctestBit :: HSize -> Int -> Bool
    testBit :: HSize -> Int -> Bool
    $cbitSizeMaybe :: HSize -> Maybe Int
    bitSizeMaybe :: HSize -> Maybe Int
    $cbitSize :: HSize -> Int
    bitSize :: HSize -> Int
    $cisSigned :: HSize -> Bool
    isSigned :: HSize -> Bool
    $cshiftL :: HSize -> Int -> HSize
    shiftL :: HSize -> Int -> HSize
    $cunsafeShiftL :: HSize -> Int -> HSize
    unsafeShiftL :: HSize -> Int -> HSize
    $cshiftR :: HSize -> Int -> HSize
    shiftR :: HSize -> Int -> HSize
    $cunsafeShiftR :: HSize -> Int -> HSize
    unsafeShiftR :: HSize -> Int -> HSize
    $crotateL :: HSize -> Int -> HSize
    rotateL :: HSize -> Int -> HSize
    $crotateR :: HSize -> Int -> HSize
    rotateR :: HSize -> Int -> HSize
    $cpopCount :: HSize -> Int
    popCount :: HSize -> Int
    Bits, Ptr HSize -> IO HSize
    Ptr HSize -> Int -> IO HSize
    Ptr HSize -> Int -> HSize -> IO ()
    Ptr HSize -> HSize -> IO ()
    HSize -> Int
    (HSize -> Int)
    -> (HSize -> Int)
    -> (Ptr HSize -> Int -> IO HSize)
    -> (Ptr HSize -> Int -> HSize -> IO ())
    -> (forall b. Ptr b -> Int -> IO HSize)
    -> (forall b. Ptr b -> Int -> HSize -> IO ())
    -> (Ptr HSize -> IO HSize)
    -> (Ptr HSize -> HSize -> IO ())
    -> Storable HSize
    forall b. Ptr b -> Int -> IO HSize
    forall b. Ptr b -> Int -> HSize -> IO ()
    forall a.
    (a -> Int)
    -> (a -> Int)
    -> (Ptr a -> Int -> IO a)
    -> (Ptr a -> Int -> a -> IO ())
    -> (forall b. Ptr b -> Int -> IO a)
    -> (forall b. Ptr b -> Int -> a -> IO ())
    -> (Ptr a -> IO a)
    -> (Ptr a -> a -> IO ())
    -> Storable a
    $csizeOf :: HSize -> Int
    sizeOf :: HSize -> Int
    $calignment :: HSize -> Int
    alignment :: HSize -> Int
    $cpeekElemOff :: Ptr HSize -> Int -> IO HSize
    peekElemOff :: Ptr HSize -> Int -> IO HSize
    $cpokeElemOff :: Ptr HSize -> Int -> HSize -> IO ()
    pokeElemOff :: Ptr HSize -> Int -> HSize -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO HSize
    peekByteOff :: forall b. Ptr b -> Int -> IO HSize
    $cpokeByteOff :: forall b. Ptr b -> Int -> HSize -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> HSize -> IO ()
    $cpeek :: Ptr HSize -> IO HSize
    peek :: Ptr HSize -> IO HSize
    $cpoke :: Ptr HSize -> HSize -> IO ()
    poke :: Ptr HSize -> HSize -> IO ()
    Storable)

    hSize :: HSize -> HSize_t
    hSize :: HSize -> HSize_t
    hSize (HSize HSize_t
    s) = HSize_t
    s

    instance Read HSize where
        readsPrec :: Int -> ReadS HSize
    readsPrec Int
    p String
    s =
            [ (HSize_t -> HSize
    HSize (Word64 -> HSize_t
    HSize_t Word64
    n), String
    rest)
            | (Word64
    n,String
    rest) <- Int -> ReadS Word64
    forall a. Read a => Int -> ReadS a
    readsPrec Int
    p String
    s
            ]

    instance Show HSize where
        showsPrec :: Int -> HSize -> ShowS
    showsPrec Int
    p (HSize (HSize_t Word64
    n)) = Int -> Word64 -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec Int
    p Word64
    n

    newtype HSSize = HSSize HSSize_t
        deriving (HSSize -> HSSize -> Bool
    (HSSize -> HSSize -> Bool)
    -> (HSSize -> HSSize -> Bool) -> Eq HSSize
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HSSize -> HSSize -> Bool
    == :: HSSize -> HSSize -> Bool
    $c/= :: HSSize -> HSSize -> Bool
    /= :: HSSize -> HSSize -> Bool
    Eq, Eq HSSize
    Eq HSSize =>
    (HSSize -> HSSize -> Ordering)
    -> (HSSize -> HSSize -> Bool)
    -> (HSSize -> HSSize -> Bool)
    -> (HSSize -> HSSize -> Bool)
    -> (HSSize -> HSSize -> Bool)
    -> (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize -> HSSize)
    -> Ord HSSize
    HSSize -> HSSize -> Bool
    HSSize -> HSSize -> Ordering
    HSSize -> HSSize -> HSSize
    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 :: HSSize -> HSSize -> Ordering
    compare :: HSSize -> HSSize -> Ordering
    $c< :: HSSize -> HSSize -> Bool
    < :: HSSize -> HSSize -> Bool
    $c<= :: HSSize -> HSSize -> Bool
    <= :: HSSize -> HSSize -> Bool
    $c> :: HSSize -> HSSize -> Bool
    > :: HSSize -> HSSize -> Bool
    $c>= :: HSSize -> HSSize -> Bool
    >= :: HSSize -> HSSize -> Bool
    $cmax :: HSSize -> HSSize -> HSSize
    max :: HSSize -> HSSize -> HSSize
    $cmin :: HSSize -> HSSize -> HSSize
    min :: HSSize -> HSSize -> HSSize
    Ord, Int -> HSSize
    HSSize -> Int
    HSSize -> [HSSize]
    HSSize -> HSSize
    HSSize -> HSSize -> [HSSize]
    HSSize -> HSSize -> HSSize -> [HSSize]
    (HSSize -> HSSize)
    -> (HSSize -> HSSize)
    -> (Int -> HSSize)
    -> (HSSize -> Int)
    -> (HSSize -> [HSSize])
    -> (HSSize -> HSSize -> [HSSize])
    -> (HSSize -> HSSize -> [HSSize])
    -> (HSSize -> HSSize -> HSSize -> [HSSize])
    -> Enum HSSize
    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 :: HSSize -> HSSize
    succ :: HSSize -> HSSize
    $cpred :: HSSize -> HSSize
    pred :: HSSize -> HSSize
    $ctoEnum :: Int -> HSSize
    toEnum :: Int -> HSSize
    $cfromEnum :: HSSize -> Int
    fromEnum :: HSSize -> Int
    $cenumFrom :: HSSize -> [HSSize]
    enumFrom :: HSSize -> [HSSize]
    $cenumFromThen :: HSSize -> HSSize -> [HSSize]
    enumFromThen :: HSSize -> HSSize -> [HSSize]
    $cenumFromTo :: HSSize -> HSSize -> [HSSize]
    enumFromTo :: HSSize -> HSSize -> [HSSize]
    $cenumFromThenTo :: HSSize -> HSSize -> HSSize -> [HSSize]
    enumFromThenTo :: HSSize -> HSSize -> HSSize -> [HSSize]
    Enum, HSSize
    HSSize -> HSSize -> Bounded HSSize
    forall a. a -> a -> Bounded a
    $cminBound :: HSSize
    minBound :: HSSize
    $cmaxBound :: HSSize
    maxBound :: HSSize
    Bounded, Integer -> HSSize
    HSSize -> HSSize
    HSSize -> HSSize -> HSSize
    (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize)
    -> (HSSize -> HSSize)
    -> (HSSize -> HSSize)
    -> (Integer -> HSSize)
    -> Num HSSize
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: HSSize -> HSSize -> HSSize
    + :: HSSize -> HSSize -> HSSize
    $c- :: HSSize -> HSSize -> HSSize
    - :: HSSize -> HSSize -> HSSize
    $c* :: HSSize -> HSSize -> HSSize
    * :: HSSize -> HSSize -> HSSize
    $cnegate :: HSSize -> HSSize
    negate :: HSSize -> HSSize
    $cabs :: HSSize -> HSSize
    abs :: HSSize -> HSSize
    $csignum :: HSSize -> HSSize
    signum :: HSSize -> HSSize
    $cfromInteger :: Integer -> HSSize
    fromInteger :: Integer -> HSSize
    Num, Num HSSize
    Ord HSSize
    (Num HSSize, Ord HSSize) => (HSSize -> Rational) -> Real HSSize
    HSSize -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: HSSize -> Rational
    toRational :: HSSize -> Rational
    Real, Enum HSSize
    Real HSSize
    (Real HSSize, Enum HSSize) =>
    (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize -> (HSSize, HSSize))
    -> (HSSize -> HSSize -> (HSSize, HSSize))
    -> (HSSize -> Integer)
    -> Integral HSSize
    HSSize -> Integer
    HSSize -> HSSize -> (HSSize, HSSize)
    HSSize -> HSSize -> HSSize
    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 :: HSSize -> HSSize -> HSSize
    quot :: HSSize -> HSSize -> HSSize
    $crem :: HSSize -> HSSize -> HSSize
    rem :: HSSize -> HSSize -> HSSize
    $cdiv :: HSSize -> HSSize -> HSSize
    div :: HSSize -> HSSize -> HSSize
    $cmod :: HSSize -> HSSize -> HSSize
    mod :: HSSize -> HSSize -> HSSize
    $cquotRem :: HSSize -> HSSize -> (HSSize, HSSize)
    quotRem :: HSSize -> HSSize -> (HSSize, HSSize)
    $cdivMod :: HSSize -> HSSize -> (HSSize, HSSize)
    divMod :: HSSize -> HSSize -> (HSSize, HSSize)
    $ctoInteger :: HSSize -> Integer
    toInteger :: HSSize -> Integer
    Integral, Eq HSSize
    HSSize
    Eq HSSize =>
    (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize -> HSSize)
    -> (HSSize -> HSSize)
    -> (HSSize -> Int -> HSSize)
    -> (HSSize -> Int -> HSSize)
    -> HSSize
    -> (Int -> HSSize)
    -> (HSSize -> Int -> HSSize)
    -> (HSSize -> Int -> HSSize)
    -> (HSSize -> Int -> HSSize)
    -> (HSSize -> Int -> Bool)
    -> (HSSize -> Maybe Int)
    -> (HSSize -> Int)
    -> (HSSize -> Bool)
    -> (HSSize -> Int -> HSSize)
    -> (HSSize -> Int -> HSSize)
    -> (HSSize -> Int -> HSSize)
    -> (HSSize -> Int -> HSSize)
    -> (HSSize -> Int -> HSSize)
    -> (HSSize -> Int -> HSSize)
    -> (HSSize -> Int)
    -> Bits HSSize
    Int -> HSSize
    HSSize -> Bool
    HSSize -> Int
    HSSize -> Maybe Int
    HSSize -> HSSize
    HSSize -> Int -> Bool
    HSSize -> Int -> HSSize
    HSSize -> HSSize -> HSSize
    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.&. :: HSSize -> HSSize -> HSSize
    .&. :: HSSize -> HSSize -> HSSize
    $c.|. :: HSSize -> HSSize -> HSSize
    .|. :: HSSize -> HSSize -> HSSize
    $cxor :: HSSize -> HSSize -> HSSize
    xor :: HSSize -> HSSize -> HSSize
    $ccomplement :: HSSize -> HSSize
    complement :: HSSize -> HSSize
    $cshift :: HSSize -> Int -> HSSize
    shift :: HSSize -> Int -> HSSize
    $crotate :: HSSize -> Int -> HSSize
    rotate :: HSSize -> Int -> HSSize
    $czeroBits :: HSSize
    zeroBits :: HSSize
    $cbit :: Int -> HSSize
    bit :: Int -> HSSize
    $csetBit :: HSSize -> Int -> HSSize
    setBit :: HSSize -> Int -> HSSize
    $cclearBit :: HSSize -> Int -> HSSize
    clearBit :: HSSize -> Int -> HSSize
    $ccomplementBit :: HSSize -> Int -> HSSize
    complementBit :: HSSize -> Int -> HSSize
    $ctestBit :: HSSize -> Int -> Bool
    testBit :: HSSize -> Int -> Bool
    $cbitSizeMaybe :: HSSize -> Maybe Int
    bitSizeMaybe :: HSSize -> Maybe Int
    $cbitSize :: HSSize -> Int
    bitSize :: HSSize -> Int
    $cisSigned :: HSSize -> Bool
    isSigned :: HSSize -> Bool
    $cshiftL :: HSSize -> Int -> HSSize
    shiftL :: HSSize -> Int -> HSSize
    $cunsafeShiftL :: HSSize -> Int -> HSSize
    unsafeShiftL :: HSSize -> Int -> HSSize
    $cshiftR :: HSSize -> Int -> HSSize
    shiftR :: HSSize -> Int -> HSSize
    $cunsafeShiftR :: HSSize -> Int -> HSSize
    unsafeShiftR :: HSSize -> Int -> HSSize
    $crotateL :: HSSize -> Int -> HSSize
    rotateL :: HSSize -> Int -> HSSize
    $crotateR :: HSSize -> Int -> HSSize
    rotateR :: HSSize -> Int -> HSSize
    $cpopCount :: HSSize -> Int
    popCount :: HSSize -> Int
    Bits, Ptr HSSize -> IO HSSize
    Ptr HSSize -> Int -> IO HSSize
    Ptr HSSize -> Int -> HSSize -> IO ()
    Ptr HSSize -> HSSize -> IO ()
    HSSize -> Int
    (HSSize -> Int)
    -> (HSSize -> Int)
    -> (Ptr HSSize -> Int -> IO HSSize)
    -> (Ptr HSSize -> Int -> HSSize -> IO ())
    -> (forall b. Ptr b -> Int -> IO HSSize)
    -> (forall b. Ptr b -> Int -> HSSize -> IO ())
    -> (Ptr HSSize -> IO HSSize)
    -> (Ptr HSSize -> HSSize -> IO ())
    -> Storable HSSize
    forall b. Ptr b -> Int -> IO HSSize
    forall b. Ptr b -> Int -> HSSize -> IO ()
    forall a.
    (a -> Int)
    -> (a -> Int)
    -> (Ptr a -> Int -> IO a)
    -> (Ptr a -> Int -> a -> IO ())
    -> (forall b. Ptr b -> Int -> IO a)
    -> (forall b. Ptr b -> Int -> a -> IO ())
    -> (Ptr a -> IO a)
    -> (Ptr a -> a -> IO ())
    -> Storable a
    $csizeOf :: HSSize -> Int
    sizeOf :: HSSize -> Int
    $calignment :: HSSize -> Int
    alignment :: HSSize -> Int
    $cpeekElemOff :: Ptr HSSize -> Int -> IO HSSize
    peekElemOff :: Ptr HSSize -> Int -> IO HSSize
    $cpokeElemOff :: Ptr HSSize -> Int -> HSSize -> IO ()
    pokeElemOff :: Ptr HSSize -> Int -> HSSize -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO HSSize
    peekByteOff :: forall b. Ptr b -> Int -> IO HSSize
    $cpokeByteOff :: forall b. Ptr b -> Int -> HSSize -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> HSSize -> IO ()
    $cpeek :: Ptr HSSize -> IO HSSize
    peek :: Ptr HSSize -> IO HSSize
    $cpoke :: Ptr HSSize -> HSSize -> IO ()
    poke :: Ptr HSSize -> HSSize -> IO ()
    Storable)

    hSSize :: HSSize -> HSSize_t
    hSSize :: HSSize -> HSSize_t
    hSSize (HSSize HSSize_t
    s) = HSSize_t
    s

    instance Read HSSize where
        readsPrec :: Int -> ReadS HSSize
    readsPrec Int
    p String
    s =
            [ (HSSize_t -> HSSize
    HSSize (Int64 -> HSSize_t
    HSSize_t Int64
    n), String
    rest)
            | (Int64
    n,String
    rest) <- Int -> ReadS Int64
    forall a. Read a => Int -> ReadS a
    readsPrec Int
    p String
    s
            ]

    instance Show HSSize where
        showsPrec :: Int -> HSSize -> ShowS
    showsPrec Int
    p (HSSize (HSSize_t Int64
    n)) = Int -> Int64 -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec Int
    p Int64
    n

    newtype HAddr = HAddr HAddr_t
        deriving (HAddr -> HAddr -> Bool
    (HAddr -> HAddr -> Bool) -> (HAddr -> HAddr -> Bool) -> Eq HAddr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: HAddr -> HAddr -> Bool
    == :: HAddr -> HAddr -> Bool
    $c/= :: HAddr -> HAddr -> Bool
    /= :: HAddr -> HAddr -> Bool
    Eq, Eq HAddr
    Eq HAddr =>
    (HAddr -> HAddr -> Ordering)
    -> (HAddr -> HAddr -> Bool)
    -> (HAddr -> HAddr -> Bool)
    -> (HAddr -> HAddr -> Bool)
    -> (HAddr -> HAddr -> Bool)
    -> (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr -> HAddr)
    -> Ord HAddr
    HAddr -> HAddr -> Bool
    HAddr -> HAddr -> Ordering
    HAddr -> HAddr -> HAddr
    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 :: HAddr -> HAddr -> Ordering
    compare :: HAddr -> HAddr -> Ordering
    $c< :: HAddr -> HAddr -> Bool
    < :: HAddr -> HAddr -> Bool
    $c<= :: HAddr -> HAddr -> Bool
    <= :: HAddr -> HAddr -> Bool
    $c> :: HAddr -> HAddr -> Bool
    > :: HAddr -> HAddr -> Bool
    $c>= :: HAddr -> HAddr -> Bool
    >= :: HAddr -> HAddr -> Bool
    $cmax :: HAddr -> HAddr -> HAddr
    max :: HAddr -> HAddr -> HAddr
    $cmin :: HAddr -> HAddr -> HAddr
    min :: HAddr -> HAddr -> HAddr
    Ord, Int -> HAddr
    HAddr -> Int
    HAddr -> [HAddr]
    HAddr -> HAddr
    HAddr -> HAddr -> [HAddr]
    HAddr -> HAddr -> HAddr -> [HAddr]
    (HAddr -> HAddr)
    -> (HAddr -> HAddr)
    -> (Int -> HAddr)
    -> (HAddr -> Int)
    -> (HAddr -> [HAddr])
    -> (HAddr -> HAddr -> [HAddr])
    -> (HAddr -> HAddr -> [HAddr])
    -> (HAddr -> HAddr -> HAddr -> [HAddr])
    -> Enum HAddr
    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 :: HAddr -> HAddr
    succ :: HAddr -> HAddr
    $cpred :: HAddr -> HAddr
    pred :: HAddr -> HAddr
    $ctoEnum :: Int -> HAddr
    toEnum :: Int -> HAddr
    $cfromEnum :: HAddr -> Int
    fromEnum :: HAddr -> Int
    $cenumFrom :: HAddr -> [HAddr]
    enumFrom :: HAddr -> [HAddr]
    $cenumFromThen :: HAddr -> HAddr -> [HAddr]
    enumFromThen :: HAddr -> HAddr -> [HAddr]
    $cenumFromTo :: HAddr -> HAddr -> [HAddr]
    enumFromTo :: HAddr -> HAddr -> [HAddr]
    $cenumFromThenTo :: HAddr -> HAddr -> HAddr -> [HAddr]
    enumFromThenTo :: HAddr -> HAddr -> HAddr -> [HAddr]
    Enum, HAddr
    HAddr -> HAddr -> Bounded HAddr
    forall a. a -> a -> Bounded a
    $cminBound :: HAddr
    minBound :: HAddr
    $cmaxBound :: HAddr
    maxBound :: HAddr
    Bounded, Integer -> HAddr
    HAddr -> HAddr
    HAddr -> HAddr -> HAddr
    (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr)
    -> (HAddr -> HAddr)
    -> (HAddr -> HAddr)
    -> (Integer -> HAddr)
    -> Num HAddr
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: HAddr -> HAddr -> HAddr
    + :: HAddr -> HAddr -> HAddr
    $c- :: HAddr -> HAddr -> HAddr
    - :: HAddr -> HAddr -> HAddr
    $c* :: HAddr -> HAddr -> HAddr
    * :: HAddr -> HAddr -> HAddr
    $cnegate :: HAddr -> HAddr
    negate :: HAddr -> HAddr
    $cabs :: HAddr -> HAddr
    abs :: HAddr -> HAddr
    $csignum :: HAddr -> HAddr
    signum :: HAddr -> HAddr
    $cfromInteger :: Integer -> HAddr
    fromInteger :: Integer -> HAddr
    Num, Num HAddr
    Ord HAddr
    (Num HAddr, Ord HAddr) => (HAddr -> Rational) -> Real HAddr
    HAddr -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    $ctoRational :: HAddr -> Rational
    toRational :: HAddr -> Rational
    Real, Enum HAddr
    Real HAddr
    (Real HAddr, Enum HAddr) =>
    (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr -> (HAddr, HAddr))
    -> (HAddr -> HAddr -> (HAddr, HAddr))
    -> (HAddr -> Integer)
    -> Integral HAddr
    HAddr -> Integer
    HAddr -> HAddr -> (HAddr, HAddr)
    HAddr -> HAddr -> HAddr
    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 :: HAddr -> HAddr -> HAddr
    quot :: HAddr -> HAddr -> HAddr
    $crem :: HAddr -> HAddr -> HAddr
    rem :: HAddr -> HAddr -> HAddr
    $cdiv :: HAddr -> HAddr -> HAddr
    div :: HAddr -> HAddr -> HAddr
    $cmod :: HAddr -> HAddr -> HAddr
    mod :: HAddr -> HAddr -> HAddr
    $cquotRem :: HAddr -> HAddr -> (HAddr, HAddr)
    quotRem :: HAddr -> HAddr -> (HAddr, HAddr)
    $cdivMod :: HAddr -> HAddr -> (HAddr, HAddr)
    divMod :: HAddr -> HAddr -> (HAddr, HAddr)
    $ctoInteger :: HAddr -> Integer
    toInteger :: HAddr -> Integer
    Integral, Eq HAddr
    HAddr
    Eq HAddr =>
    (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr -> HAddr)
    -> (HAddr -> HAddr)
    -> (HAddr -> Int -> HAddr)
    -> (HAddr -> Int -> HAddr)
    -> HAddr
    -> (Int -> HAddr)
    -> (HAddr -> Int -> HAddr)
    -> (HAddr -> Int -> HAddr)
    -> (HAddr -> Int -> HAddr)
    -> (HAddr -> Int -> Bool)
    -> (HAddr -> Maybe Int)
    -> (HAddr -> Int)
    -> (HAddr -> Bool)
    -> (HAddr -> Int -> HAddr)
    -> (HAddr -> Int -> HAddr)
    -> (HAddr -> Int -> HAddr)
    -> (HAddr -> Int -> HAddr)
    -> (HAddr -> Int -> HAddr)
    -> (HAddr -> Int -> HAddr)
    -> (HAddr -> Int)
    -> Bits HAddr
    Int -> HAddr
    HAddr -> Bool
    HAddr -> Int
    HAddr -> Maybe Int
    HAddr -> HAddr
    HAddr -> Int -> Bool
    HAddr -> Int -> HAddr
    HAddr -> HAddr -> HAddr
    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.&. :: HAddr -> HAddr -> HAddr
    .&. :: HAddr -> HAddr -> HAddr
    $c.|. :: HAddr -> HAddr -> HAddr
    .|. :: HAddr -> HAddr -> HAddr
    $cxor :: HAddr -> HAddr -> HAddr
    xor :: HAddr -> HAddr -> HAddr
    $ccomplement :: HAddr -> HAddr
    complement :: HAddr -> HAddr
    $cshift :: HAddr -> Int -> HAddr
    shift :: HAddr -> Int -> HAddr
    $crotate :: HAddr -> Int -> HAddr
    rotate :: HAddr -> Int -> HAddr
    $czeroBits :: HAddr
    zeroBits :: HAddr
    $cbit :: Int -> HAddr
    bit :: Int -> HAddr
    $csetBit :: HAddr -> Int -> HAddr
    setBit :: HAddr -> Int -> HAddr
    $cclearBit :: HAddr -> Int -> HAddr
    clearBit :: HAddr -> Int -> HAddr
    $ccomplementBit :: HAddr -> Int -> HAddr
    complementBit :: HAddr -> Int -> HAddr
    $ctestBit :: HAddr -> Int -> Bool
    testBit :: HAddr -> Int -> Bool
    $cbitSizeMaybe :: HAddr -> Maybe Int
    bitSizeMaybe :: HAddr -> Maybe Int
    $cbitSize :: HAddr -> Int
    bitSize :: HAddr -> Int
    $cisSigned :: HAddr -> Bool
    isSigned :: HAddr -> Bool
    $cshiftL :: HAddr -> Int -> HAddr
    shiftL :: HAddr -> Int -> HAddr
    $cunsafeShiftL :: HAddr -> Int -> HAddr
    unsafeShiftL :: HAddr -> Int -> HAddr
    $cshiftR :: HAddr -> Int -> HAddr
    shiftR :: HAddr -> Int -> HAddr
    $cunsafeShiftR :: HAddr -> Int -> HAddr
    unsafeShiftR :: HAddr -> Int -> HAddr
    $crotateL :: HAddr -> Int -> HAddr
    rotateL :: HAddr -> Int -> HAddr
    $crotateR :: HAddr -> Int -> HAddr
    rotateR :: HAddr -> Int -> HAddr
    $cpopCount :: HAddr -> Int
    popCount :: HAddr -> Int
    Bits, Ptr HAddr -> IO HAddr
    Ptr HAddr -> Int -> IO HAddr
    Ptr HAddr -> Int -> HAddr -> IO ()
    Ptr HAddr -> HAddr -> IO ()
    HAddr -> Int
    (HAddr -> Int)
    -> (HAddr -> Int)
    -> (Ptr HAddr -> Int -> IO HAddr)
    -> (Ptr HAddr -> Int -> HAddr -> IO ())
    -> (forall b. Ptr b -> Int -> IO HAddr)
    -> (forall b. Ptr b -> Int -> HAddr -> IO ())
    -> (Ptr HAddr -> IO HAddr)
    -> (Ptr HAddr -> HAddr -> IO ())
    -> Storable HAddr
    forall b. Ptr b -> Int -> IO HAddr
    forall b. Ptr b -> Int -> HAddr -> IO ()
    forall a.
    (a -> Int)
    -> (a -> Int)
    -> (Ptr a -> Int -> IO a)
    -> (Ptr a -> Int -> a -> IO ())
    -> (forall b. Ptr b -> Int -> IO a)
    -> (forall b. Ptr b -> Int -> a -> IO ())
    -> (Ptr a -> IO a)
    -> (Ptr a -> a -> IO ())
    -> Storable a
    $csizeOf :: HAddr -> Int
    sizeOf :: HAddr -> Int
    $calignment :: HAddr -> Int
    alignment :: HAddr -> Int
    $cpeekElemOff :: Ptr HAddr -> Int -> IO HAddr
    peekElemOff :: Ptr HAddr -> Int -> IO HAddr
    $cpokeElemOff :: Ptr HAddr -> Int -> HAddr -> IO ()
    pokeElemOff :: Ptr HAddr -> Int -> HAddr -> IO ()
    $cpeekByteOff :: forall b. Ptr b -> Int -> IO HAddr
    peekByteOff :: forall b. Ptr b -> Int -> IO HAddr
    $cpokeByteOff :: forall b. Ptr b -> Int -> HAddr -> IO ()
    pokeByteOff :: forall b. Ptr b -> Int -> HAddr -> IO ()
    $cpeek :: Ptr HAddr -> IO HAddr
    peek :: Ptr HAddr -> IO HAddr
    $cpoke :: Ptr HAddr -> HAddr -> IO ()
    poke :: Ptr HAddr -> HAddr -> IO ()
    Storable)

    hAddr :: HAddr -> HAddr_t
    hAddr :: HAddr -> HAddr_t
    hAddr (HAddr HAddr_t
    a) = HAddr_t
    a

    instance Read HAddr where
        readsPrec :: Int -> ReadS HAddr
    readsPrec Int
    p String
    s =
            [ (HAddr_t -> HAddr
    HAddr (Word64 -> HAddr_t
    HAddr_t Word64
    n), String
    rest)
            | (Word64
    n, String
    rest) <- Int -> ReadS Word64
    forall a. Read a => Int -> ReadS a
    readsPrec Int
    p String
    s
            ]

    instance Show HAddr where
        showsPrec :: Int -> HAddr -> ShowS
    showsPrec Int
    p (HAddr (HAddr_t Word64
    n)) = Int -> Word64 -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec Int
    p Word64
    n

    data IH_Info = IH_Info
        { IH_Info -> HSize
    indexSize     :: !HSize
        , IH_Info -> HSize
    heapSize      :: !HSize
        } deriving (IH_Info -> IH_Info -> Bool
    (IH_Info -> IH_Info -> Bool)
    -> (IH_Info -> IH_Info -> Bool) -> Eq IH_Info
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IH_Info -> IH_Info -> Bool
    == :: IH_Info -> IH_Info -> Bool
    $c/= :: IH_Info -> IH_Info -> Bool
    /= :: IH_Info -> IH_Info -> Bool
    Eq, Eq IH_Info
    Eq IH_Info =>
    (IH_Info -> IH_Info -> Ordering)
    -> (IH_Info -> IH_Info -> Bool)
    -> (IH_Info -> IH_Info -> Bool)
    -> (IH_Info -> IH_Info -> Bool)
    -> (IH_Info -> IH_Info -> Bool)
    -> (IH_Info -> IH_Info -> IH_Info)
    -> (IH_Info -> IH_Info -> IH_Info)
    -> Ord IH_Info
    IH_Info -> IH_Info -> Bool
    IH_Info -> IH_Info -> Ordering
    IH_Info -> IH_Info -> IH_Info
    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 :: IH_Info -> IH_Info -> Ordering
    compare :: IH_Info -> IH_Info -> Ordering
    $c< :: IH_Info -> IH_Info -> Bool
    < :: IH_Info -> IH_Info -> Bool
    $c<= :: IH_Info -> IH_Info -> Bool
    <= :: IH_Info -> IH_Info -> Bool
    $c> :: IH_Info -> IH_Info -> Bool
    > :: IH_Info -> IH_Info -> Bool
    $c>= :: IH_Info -> IH_Info -> Bool
    >= :: IH_Info -> IH_Info -> Bool
    $cmax :: IH_Info -> IH_Info -> IH_Info
    max :: IH_Info -> IH_Info -> IH_Info
    $cmin :: IH_Info -> IH_Info -> IH_Info
    min :: IH_Info -> IH_Info -> IH_Info
    Ord, ReadPrec [IH_Info]
    ReadPrec IH_Info
    Int -> ReadS IH_Info
    ReadS [IH_Info]
    (Int -> ReadS IH_Info)
    -> ReadS [IH_Info]
    -> ReadPrec IH_Info
    -> ReadPrec [IH_Info]
    -> Read IH_Info
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS IH_Info
    readsPrec :: Int -> ReadS IH_Info
    $creadList :: ReadS [IH_Info]
    readList :: ReadS [IH_Info]
    $creadPrec :: ReadPrec IH_Info
    readPrec :: ReadPrec IH_Info
    $creadListPrec :: ReadPrec [IH_Info]
    readListPrec :: ReadPrec [IH_Info]
    Read, Int -> IH_Info -> ShowS
    [IH_Info] -> ShowS
    IH_Info -> String
    (Int -> IH_Info -> ShowS)
    -> (IH_Info -> String) -> ([IH_Info] -> ShowS) -> Show IH_Info
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IH_Info -> ShowS
    showsPrec :: Int -> IH_Info -> ShowS
    $cshow :: IH_Info -> String
    show :: IH_Info -> String
    $cshowList :: [IH_Info] -> ShowS
    showList :: [IH_Info] -> ShowS
    Show)

    data IndexType
        = ByName
        | ByCreationOrder
        deriving (IndexType -> IndexType -> Bool
    (IndexType -> IndexType -> Bool)
    -> (IndexType -> IndexType -> Bool) -> Eq IndexType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IndexType -> IndexType -> Bool
    == :: IndexType -> IndexType -> Bool
    $c/= :: IndexType -> IndexType -> Bool
    /= :: IndexType -> IndexType -> Bool
    Eq, Eq IndexType
    Eq IndexType =>
    (IndexType -> IndexType -> Ordering)
    -> (IndexType -> IndexType -> Bool)
    -> (IndexType -> IndexType -> Bool)
    -> (IndexType -> IndexType -> Bool)
    -> (IndexType -> IndexType -> Bool)
    -> (IndexType -> IndexType -> IndexType)
    -> (IndexType -> IndexType -> IndexType)
    -> Ord IndexType
    IndexType -> IndexType -> Bool
    IndexType -> IndexType -> Ordering
    IndexType -> IndexType -> IndexType
    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 :: IndexType -> IndexType -> Ordering
    compare :: IndexType -> IndexType -> Ordering
    $c< :: IndexType -> IndexType -> Bool
    < :: IndexType -> IndexType -> Bool
    $c<= :: IndexType -> IndexType -> Bool
    <= :: IndexType -> IndexType -> Bool
    $c> :: IndexType -> IndexType -> Bool
    > :: IndexType -> IndexType -> Bool
    $c>= :: IndexType -> IndexType -> Bool
    >= :: IndexType -> IndexType -> Bool
    $cmax :: IndexType -> IndexType -> IndexType
    max :: IndexType -> IndexType -> IndexType
    $cmin :: IndexType -> IndexType -> IndexType
    min :: IndexType -> IndexType -> IndexType
    Ord, Int -> IndexType
    IndexType -> Int
    IndexType -> [IndexType]
    IndexType -> IndexType
    IndexType -> IndexType -> [IndexType]
    IndexType -> IndexType -> IndexType -> [IndexType]
    (IndexType -> IndexType)
    -> (IndexType -> IndexType)
    -> (Int -> IndexType)
    -> (IndexType -> Int)
    -> (IndexType -> [IndexType])
    -> (IndexType -> IndexType -> [IndexType])
    -> (IndexType -> IndexType -> [IndexType])
    -> (IndexType -> IndexType -> IndexType -> [IndexType])
    -> Enum IndexType
    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 :: IndexType -> IndexType
    succ :: IndexType -> IndexType
    $cpred :: IndexType -> IndexType
    pred :: IndexType -> IndexType
    $ctoEnum :: Int -> IndexType
    toEnum :: Int -> IndexType
    $cfromEnum :: IndexType -> Int
    fromEnum :: IndexType -> Int
    $cenumFrom :: IndexType -> [IndexType]
    enumFrom :: IndexType -> [IndexType]
    $cenumFromThen :: IndexType -> IndexType -> [IndexType]
    enumFromThen :: IndexType -> IndexType -> [IndexType]
    $cenumFromTo :: IndexType -> IndexType -> [IndexType]
    enumFromTo :: IndexType -> IndexType -> [IndexType]
    $cenumFromThenTo :: IndexType -> IndexType -> IndexType -> [IndexType]
    enumFromThenTo :: IndexType -> IndexType -> IndexType -> [IndexType]
    Enum, IndexType
    IndexType -> IndexType -> Bounded IndexType
    forall a. a -> a -> Bounded a
    $cminBound :: IndexType
    minBound :: IndexType
    $cmaxBound :: IndexType
    maxBound :: IndexType
    Bounded, ReadPrec [IndexType]
    ReadPrec IndexType
    Int -> ReadS IndexType
    ReadS [IndexType]
    (Int -> ReadS IndexType)
    -> ReadS [IndexType]
    -> ReadPrec IndexType
    -> ReadPrec [IndexType]
    -> Read IndexType
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS IndexType
    readsPrec :: Int -> ReadS IndexType
    $creadList :: ReadS [IndexType]
    readList :: ReadS [IndexType]
    $creadPrec :: ReadPrec IndexType
    readPrec :: ReadPrec IndexType
    $creadListPrec :: ReadPrec [IndexType]
    readListPrec :: ReadPrec [IndexType]
    Read, Int -> IndexType -> ShowS
    [IndexType] -> ShowS
    IndexType -> String
    (Int -> IndexType -> ShowS)
    -> (IndexType -> String)
    -> ([IndexType] -> ShowS)
    -> Show IndexType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IndexType -> ShowS
    showsPrec :: Int -> IndexType -> ShowS
    $cshow :: IndexType -> String
    show :: IndexType -> String
    $cshowList :: [IndexType] -> ShowS
    showList :: [IndexType] -> ShowS
    Show)

    indexTypeCode :: IndexType -> H5_index_t
    indexTypeCode :: IndexType -> H5_index_t
    indexTypeCode IndexType
    ByName            = H5_index_t
    h5_INDEX_NAME
    indexTypeCode IndexType
    ByCreationOrder   = H5_index_t
    h5_INDEX_CRT_ORDER

    data IterOrder
        = Increasing
        | Decreasing
        | Native
        deriving (IterOrder -> IterOrder -> Bool
    (IterOrder -> IterOrder -> Bool)
    -> (IterOrder -> IterOrder -> Bool) -> Eq IterOrder
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: IterOrder -> IterOrder -> Bool
    == :: IterOrder -> IterOrder -> Bool
    $c/= :: IterOrder -> IterOrder -> Bool
    /= :: IterOrder -> IterOrder -> Bool
    Eq, Eq IterOrder
    Eq IterOrder =>
    (IterOrder -> IterOrder -> Ordering)
    -> (IterOrder -> IterOrder -> Bool)
    -> (IterOrder -> IterOrder -> Bool)
    -> (IterOrder -> IterOrder -> Bool)
    -> (IterOrder -> IterOrder -> Bool)
    -> (IterOrder -> IterOrder -> IterOrder)
    -> (IterOrder -> IterOrder -> IterOrder)
    -> Ord IterOrder
    IterOrder -> IterOrder -> Bool
    IterOrder -> IterOrder -> Ordering
    IterOrder -> IterOrder -> IterOrder
    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 :: IterOrder -> IterOrder -> Ordering
    compare :: IterOrder -> IterOrder -> Ordering
    $c< :: IterOrder -> IterOrder -> Bool
    < :: IterOrder -> IterOrder -> Bool
    $c<= :: IterOrder -> IterOrder -> Bool
    <= :: IterOrder -> IterOrder -> Bool
    $c> :: IterOrder -> IterOrder -> Bool
    > :: IterOrder -> IterOrder -> Bool
    $c>= :: IterOrder -> IterOrder -> Bool
    >= :: IterOrder -> IterOrder -> Bool
    $cmax :: IterOrder -> IterOrder -> IterOrder
    max :: IterOrder -> IterOrder -> IterOrder
    $cmin :: IterOrder -> IterOrder -> IterOrder
    min :: IterOrder -> IterOrder -> IterOrder
    Ord, Int -> IterOrder
    IterOrder -> Int
    IterOrder -> [IterOrder]
    IterOrder -> IterOrder
    IterOrder -> IterOrder -> [IterOrder]
    IterOrder -> IterOrder -> IterOrder -> [IterOrder]
    (IterOrder -> IterOrder)
    -> (IterOrder -> IterOrder)
    -> (Int -> IterOrder)
    -> (IterOrder -> Int)
    -> (IterOrder -> [IterOrder])
    -> (IterOrder -> IterOrder -> [IterOrder])
    -> (IterOrder -> IterOrder -> [IterOrder])
    -> (IterOrder -> IterOrder -> IterOrder -> [IterOrder])
    -> Enum IterOrder
    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 :: IterOrder -> IterOrder
    succ :: IterOrder -> IterOrder
    $cpred :: IterOrder -> IterOrder
    pred :: IterOrder -> IterOrder
    $ctoEnum :: Int -> IterOrder
    toEnum :: Int -> IterOrder
    $cfromEnum :: IterOrder -> Int
    fromEnum :: IterOrder -> Int
    $cenumFrom :: IterOrder -> [IterOrder]
    enumFrom :: IterOrder -> [IterOrder]
    $cenumFromThen :: IterOrder -> IterOrder -> [IterOrder]
    enumFromThen :: IterOrder -> IterOrder -> [IterOrder]
    $cenumFromTo :: IterOrder -> IterOrder -> [IterOrder]
    enumFromTo :: IterOrder -> IterOrder -> [IterOrder]
    $cenumFromThenTo :: IterOrder -> IterOrder -> IterOrder -> [IterOrder]
    enumFromThenTo :: IterOrder -> IterOrder -> IterOrder -> [IterOrder]
    Enum, IterOrder
    IterOrder -> IterOrder -> Bounded IterOrder
    forall a. a -> a -> Bounded a
    $cminBound :: IterOrder
    minBound :: IterOrder
    $cmaxBound :: IterOrder
    maxBound :: IterOrder
    Bounded, ReadPrec [IterOrder]
    ReadPrec IterOrder
    Int -> ReadS IterOrder
    ReadS [IterOrder]
    (Int -> ReadS IterOrder)
    -> ReadS [IterOrder]
    -> ReadPrec IterOrder
    -> ReadPrec [IterOrder]
    -> Read IterOrder
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS IterOrder
    readsPrec :: Int -> ReadS IterOrder
    $creadList :: ReadS [IterOrder]
    readList :: ReadS [IterOrder]
    $creadPrec :: ReadPrec IterOrder
    readPrec :: ReadPrec IterOrder
    $creadListPrec :: ReadPrec [IterOrder]
    readListPrec :: ReadPrec [IterOrder]
    Read, Int -> IterOrder -> ShowS
    [IterOrder] -> ShowS
    IterOrder -> String
    (Int -> IterOrder -> ShowS)
    -> (IterOrder -> String)
    -> ([IterOrder] -> ShowS)
    -> Show IterOrder
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> IterOrder -> ShowS
    showsPrec :: Int -> IterOrder -> ShowS
    $cshow :: IterOrder -> String
    show :: IterOrder -> String
    $cshowList :: [IterOrder] -> ShowS
    showList :: [IterOrder] -> ShowS
    Show)

    iterOrderCode :: IterOrder -> H5_iter_order_t
    iterOrderCode :: IterOrder -> H5_iter_order_t
    iterOrderCode IterOrder
    Increasing = H5_iter_order_t
    h5_ITER_INC
    iterOrderCode IterOrder
    Decreasing = H5_iter_order_t
    h5_ITER_DEC
    iterOrderCode IterOrder
    Native     = H5_iter_order_t
    h5_ITER_NATIVE