Data.TypeID.Class

A module with the APIs for any TypeID-ish identifier type.

These type classes are useful to define custom TypeID-ish identifier types. For example, if one wishes to remove the constraints on prefix, or use a different UUID version for the suffix.

Type classes

type TypeIDLike a = (IDType a, IDConv a, IDGen a)

A constraint synonym for a TypeID-ish identifier type that supports ID generation and string conversion.

class IDType a where

A type class for a TypeID-ish identifier type, which has a Text prefix and a UUID suffix.

Methods

getPrefix :: a -> Text

Get the prefix of the identifier.

getUUID :: a -> UUID

Get the UUID suffix of the identifier.

getTime :: a -> Word64

Get the timestamp of the identifier. Returns 0 if the identifier is not timestamp-based.

Instances

IDType (TypeID' version)

Get the prefix, UUID, and timestamp of a TypeID'.

Defined in Data.TypeID.Internal

Methods

getPrefix :: TypeID' version -> Text

getUUID :: TypeID' version -> UUID

getTime :: TypeID' version -> Word64

(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) => IDType (KindID' version prefix)

Get the prefix, UUID, and timestamp of a KindID'.

Defined in Data.KindID.Internal

Methods

getPrefix :: KindID' version prefix -> Text

getUUID :: KindID' version prefix -> UUID

getTime :: KindID' version prefix -> Word64

class IDConv a where

A type class for converting between a TypeID-ish identifier type and some string representations.

Minimal complete definition

string2ID, id2String | string2ID, id2Text | string2ID, id2ByteString | text2ID, id2String | text2ID, id2Text | text2ID, id2ByteString | byteString2ID, id2String | byteString2ID, id2Text | byteString2ID, id2ByteString

Methods

string2ID :: String -> Either TypeIDError a

Parse the identifier from its String representation.

text2ID :: Text -> Either TypeIDError a

Parse the identifier from its string representation as a strict Text.

byteString2ID :: ByteString -> Either TypeIDError a

Parse the identifier from its string representation as a lazy ByteString.

id2String :: a -> String

Pretty-print the identifier to a String.

id2Text :: a -> Text

Pretty-print the identifier to a strict Text.

id2ByteString :: a -> ByteString

Pretty-print the identifier to a lazy ByteString.

string2IDM :: MonadIO m => String -> m a

Parse the identifier from its String representation, throwing an error when the parsing fails.

text2IDM :: MonadIO m => Text -> m a

Parse the identifier from its string representation as a strict Text, throwing an error when the parsing fails.

byteString2IDM :: MonadIO m => ByteString -> m a

Parse the identifier from its string representation as a lazy ByteString, throwing an error when the parsing fails.

unsafeString2ID :: String -> a

Parse the identifier from its String representation, but crashes when the parsing fails.

unsafeText2ID :: Text -> a

Parse the identifier from its string representation as a strict Text, but crashes when the parsing fails.

unsafeByteString2ID :: ByteString -> a

Parse the identifier from its string representation as a lazy ByteString, but crashes when the parsing fails.

Instances

IDConv (TypeID' version)

Conversion between TypeID' and StringTextByteString.

Defined in Data.TypeID.Internal

Methods

string2ID :: String -> Either TypeIDError (TypeID' version)

text2ID :: Text -> Either TypeIDError (TypeID' version)

byteString2ID :: ByteString -> Either TypeIDError (TypeID' version)

id2String :: TypeID' version -> String

id2Text :: TypeID' version -> Text

id2ByteString :: TypeID' version -> ByteString

string2IDM :: MonadIO m => String -> m (TypeID' version)

text2IDM :: MonadIO m => Text -> m (TypeID' version)

byteString2IDM :: MonadIO m => ByteString -> m (TypeID' version)

unsafeString2ID :: String -> TypeID' version

unsafeText2ID :: Text -> TypeID' version

unsafeByteString2ID :: ByteString -> TypeID' version

(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) => IDConv (KindID' version prefix)

Conversion between KindID' and StringTextByteString.

Defined in Data.KindID.Internal

Methods

string2ID :: String -> Either TypeIDError (KindID' version prefix)

text2ID :: Text -> Either TypeIDError (KindID' version prefix)

byteString2ID :: ByteString -> Either TypeIDError (KindID' version prefix)

id2String :: KindID' version prefix -> String

id2Text :: KindID' version prefix -> Text

id2ByteString :: KindID' version prefix -> ByteString

string2IDM :: MonadIO m => String -> m (KindID' version prefix)

text2IDM :: MonadIO m => Text -> m (KindID' version prefix)

byteString2IDM :: MonadIO m => ByteString -> m (KindID' version prefix)

unsafeString2ID :: String -> KindID' version prefix

unsafeText2ID :: Text -> KindID' version prefix

unsafeByteString2ID :: ByteString -> KindID' version prefix

class IDGen a where

A type class for generating TypeID-ish identifiers.

The methods in this type class are not directly used since each of them has a dummy Proxy in order to compile. We implement the methods here and use the methods without the underscore suffix instead.

Minimal complete definition

genID_, genIDs_, decorate_, checkID_

Associated Types

type IDGenPrefix a :: Maybe Type

If the identifier has compile-time determined prefix, this type should be 'Nothing. Otherwise it should be 'Just prefix where prefix is the type of the prefix (e.g. Text).

type IDGenReq a r :: Type

If the identifier's generation requires additional information (such as UUID version 5), this type corresponds to how to generate r from the required information. Otherwise it should be simply type IDGenReq a r = r .

Methods

genID_ :: MonadIO m => Proxy a -> GenFunc (IDGenPrefix a) (IDGenReq a (m a))

Generate an identifier with the given prefix.

genID'_ :: forall m. MonadIO m => Proxy a -> GenFunc (IDGenPrefix a) (IDGenReq a (m a))

Similar to genID_, but stateless. It can be a faster implementation than genID_, but it does not guarantee any stateful property, such as monotonically increasing for UUIDv7-based identifiers.

The default implementation is the same as genID_.

genIDs_ :: forall m. MonadIO m => Proxy a -> GenFunc (IDGenPrefix a) (IDGenReq a (Word16 -> m [a]))

Generate a list of identifiers with the given prefix.

decorate_ :: Proxy a -> GenFunc (IDGenPrefix a) (UUID -> ResWithErr (IDGenPrefix a) a)

Generate a new identifier with the given prefix and UUID suffix.

checkID_ :: Proxy a -> a -> Maybe TypeIDError

Check the validity of the identifier.

checkIDWithEnv_ :: MonadIO m => Proxy a -> a -> m (Maybe TypeIDError)

Check the validity of the identifier, potentially with impure criteria.

Instances

IDGen (TypeID' 'V1)

Generate TypeID' 'V1s.

Defined in Data.TypeID.Internal

Associated Types

type IDGenPrefix (TypeID' 'V1) :: Maybe Type

type IDGenReq (TypeID' 'V1) r

Methods

genID_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V1) -> GenFunc (IDGenPrefix (TypeID' 'V1)) (IDGenReq (TypeID' 'V1) (m (TypeID' 'V1)))

genID'_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V1) -> GenFunc (IDGenPrefix (TypeID' 'V1)) (IDGenReq (TypeID' 'V1) (m (TypeID' 'V1)))

genIDs_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V1) -> GenFunc (IDGenPrefix (TypeID' 'V1)) (IDGenReq (TypeID' 'V1) (Word16 -> m [TypeID' 'V1]))

decorate_ :: Proxy (TypeID' 'V1) -> GenFunc (IDGenPrefix (TypeID' 'V1)) (UUID -> ResWithErr (IDGenPrefix (TypeID' 'V1)) (TypeID' 'V1))

checkID_ :: Proxy (TypeID' 'V1) -> TypeID' 'V1 -> Maybe TypeIDError

checkIDWithEnv_ :: MonadIO m => Proxy (TypeID' 'V1) -> TypeID' 'V1 -> m (Maybe TypeIDError)

IDGen (TypeID' 'V4)

Generate TypeID' 'V4s.

Defined in Data.TypeID.Internal

Associated Types

type IDGenPrefix (TypeID' 'V4) :: Maybe Type

type IDGenReq (TypeID' 'V4) r

Methods

genID_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V4) -> GenFunc (IDGenPrefix (TypeID' 'V4)) (IDGenReq (TypeID' 'V4) (m (TypeID' 'V4)))

genID'_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V4) -> GenFunc (IDGenPrefix (TypeID' 'V4)) (IDGenReq (TypeID' 'V4) (m (TypeID' 'V4)))

genIDs_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V4) -> GenFunc (IDGenPrefix (TypeID' 'V4)) (IDGenReq (TypeID' 'V4) (Word16 -> m [TypeID' 'V4]))

decorate_ :: Proxy (TypeID' 'V4) -> GenFunc (IDGenPrefix (TypeID' 'V4)) (UUID -> ResWithErr (IDGenPrefix (TypeID' 'V4)) (TypeID' 'V4))

checkID_ :: Proxy (TypeID' 'V4) -> TypeID' 'V4 -> Maybe TypeIDError

checkIDWithEnv_ :: MonadIO m => Proxy (TypeID' 'V4) -> TypeID' 'V4 -> m (Maybe TypeIDError)

IDGen (TypeID' 'V5)

Generate TypeID' 'V5s.

Defined in Data.TypeID.Internal

Associated Types

type IDGenPrefix (TypeID' 'V5) :: Maybe Type

type IDGenReq (TypeID' 'V5) r

Methods

genID_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V5) -> GenFunc (IDGenPrefix (TypeID' 'V5)) (IDGenReq (TypeID' 'V5) (m (TypeID' 'V5)))

genID'_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V5) -> GenFunc (IDGenPrefix (TypeID' 'V5)) (IDGenReq (TypeID' 'V5) (m (TypeID' 'V5)))

genIDs_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V5) -> GenFunc (IDGenPrefix (TypeID' 'V5)) (IDGenReq (TypeID' 'V5) (Word16 -> m [TypeID' 'V5]))

decorate_ :: Proxy (TypeID' 'V5) -> GenFunc (IDGenPrefix (TypeID' 'V5)) (UUID -> ResWithErr (IDGenPrefix (TypeID' 'V5)) (TypeID' 'V5))

checkID_ :: Proxy (TypeID' 'V5) -> TypeID' 'V5 -> Maybe TypeIDError

checkIDWithEnv_ :: MonadIO m => Proxy (TypeID' 'V5) -> TypeID' 'V5 -> m (Maybe TypeIDError)

IDGen (TypeID' 'V7)

Generate TypeIDs.

Defined in Data.TypeID.Internal

Associated Types

type IDGenPrefix (TypeID' 'V7) :: Maybe Type

type IDGenReq (TypeID' 'V7) r

Methods

genID_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V7) -> GenFunc (IDGenPrefix (TypeID' 'V7)) (IDGenReq (TypeID' 'V7) (m (TypeID' 'V7)))

genID'_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V7) -> GenFunc (IDGenPrefix (TypeID' 'V7)) (IDGenReq (TypeID' 'V7) (m (TypeID' 'V7)))

genIDs_ :: forall (m :: Type -> Type). MonadIO m => Proxy (TypeID' 'V7) -> GenFunc (IDGenPrefix (TypeID' 'V7)) (IDGenReq (TypeID' 'V7) (Word16 -> m [TypeID' 'V7]))

decorate_ :: Proxy (TypeID' 'V7) -> GenFunc (IDGenPrefix (TypeID' 'V7)) (UUID -> ResWithErr (IDGenPrefix (TypeID' 'V7)) (TypeID' 'V7))

checkID_ :: Proxy (TypeID' 'V7) -> TypeID' 'V7 -> Maybe TypeIDError

checkIDWithEnv_ :: MonadIO m => Proxy (TypeID' 'V7) -> TypeID' 'V7 -> m (Maybe TypeIDError)

(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) => IDGen (KindID' 'V1 prefix)

Generate KindID' 'V1s.

Defined in Data.KindID.Internal

Associated Types

type IDGenPrefix (KindID' 'V1 prefix) :: Maybe Type

type IDGenReq (KindID' 'V1 prefix) r

Methods

genID_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V1 prefix) -> GenFunc (IDGenPrefix (KindID' 'V1 prefix)) (IDGenReq (KindID' 'V1 prefix) (m (KindID' 'V1 prefix)))

genID'_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V1 prefix) -> GenFunc (IDGenPrefix (KindID' 'V1 prefix)) (IDGenReq (KindID' 'V1 prefix) (m (KindID' 'V1 prefix)))

genIDs_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V1 prefix) -> GenFunc (IDGenPrefix (KindID' 'V1 prefix)) (IDGenReq (KindID' 'V1 prefix) (Word16 -> m [KindID' 'V1 prefix]))

decorate_ :: Proxy (KindID' 'V1 prefix) -> GenFunc (IDGenPrefix (KindID' 'V1 prefix)) (UUID -> ResWithErr (IDGenPrefix (KindID' 'V1 prefix)) (KindID' 'V1 prefix))

checkID_ :: Proxy (KindID' 'V1 prefix) -> KindID' 'V1 prefix -> Maybe TypeIDError

checkIDWithEnv_ :: MonadIO m => Proxy (KindID' 'V1 prefix) -> KindID' 'V1 prefix -> m (Maybe TypeIDError)

(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) => IDGen (KindID' 'V4 prefix)

Generate KindID' 'V4s.

Defined in Data.KindID.Internal

Associated Types

type IDGenPrefix (KindID' 'V4 prefix) :: Maybe Type

type IDGenReq (KindID' 'V4 prefix) r

Methods

genID_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V4 prefix) -> GenFunc (IDGenPrefix (KindID' 'V4 prefix)) (IDGenReq (KindID' 'V4 prefix) (m (KindID' 'V4 prefix)))

genID'_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V4 prefix) -> GenFunc (IDGenPrefix (KindID' 'V4 prefix)) (IDGenReq (KindID' 'V4 prefix) (m (KindID' 'V4 prefix)))

genIDs_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V4 prefix) -> GenFunc (IDGenPrefix (KindID' 'V4 prefix)) (IDGenReq (KindID' 'V4 prefix) (Word16 -> m [KindID' 'V4 prefix]))

decorate_ :: Proxy (KindID' 'V4 prefix) -> GenFunc (IDGenPrefix (KindID' 'V4 prefix)) (UUID -> ResWithErr (IDGenPrefix (KindID' 'V4 prefix)) (KindID' 'V4 prefix))

checkID_ :: Proxy (KindID' 'V4 prefix) -> KindID' 'V4 prefix -> Maybe TypeIDError

checkIDWithEnv_ :: MonadIO m => Proxy (KindID' 'V4 prefix) -> KindID' 'V4 prefix -> m (Maybe TypeIDError)

(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) => IDGen (KindID' 'V5 prefix)

Generate KindID' 'V5s.

Defined in Data.KindID.Internal

Associated Types

type IDGenPrefix (KindID' 'V5 prefix) :: Maybe Type

type IDGenReq (KindID' 'V5 prefix) r

Methods

genID_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V5 prefix) -> GenFunc (IDGenPrefix (KindID' 'V5 prefix)) (IDGenReq (KindID' 'V5 prefix) (m (KindID' 'V5 prefix)))

genID'_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V5 prefix) -> GenFunc (IDGenPrefix (KindID' 'V5 prefix)) (IDGenReq (KindID' 'V5 prefix) (m (KindID' 'V5 prefix)))

genIDs_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V5 prefix) -> GenFunc (IDGenPrefix (KindID' 'V5 prefix)) (IDGenReq (KindID' 'V5 prefix) (Word16 -> m [KindID' 'V5 prefix]))

decorate_ :: Proxy (KindID' 'V5 prefix) -> GenFunc (IDGenPrefix (KindID' 'V5 prefix)) (UUID -> ResWithErr (IDGenPrefix (KindID' 'V5 prefix)) (KindID' 'V5 prefix))

checkID_ :: Proxy (KindID' 'V5 prefix) -> KindID' 'V5 prefix -> Maybe TypeIDError

checkIDWithEnv_ :: MonadIO m => Proxy (KindID' 'V5 prefix) -> KindID' 'V5 prefix -> m (Maybe TypeIDError)

(ToPrefix prefix, ValidPrefix (PrefixSymbol prefix)) => IDGen (KindID' 'V7 prefix)

Generate KindIDs.

Defined in Data.KindID.Internal

Associated Types

type IDGenPrefix (KindID' 'V7 prefix) :: Maybe Type

type IDGenReq (KindID' 'V7 prefix) r

Methods

genID_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V7 prefix) -> GenFunc (IDGenPrefix (KindID' 'V7 prefix)) (IDGenReq (KindID' 'V7 prefix) (m (KindID' 'V7 prefix)))

genID'_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V7 prefix) -> GenFunc (IDGenPrefix (KindID' 'V7 prefix)) (IDGenReq (KindID' 'V7 prefix) (m (KindID' 'V7 prefix)))

genIDs_ :: forall (m :: Type -> Type). MonadIO m => Proxy (KindID' 'V7 prefix) -> GenFunc (IDGenPrefix (KindID' 'V7 prefix)) (IDGenReq (KindID' 'V7 prefix) (Word16 -> m [KindID' 'V7 prefix]))

decorate_ :: Proxy (KindID' 'V7 prefix) -> GenFunc (IDGenPrefix (KindID' 'V7 prefix)) (UUID -> ResWithErr (IDGenPrefix (KindID' 'V7 prefix)) (KindID' 'V7 prefix))

checkID_ :: Proxy (KindID' 'V7 prefix) -> KindID' 'V7 prefix -> Maybe TypeIDError

checkIDWithEnv_ :: MonadIO m => Proxy (KindID' 'V7 prefix) -> KindID' 'V7 prefix -> m (Maybe TypeIDError)

decorate :: forall a. IDGen a => GenFunc (IDGenPrefix a) (UUID -> ResWithErr (IDGenPrefix a) a)

Generate a new identifier with the given prefix and UUID suffix.

genID :: forall a m. (IDGen a, MonadIO m) => GenFunc (IDGenPrefix a) (IDGenReq a (m a))

Generate a new identifier with the given prefix.

genID' :: forall a m. (IDGen a, MonadIO m) => GenFunc (IDGenPrefix a) (IDGenReq a (m a))

Similar to genID, but stateless. It can be a faster implementation than genID, but it does not guarantee any stateful property, such as monotonically increasing for UUIDv7-based identifiers.

The default implementation is the same as genID.

genIDs :: forall a m. (IDGen a, MonadIO m) => GenFunc (IDGenPrefix a) (IDGenReq a (Word16 -> m [a]))

Generate a list of identifiers with the given prefix.

checkID :: forall a. IDGen a => a -> Maybe TypeIDError

Check the validity of the identifier.

checkIDWithEnv :: forall a m. (IDGen a, MonadIO m) => a -> m (Maybe TypeIDError)

Check the validity of the identifier, potentially with impure criteria.

Helper types

type family GenFunc prefix res where ...

A function generator based on the IDGenPrefix type family.

Equations

GenFunc ('Just prefix) res = prefix -> res

GenFunc 'Nothing res = res

type family ResWithErr prefix res where ...

A result that may contain an error, based on the IDGenPrefix type family.

In other words, if the prefix type is already encoded in the type level, we are certain that the prefix is valid, so the result type does not need the Either TypeIDError part.

Equations

ResWithErr ('Just prefix) res = Either TypeIDError res

ResWithErr 'Nothing res = res