{-# LANGUAGE UndecidableInstances #-}

-- |
-- Module      : Data.KindID.Internal
-- License     : MIT
-- Maintainer  : mmzk1526@outlook.com
-- Portability : GHC
--
module Data.KindID.Internal where

import           Control.Monad
import           Control.Monad.IO.Class
import           Data.Aeson.Types hiding (String)
import           Data.Binary
import           Data.ByteString.Lazy (ByteString)
import           Data.Hashable
import           Data.Proxy
import           Data.KindID.Class
import           Data.Text (Text)
import qualified Data.Text as T
import           Data.TypeID.Class
import           Data.TypeID.Error
import           Data.TypeID.Internal (TypeID'(..))
import qualified Data.TypeID.Internal as TID
import           Data.UUID.Types.Internal (UUID(..))
import           Data.TypeID.V7 (TypeID)
import qualified Data.UUID.V4 as V4
import qualified Data.UUID.V7 as V7
import           Data.UUID.Versions
import           Foreign
import           GHC.TypeLits (symbolVal)
import           System.Random

-- | A TypeID with the prefix encoded at type level.
--
-- It is dubbed 'Data.KindID.V7.KindID' because the prefix here is a data kind
-- rather than a type.
newtype KindID' (version :: UUIDVersion) prefix = KindID' UUID
  deriving (KindID' version prefix -> KindID' version prefix -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix -> KindID' version prefix -> Bool
/= :: KindID' version prefix -> KindID' version prefix -> Bool
$c/= :: forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix -> KindID' version prefix -> Bool
== :: KindID' version prefix -> KindID' version prefix -> Bool
$c== :: forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix -> KindID' version prefix -> Bool
Eq, KindID' version prefix -> KindID' version prefix -> Bool
KindID' version prefix -> KindID' version prefix -> Ordering
KindID' version prefix
-> KindID' version prefix -> KindID' version prefix
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (version :: UUIDVersion) k (prefix :: k).
Eq (KindID' version prefix)
forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix -> KindID' version prefix -> Bool
forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix -> KindID' version prefix -> Ordering
forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix
-> KindID' version prefix -> KindID' version prefix
min :: KindID' version prefix
-> KindID' version prefix -> KindID' version prefix
$cmin :: forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix
-> KindID' version prefix -> KindID' version prefix
max :: KindID' version prefix
-> KindID' version prefix -> KindID' version prefix
$cmax :: forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix
-> KindID' version prefix -> KindID' version prefix
>= :: KindID' version prefix -> KindID' version prefix -> Bool
$c>= :: forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix -> KindID' version prefix -> Bool
> :: KindID' version prefix -> KindID' version prefix -> Bool
$c> :: forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix -> KindID' version prefix -> Bool
<= :: KindID' version prefix -> KindID' version prefix -> Bool
$c<= :: forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix -> KindID' version prefix -> Bool
< :: KindID' version prefix -> KindID' version prefix -> Bool
$c< :: forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix -> KindID' version prefix -> Bool
compare :: KindID' version prefix -> KindID' version prefix -> Ordering
$ccompare :: forall (version :: UUIDVersion) k (prefix :: k).
KindID' version prefix -> KindID' version prefix -> Ordering
Ord)

instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => Show (KindID' version prefix) where
    show :: KindID' version prefix -> String
    show :: KindID' version prefix -> String
show = forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> String
toString
    {-# INLINE show #-}

instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => Read (KindID' version prefix) where
    readsPrec :: Int -> String -> [(KindID' version prefix, String)]
    readsPrec :: Int -> ReadS (KindID' version prefix)
readsPrec Int
_ String
str = case forall (version :: UUIDVersion).
String -> Either TypeIDError (TypeID' version, String)
TID.parseStringS String
str of
      Left TypeIDError
_           -> []
      Right (TypeID' version
tid, String
rem) -> case forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> Maybe (KindID' version prefix)
fromTypeID TypeID' version
tid of
        Maybe (KindID' version prefix)
Nothing  -> []
        Just KindID' version prefix
kid -> [(KindID' version prefix
kid, String
rem)]
    {-# INLINE readsPrec #-}

instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => ToJSON (KindID' version prefix) where
    toJSON :: KindID' version prefix -> Value
    toJSON :: KindID' version prefix -> Value
toJSON = forall a. ToJSON a => a -> Value
toJSON forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> Text
toText
    {-# INLINE toJSON #-}

instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => FromJSON (KindID' version prefix) where
    parseJSON :: Value -> Parser (KindID' version prefix)
    parseJSON :: Value -> Parser (KindID' version prefix)
parseJSON Value
str = do
      Text
s <- forall a. FromJSON a => Value -> Parser a
parseJSON Value
str
      case forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
Text -> Either TypeIDError (KindID' version prefix)
parseText Text
s of
        Left TypeIDError
err  -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show TypeIDError
err
        Right KindID' version prefix
kid -> forall (f :: * -> *) a. Applicative f => a -> f a
pure KindID' version prefix
kid
    {-# INLINE parseJSON #-}

instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => ToJSONKey (KindID' version prefix) where
    toJSONKey :: ToJSONKeyFunction (KindID' version prefix)
    toJSONKey :: ToJSONKeyFunction (KindID' version prefix)
toJSONKey = forall a. (a -> Text) -> ToJSONKeyFunction a
toJSONKeyText forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> Text
toText
    {-# INLINE toJSONKey #-}

instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => FromJSONKey (KindID' version prefix) where
    fromJSONKey :: FromJSONKeyFunction (KindID' version prefix)
    fromJSONKey :: FromJSONKeyFunction (KindID' version prefix)
fromJSONKey = forall a. (Text -> Parser a) -> FromJSONKeyFunction a
FromJSONKeyTextParser \Text
t -> case forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
Text -> Either TypeIDError (KindID' version prefix)
parseText Text
t of
      Left TypeIDError
err  -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show TypeIDError
err
      Right KindID' version prefix
kid -> forall (f :: * -> *) a. Applicative f => a -> f a
pure KindID' version prefix
kid
    {-# INLINE fromJSONKey #-}

-- | See The 'Binary' instance of 'TypeID''.
instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => Binary (KindID' version prefix) where
    put :: KindID' version prefix -> Put
    put :: KindID' version prefix -> Put
put = forall t. Binary t => t -> Put
put forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
    {-# INLINE put #-}

    get :: Get (KindID' version prefix)
    get :: Get (KindID' version prefix)
get = do
      TypeID' version
tid <- forall t. Binary t => Get t
get :: Get (TypeID' version)
      case forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> Maybe (KindID' version prefix)
fromTypeID TypeID' version
tid of
        Maybe (KindID' version prefix)
Nothing  -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Binary: Prefix mismatch"
        Just KindID' version prefix
kid -> forall (f :: * -> *) a. Applicative f => a -> f a
pure KindID' version prefix
kid
    {-# INLINE get #-}

-- | Similar to the 'Binary' instance, but the 'UUID' is stored in host endian.
instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => Storable (KindID' version prefix) where
    sizeOf :: KindID' version prefix -> Int
    sizeOf :: KindID' version prefix -> Int
sizeOf = forall a. Storable a => a -> Int
sizeOf forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
    {-# INLINE sizeOf #-}

    alignment :: KindID' version prefix -> Int
    alignment :: KindID' version prefix -> Int
alignment = forall a. Storable a => a -> Int
alignment forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
    {-# INLINE alignment #-}

    peek :: Ptr (KindID' version prefix) -> IO (KindID' version prefix)
    peek :: Ptr (KindID' version prefix) -> IO (KindID' version prefix)
peek Ptr (KindID' version prefix)
ptr = do
      TypeID' version
tid <- forall a. Storable a => Ptr a -> IO a
peek forall a b. (a -> b) -> a -> b
$ forall a b. Ptr a -> Ptr b
castPtr Ptr (KindID' version prefix)
ptr :: IO (TypeID' version)
      case forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> Maybe (KindID' version prefix)
fromTypeID TypeID' version
tid of
        Maybe (KindID' version prefix)
Nothing  -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Storable: Prefix mismatch"
        Just KindID' version prefix
kid -> forall (f :: * -> *) a. Applicative f => a -> f a
pure KindID' version prefix
kid
    {-# INLINE peek #-}

    poke :: Ptr (KindID' version prefix) -> KindID' version prefix -> IO ()
    poke :: Ptr (KindID' version prefix) -> KindID' version prefix -> IO ()
poke Ptr (KindID' version prefix)
ptr = forall a. Storable a => Ptr a -> a -> IO ()
poke (forall a b. Ptr a -> Ptr b
castPtr Ptr (KindID' version prefix)
ptr) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
    {-# INLINE poke #-}

instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => Hashable (KindID' version prefix) where
    hashWithSalt :: Int -> KindID' version prefix -> Int
    hashWithSalt :: Int -> KindID' version prefix -> Int
hashWithSalt Int
salt = forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
salt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
    {-# INLINE hashWithSalt #-}

-- | Get the prefix, 'UUID', and timestamp of a 'KindID''.
instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => IDType (KindID' version prefix) where
    getPrefix :: KindID' version prefix -> Text
    getPrefix :: KindID' version prefix -> Text
getPrefix KindID' version prefix
_ = String -> Text
T.pack (forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (forall {k} (t :: k). Proxy t
Proxy @(PrefixSymbol prefix)))
    {-# INLINE getPrefix #-}

    getUUID :: KindID' version prefix -> UUID
    getUUID :: KindID' version prefix -> UUID
getUUID (KindID' UUID
uuid) = UUID
uuid
    {-# INLINE getUUID #-}

    getTime :: KindID' version prefix -> Word64
    getTime :: KindID' version prefix -> Word64
getTime = UUID -> Word64
V7.getTime forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IDType a => a -> UUID
getUUID
    {-# INLINE getTime #-}

-- | Conversion between 'KindID'' and 'String'/'Text'/'ByteString'.
instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => IDConv (KindID' version prefix) where
    string2ID :: String -> Either TypeIDError (KindID' version prefix)
    string2ID :: String -> Either TypeIDError (KindID' version prefix)
string2ID = forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
String -> Either TypeIDError (KindID' version prefix)
parseString
    {-# INLINE string2ID #-}

    text2ID :: Text -> Either TypeIDError (KindID' version prefix)
    text2ID :: Text -> Either TypeIDError (KindID' version prefix)
text2ID = forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
Text -> Either TypeIDError (KindID' version prefix)
parseText
    {-# INLINE text2ID #-}

    byteString2ID :: ByteString -> Either TypeIDError (KindID' version prefix)
    byteString2ID :: ByteString -> Either TypeIDError (KindID' version prefix)
byteString2ID = forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
ByteString -> Either TypeIDError (KindID' version prefix)
parseByteString
    {-# INLINE byteString2ID #-}

    id2String :: KindID' version prefix -> String
    id2String :: KindID' version prefix -> String
id2String = forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> String
toString
    {-# INLINE id2String #-}

    id2Text :: KindID' version prefix -> Text
    id2Text :: KindID' version prefix -> Text
id2Text = forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> Text
toText
    {-# INLINE id2Text #-}

    id2ByteString :: KindID' version prefix -> ByteString
    id2ByteString :: KindID' version prefix -> ByteString
id2ByteString = forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> ByteString
toByteString
    {-# INLINE id2ByteString #-}

    unsafeString2ID :: String -> KindID' version prefix
    unsafeString2ID :: String -> KindID' version prefix
unsafeString2ID = forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
String -> KindID' version prefix
unsafeParseString
    {-# INLINE unsafeString2ID #-}

    unsafeText2ID :: Text -> KindID' version prefix
    unsafeText2ID :: Text -> KindID' version prefix
unsafeText2ID = forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
Text -> KindID' version prefix
unsafeParseText
    {-# INLINE unsafeText2ID #-}

    unsafeByteString2ID :: ByteString -> KindID' version prefix
    unsafeByteString2ID :: ByteString -> KindID' version prefix
unsafeByteString2ID = forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
ByteString -> KindID' version prefix
unsafeParseByteString
    {-# INLINE unsafeByteString2ID #-}

-- | Generate 'Data.KindID.V7.KindID's.
instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => IDGen (KindID' 'V7 prefix) where
    type IDGenPrefix (KindID' 'V7 prefix) = 'Nothing

    genID_ :: MonadIO m => Proxy (KindID' 'V7 prefix) -> m (KindID' 'V7 prefix)
    genID_ :: forall (m :: * -> *).
MonadIO m =>
Proxy (KindID' 'V7 prefix) -> m (KindID' 'V7 prefix)
genID_ Proxy (KindID' 'V7 prefix)
_ = forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
m (KindID' 'V7 prefix)
genKindID
    {-# INLINE genID_ #-}

    genID'_ :: MonadIO m => Proxy (KindID' 'V7 prefix) -> m (KindID' 'V7 prefix)
    genID'_ :: forall (m :: * -> *).
MonadIO m =>
Proxy (KindID' 'V7 prefix) -> m (KindID' 'V7 prefix)
genID'_ Proxy (KindID' 'V7 prefix)
_ = forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
m (KindID' 'V7 prefix)
genKindID'
    {-# INLINE genID'_ #-}

    genIDs_ :: MonadIO m
            => Proxy (KindID' 'V7 prefix) -> Word16 -> m [KindID' 'V7 prefix]
    genIDs_ :: forall (m :: * -> *).
MonadIO m =>
Proxy (KindID' 'V7 prefix) -> Word16 -> m [KindID' 'V7 prefix]
genIDs_ Proxy (KindID' 'V7 prefix)
_ = forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
Word16 -> m [KindID' 'V7 prefix]
genKindIDs
    {-# INLINE genIDs_ #-}

    decorate_ :: Proxy (KindID' 'V7 prefix) -> UUID -> KindID' 'V7 prefix
    decorate_ :: Proxy (KindID' 'V7 prefix) -> UUID -> KindID' 'V7 prefix
decorate_ Proxy (KindID' 'V7 prefix)
_ = forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
UUID -> KindID' version prefix
decorateKindID
    {-# INLINE decorate_ #-}

    checkID_ :: Proxy (KindID' 'V7 prefix)
             -> KindID' 'V7 prefix
             -> Maybe TypeIDError
    checkID_ :: Proxy (KindID' 'V7 prefix)
-> KindID' 'V7 prefix -> Maybe TypeIDError
checkID_ Proxy (KindID' 'V7 prefix)
_ = forall {k} (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' 'V7 prefix -> Maybe TypeIDError
checkKindID
    {-# INLINE checkID_ #-}

    checkIDWithEnv_ :: MonadIO m
                    => Proxy (KindID' 'V7 prefix)
                    -> KindID' 'V7 prefix
                    -> m (Maybe TypeIDError)
    checkIDWithEnv_ :: forall (m :: * -> *).
MonadIO m =>
Proxy (KindID' 'V7 prefix)
-> KindID' 'V7 prefix -> m (Maybe TypeIDError)
checkIDWithEnv_ Proxy (KindID' 'V7 prefix)
_ = forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
KindID' 'V7 prefix -> m (Maybe TypeIDError)
checkKindIDWithEnv
    {-# INLINE checkIDWithEnv_ #-}

-- | Generate 'KindID'' ''V4's.
instance (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
  => IDGen (KindID' 'V4 prefix) where
    type IDGenPrefix (KindID' 'V4 prefix) = 'Nothing

    genID_ :: MonadIO m => Proxy (KindID' 'V4 prefix) -> m (KindID' 'V4 prefix)
    genID_ :: forall (m :: * -> *).
MonadIO m =>
Proxy (KindID' 'V4 prefix) -> m (KindID' 'V4 prefix)
genID_ Proxy (KindID' 'V4 prefix)
_ = forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
m (KindID' 'V4 prefix)
genKindIDV4
    {-# INLINE genID_ #-}

    genID'_ :: MonadIO m => Proxy (KindID' 'V4 prefix) -> m (KindID' 'V4 prefix)
    genID'_ :: forall (m :: * -> *).
MonadIO m =>
Proxy (KindID' 'V4 prefix) -> m (KindID' 'V4 prefix)
genID'_ Proxy (KindID' 'V4 prefix)
_ = forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
m (KindID' 'V4 prefix)
genKindIDV4'
    {-# INLINE genID'_ #-}

    genIDs_ :: MonadIO m
            => Proxy (KindID' 'V4 prefix) -> Word16 -> m [KindID' 'V4 prefix]
    genIDs_ :: forall (m :: * -> *).
MonadIO m =>
Proxy (KindID' 'V4 prefix) -> Word16 -> m [KindID' 'V4 prefix]
genIDs_ Proxy (KindID' 'V4 prefix)
_ Word16
n
      = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {k} (version :: UUIDVersion) (prefix :: k).
UUID -> KindID' version prefix
KindID' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM (forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
n) (forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO UUID
V4.nextRandom)
    {-# INLINE genIDs_ #-}

    decorate_ :: Proxy (KindID' 'V4 prefix) -> UUID -> KindID' 'V4 prefix
    decorate_ :: Proxy (KindID' 'V4 prefix) -> UUID -> KindID' 'V4 prefix
decorate_ Proxy (KindID' 'V4 prefix)
_ = forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
UUID -> KindID' version prefix
decorateKindID
    {-# INLINE decorate_ #-}

    checkID_ :: Proxy (KindID' 'V4 prefix)
             -> KindID' 'V4 prefix
             -> Maybe TypeIDError
    checkID_ :: Proxy (KindID' 'V4 prefix)
-> KindID' 'V4 prefix -> Maybe TypeIDError
checkID_ Proxy (KindID' 'V4 prefix)
_ = forall {k} (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' 'V4 prefix -> Maybe TypeIDError
checkKindIDV4
    {-# INLINE checkID_ #-}

-- | Generate a new 'Data.KindID.V7.KindID' from a prefix.
--
-- It throws a 'TypeIDError' if the prefix does not match the specification,
-- namely if it's longer than 63 characters or if it contains characters other
-- than lowercase latin letters.
genKindID :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m)
          => m (KindID' 'V7 prefix)
genKindID :: forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
m (KindID' 'V7 prefix)
genKindID = forall {k} (version :: UUIDVersion) (prefix :: k).
UUID -> KindID' version prefix
KindID' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadIO m => m UUID
V7.genUUID
{-# INLINE genKindID #-}

-- | Generate a new 'Data.KindID.V7.KindID' from a prefix based on stateless
-- 'UUID'v7.
--
-- See the documentation of 'V7.genUUID'' for more information.
genKindID' :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m)
           => m (KindID' 'V7 prefix)
genKindID' :: forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
m (KindID' 'V7 prefix)
genKindID' = forall {k} (version :: UUIDVersion) (prefix :: k).
UUID -> KindID' version prefix
KindID' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadIO m => m UUID
V7.genUUID'
{-# INLINE genKindID' #-}

-- | Generate a list of 'Data.KindID.V7.KindID's from a prefix.
--
-- It tries its best to generate 'Data.KindID.V7.KindID's at the same timestamp,
-- but it may not be possible if we are asking too many 'UUID's at the same
-- time.
--
-- It is guaranteed that the first 32768 'Data.KindID.V7.KindID's are generated
-- at the same timestamp.
genKindIDs :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m)
           => Word16 -> m [KindID' 'V7 prefix]
genKindIDs :: forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
Word16 -> m [KindID' 'V7 prefix]
genKindIDs Word16
n = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {k} (version :: UUIDVersion) (prefix :: k).
UUID -> KindID' version prefix
KindID' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadIO m => Word16 -> m [UUID]
V7.genUUIDs Word16
n
{-# INLINE genKindIDs #-}

-- | Generate a new 'KindID'' ''V4' from a prefix.
--
-- It throws a 'TypeIDError' if the prefix does not match the specification,
-- namely if it's longer than 63 characters or if it contains characters other
-- than lowercase latin letters.
genKindIDV4 :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m)
            => m (KindID' 'V4 prefix)
genKindIDV4 :: forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
m (KindID' 'V4 prefix)
genKindIDV4 = forall {k} (version :: UUIDVersion) (prefix :: k).
UUID -> KindID' version prefix
KindID' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO UUID
V4.nextRandom
{-# INLINE genKindIDV4 #-}

-- | Generate a new 'KindID'' ''V4' from a prefix with insecure 'UUID'v4.
genKindIDV4' :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m)
             => m (KindID' 'V4 prefix)
genKindIDV4' :: forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
m (KindID' 'V4 prefix)
genKindIDV4' = forall {k} (version :: UUIDVersion) (prefix :: k).
UUID -> KindID' version prefix
KindID' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a (m :: * -> *). (Random a, MonadIO m) => m a
randomIO
{-# INLINE genKindIDV4' #-}

-- | Obtain a 'KindID'' from a prefix and a 'UUID'.
decorateKindID :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
               => UUID -> KindID' version prefix
decorateKindID :: forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
UUID -> KindID' version prefix
decorateKindID = forall {k} (version :: UUIDVersion) (prefix :: k).
UUID -> KindID' version prefix
KindID'
{-# INLINE decorateKindID #-}

-- | Convert a 'KindID'' to a 'TypeID''.
toTypeID :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
         => KindID' version prefix -> TypeID' version
toTypeID :: forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID KindID' version prefix
kid = forall (version :: UUIDVersion). Text -> UUID -> TypeID' version
TID.TypeID' (forall a. IDType a => a -> Text
getPrefix KindID' version prefix
kid) (forall a. IDType a => a -> UUID
getUUID KindID' version prefix
kid)
{-# INLINE toTypeID #-}

-- | Convert a 'TypeID'' to a 'KindID''. If the actual prefix does not match
-- with the expected one as defined by the type, it returns @Nothing@.
fromTypeID :: forall version prefix
            . (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
           => TypeID' version -> Maybe (KindID' version prefix)
fromTypeID :: forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> Maybe (KindID' version prefix)
fromTypeID TypeID' version
tid = do
  forall (f :: * -> *). Alternative f => Bool -> f ()
guard (String -> Text
T.pack (forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (forall {k} (t :: k). Proxy t
Proxy @(PrefixSymbol prefix))) forall a. Eq a => a -> a -> Bool
== forall a. IDType a => a -> Text
getPrefix TypeID' version
tid)
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall {k} (version :: UUIDVersion) (prefix :: k).
UUID -> KindID' version prefix
KindID' (forall a. IDType a => a -> UUID
getUUID TypeID' version
tid)
{-# INLINE fromTypeID #-}

-- | Pretty-print a 'KindID''. It is 'id2String' with concrete type.
toString :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
         => KindID' version prefix -> String
toString :: forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> String
toString = forall (version :: UUIDVersion). TypeID' version -> String
TID.toString forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
{-# INLINE toString #-}

-- | Pretty-print a 'KindID'' to strict 'Text'. It is 'id2Text' with concrete
-- type.
toText :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
       => KindID' version prefix -> Text
toText :: forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> Text
toText = forall (version :: UUIDVersion). TypeID' version -> Text
TID.toText forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
{-# INLINE toText #-}

-- | Pretty-print a 'KindID'' to lazy 'ByteString'. It is 'id2ByteString' with
-- concrete type.
toByteString :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
             => KindID' version prefix -> ByteString
toByteString :: forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> ByteString
toByteString = forall (version :: UUIDVersion). TypeID' version -> ByteString
TID.toByteString forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
{-# INLINE toByteString #-}

-- | Parse a 'KindID'' from its 'String' representation. It is 'parseString'
-- with concrete type.
parseString :: forall version prefix
             . (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
            => String -> Either TypeIDError (KindID' version prefix)
parseString :: forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
String -> Either TypeIDError (KindID' version prefix)
parseString String
str = do
  TypeID' version
tid <- forall (version :: UUIDVersion).
String -> Either TypeIDError (TypeID' version)
TID.parseString String
str
  case forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> Maybe (KindID' version prefix)
fromTypeID TypeID' version
tid of
    Maybe (KindID' version prefix)
Nothing  -> forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ Text -> Text -> TypeIDError
TypeIDErrorPrefixMismatch
                       (String -> Text
T.pack (forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (forall {k} (t :: k). Proxy t
Proxy @(PrefixSymbol prefix))))
                       (forall a. IDType a => a -> Text
getPrefix TypeID' version
tid)
    Just KindID' version prefix
kid -> forall (f :: * -> *) a. Applicative f => a -> f a
pure KindID' version prefix
kid
{-# INLINE parseString #-}

-- | Parse a 'KindID'' from its string representation as a strict 'Text'. It is
-- 'parseText' with concrete type.
parseText :: forall version prefix
           . (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
          => Text -> Either TypeIDError (KindID' version prefix)
parseText :: forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
Text -> Either TypeIDError (KindID' version prefix)
parseText Text
str = do
  TypeID' version
tid <- forall (version :: UUIDVersion).
Text -> Either TypeIDError (TypeID' version)
TID.parseText Text
str
  case forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> Maybe (KindID' version prefix)
fromTypeID TypeID' version
tid of
    Maybe (KindID' version prefix)
Nothing  -> forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ Text -> Text -> TypeIDError
TypeIDErrorPrefixMismatch
                       (String -> Text
T.pack (forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (forall {k} (t :: k). Proxy t
Proxy @(PrefixSymbol prefix))))
                       (forall a. IDType a => a -> Text
getPrefix TypeID' version
tid)
    Just KindID' version prefix
kid -> forall (f :: * -> *) a. Applicative f => a -> f a
pure KindID' version prefix
kid
{-# INLINE parseText #-}

-- | Parse a 'KindID'' from its string representation as a lazy 'ByteString'. It
-- is 'parseByteString' with concrete type.
parseByteString :: forall version prefix
                 . (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
                => ByteString -> Either TypeIDError (KindID' version prefix)
parseByteString :: forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
ByteString -> Either TypeIDError (KindID' version prefix)
parseByteString ByteString
str = do
  TypeID' version
tid <- forall (version :: UUIDVersion).
ByteString -> Either TypeIDError (TypeID' version)
TID.parseByteString ByteString
str
  case forall {k} (version :: UUIDVersion) (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> Maybe (KindID' version prefix)
fromTypeID TypeID' version
tid of
    Maybe (KindID' version prefix)
Nothing  -> forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ Text -> Text -> TypeIDError
TypeIDErrorPrefixMismatch
                       (String -> Text
T.pack (forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal (forall {k} (t :: k). Proxy t
Proxy @(PrefixSymbol prefix))))
                       (forall a. IDType a => a -> Text
getPrefix TypeID' version
tid)
    Just KindID' version prefix
kid -> forall (f :: * -> *) a. Applicative f => a -> f a
pure KindID' version prefix
kid
{-# INLINE parseByteString #-}

-- | Parse a 'KindID'' from its 'String' representation, throwing an error when
-- the parsing fails. It is 'string2IDM' with concrete type.
parseStringM :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m)
             => String -> m (KindID' version prefix)
parseStringM :: forall {k} (prefix :: k) (m :: * -> *) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
String -> m (KindID' version prefix)
parseStringM = forall a (m :: * -> *). (IDConv a, MonadIO m) => String -> m a
string2IDM
{-# INLINE parseStringM #-}

-- | Parse a 'KindID'' from its string representation as a strict 'Text',
-- throwing an error when the parsing fails. It is 'text2IDM' with concrete
-- type.
parseTextM :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m)
           => Text -> m (KindID' version prefix)
parseTextM :: forall {k} (prefix :: k) (m :: * -> *) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
Text -> m (KindID' version prefix)
parseTextM = forall a (m :: * -> *). (IDConv a, MonadIO m) => Text -> m a
text2IDM
{-# INLINE parseTextM #-}

-- | Parse a 'KindID'' from its string representation as a lazy 'ByteString',
-- throwing an error when the parsing fails. It is 'byteString2IDM' with
-- concrete type.
parseByteStringM :: ( ToPrefix prefix
                    , ValidPrefix (PrefixSymbol prefix)
                    , MonadIO m )
                 => ByteString
                 -> m (KindID' version prefix)
parseByteStringM :: forall {k} (prefix :: k) (m :: * -> *) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
ByteString -> m (KindID' version prefix)
parseByteStringM = forall a (m :: * -> *). (IDConv a, MonadIO m) => ByteString -> m a
byteString2IDM
{-# INLINE parseByteStringM #-}

-- | Check if the prefix is valid and the suffix 'UUID' has the correct v7
-- version and variant.
checkKindID :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
            => KindID' 'V7 prefix -> Maybe TypeIDError
checkKindID :: forall {k} (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' 'V7 prefix -> Maybe TypeIDError
checkKindID = TypeID' 'V7 -> Maybe TypeIDError
TID.checkTypeID forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
{-# INLINE checkKindID #-}

-- | Similar to 'checkKindID', but also checks if the suffix 'UUID' is
-- generated in the past.
checkKindIDWithEnv :: ( ToPrefix prefix
                      , ValidPrefix (PrefixSymbol prefix)
                      , MonadIO m )
                   => KindID' 'V7 prefix -> m (Maybe TypeIDError)
checkKindIDWithEnv :: forall {k} (prefix :: k) (m :: * -> *).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix), MonadIO m) =>
KindID' 'V7 prefix -> m (Maybe TypeIDError)
checkKindIDWithEnv = forall (m :: * -> *).
MonadIO m =>
TypeID' 'V7 -> m (Maybe TypeIDError)
TID.checkTypeIDWithEnv forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
{-# INLINE checkKindIDWithEnv #-}

-- | Check if the prefix is valid and the suffix 'UUID' has the correct v4
-- version and variant.
checkKindIDV4 :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
              => KindID' 'V4 prefix -> Maybe TypeIDError
checkKindIDV4 :: forall {k} (prefix :: k).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' 'V4 prefix -> Maybe TypeIDError
checkKindIDV4 = TypeID' 'V4 -> Maybe TypeIDError
TID.checkTypeIDV4 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
KindID' version prefix -> TypeID' version
toTypeID
{-# INLINE checkKindIDV4 #-}

-- | Convert a 'TypeID'' to a 'KindID''. If the actual prefix does not match
-- with the expected one as defined by the type, it does not complain and
-- produces a wrong 'KindID''.
unsafeFromTypeID :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
                 => TypeID' version -> KindID' version prefix
unsafeFromTypeID :: forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> KindID' version prefix
unsafeFromTypeID TypeID' version
tid = forall {k} (version :: UUIDVersion) (prefix :: k).
UUID -> KindID' version prefix
KindID' (forall a. IDType a => a -> UUID
getUUID TypeID' version
tid)
{-# INLINE unsafeFromTypeID #-}

-- | Parse a 'KindID'' from its 'String' representation, but does not behave
-- correctly when parsing fails.
--
-- More specifically, if the prefix does not match, it will not complain and
-- produce the wrong 'KindID''. If there are other parse errors, it will crash.
unsafeParseString :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
                  => String -> KindID' version prefix
unsafeParseString :: forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
String -> KindID' version prefix
unsafeParseString = forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> KindID' version prefix
unsafeFromTypeID forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (version :: UUIDVersion). String -> TypeID' version
TID.unsafeParseString
{-# INLINE unsafeParseString #-}

-- | Parse a 'KindID'' from its string representation as a strict 'Text', but
-- does not behave correctly when parsing fails.
--
-- More specifically, if the prefix does not match, it will not complain and
-- produce the wrong 'KindID''. If there are other parse errors, it will crash.
unsafeParseText :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
                => Text -> KindID' version prefix
unsafeParseText :: forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
Text -> KindID' version prefix
unsafeParseText = forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> KindID' version prefix
unsafeFromTypeID forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (version :: UUIDVersion). Text -> TypeID' version
TID.unsafeParseText
{-# INLINE unsafeParseText #-}

-- | Parse a 'KindID'' from its string representation as a lazy 'ByteString', but
-- does not behave correctly when parsing fails.
--
-- More specifically, if the prefix does not match, it will not complain and
-- produce the wrong 'KindID''. If there are other parse errors, it will crash.
unsafeParseByteString :: (ToPrefix prefix, ValidPrefix (PrefixSymbol prefix))
                      => ByteString -> KindID' version prefix
unsafeParseByteString :: forall k (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
ByteString -> KindID' version prefix
unsafeParseByteString = forall {k} (prefix :: k) (version :: UUIDVersion).
(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) =>
TypeID' version -> KindID' version prefix
unsafeFromTypeID forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (version :: UUIDVersion). ByteString -> TypeID' version
TID.unsafeParseByteString
{-# INLINE unsafeParseByteString #-}