uuid-types-1.0.4: Type definitions for Universally Unique Identifiers
Copyright(c) 2017-2018 Herbert Valerio Riedel
(c) 20082012 Antoine Latter
LicenseBSD-style
Maintainerhvr@gnu.org
Portabilityportable
Safe HaskellTrustworthy
LanguageHaskell2010

Data.UUID.Types

Description

This library is useful for comparing, parsing and printing Universally Unique Identifiers (UUID). See RFC 4122 for the specification.

Synopsis

The UUID Type

data UUID Source #

Type representing Universally Unique Identifiers (UUID) as specified in RFC 4122.

Instances

Instances details
Eq UUID Source # 
Instance details

Defined in Data.UUID.Types.Internal

Methods

(==) :: UUID -> UUID -> Bool #

(/=) :: UUID -> UUID -> Bool #

Data UUID Source # 
Instance details

Defined in Data.UUID.Types.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UUID -> c UUID #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UUID #

toConstr :: UUID -> Constr #

dataTypeOf :: UUID -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UUID) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UUID) #

gmapT :: (forall b. Data b => b -> b) -> UUID -> UUID #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UUID -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UUID -> r #

gmapQ :: (forall d. Data d => d -> u) -> UUID -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UUID -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UUID -> m UUID #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UUID -> m UUID #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UUID -> m UUID #

Ord UUID Source # 
Instance details

Defined in Data.UUID.Types.Internal

Methods

compare :: UUID -> UUID -> Ordering #

(<) :: UUID -> UUID -> Bool #

(<=) :: UUID -> UUID -> Bool #

(>) :: UUID -> UUID -> Bool #

(>=) :: UUID -> UUID -> Bool #

max :: UUID -> UUID -> UUID #

min :: UUID -> UUID -> UUID #

Read UUID Source # 
Instance details

Defined in Data.UUID.Types.Internal

Show UUID Source #

Pretty prints a UUID (without quotation marks). See also toString.

>>> show nil
"00000000-0000-0000-0000-000000000000"
Instance details

Defined in Data.UUID.Types.Internal

Methods

showsPrec :: Int -> UUID -> ShowS #

show :: UUID -> String #

showList :: [UUID] -> ShowS #

Storable UUID Source #

This Storable instance uses the memory layout as described in RFC 4122, but in contrast to the Binary instance, the fields are stored in host byte order.

Instance details

Defined in Data.UUID.Types.Internal

Methods

sizeOf :: UUID -> Int #

alignment :: UUID -> Int #

peekElemOff :: Ptr UUID -> Int -> IO UUID #

pokeElemOff :: Ptr UUID -> Int -> UUID -> IO () #

peekByteOff :: Ptr b -> Int -> IO UUID #

pokeByteOff :: Ptr b -> Int -> UUID -> IO () #

peek :: Ptr UUID -> IO UUID #

poke :: Ptr UUID -> UUID -> IO () #

Binary UUID Source #

This Binary instance is compatible with RFC 4122, storing the fields in network order as 16 bytes.

Instance details

Defined in Data.UUID.Types.Internal

Methods

put :: UUID -> Put #

get :: Get UUID #

putList :: [UUID] -> Put #

NFData UUID Source # 
Instance details

Defined in Data.UUID.Types.Internal

Methods

rnf :: UUID -> () #

Hashable UUID Source # 
Instance details

Defined in Data.UUID.Types.Internal

Methods

hashWithSalt :: Int -> UUID -> Int #

hash :: UUID -> Int #

Random UUID Source #

This Random instance produces insecure version 4 UUIDs as specified in RFC 4122.

Instance details

Defined in Data.UUID.Types.Internal

Methods

randomR :: RandomGen g => (UUID, UUID) -> g -> (UUID, g) #

random :: RandomGen g => g -> (UUID, g) #

randomRs :: RandomGen g => (UUID, UUID) -> g -> [UUID] #

randoms :: RandomGen g => g -> [UUID] #

Uniform UUID Source # 
Instance details

Defined in Data.UUID.Types.Internal

Methods

uniformM :: StatefulGen g m => g -> m UUID #

Nil UUID

nil :: UUID Source #

The nil UUID, as defined in RFC 4122. It is a UUID of all zeros. null u iff u == nil.

null :: UUID -> Bool Source #

Returns true if the passed-in UUID is the nil UUID.

Textual Representation

toString :: UUID -> String Source #

Convert a UUID into a hypenated string using lower-case letters. Example:

>>> toString <$> fromString "550e8400-e29b-41d4-a716-446655440000"
Just "550e8400-e29b-41d4-a716-446655440000"

fromString :: String -> Maybe UUID Source #

If the passed in String can be parsed as a UUID, it will be. The hyphens may not be omitted. Example:

>>> fromString "c2cc10e1-57d6-4b6f-9899-38d972112d8c"
Just c2cc10e1-57d6-4b6f-9899-38d972112d8c

Hex digits may be upper or lower-case.

toText :: UUID -> Text Source #

Convert a UUID into a hyphentated string using lower-case letters.

fromText :: Text -> Maybe UUID Source #

If the passed in Text can be parsed as an ASCII representation of a UUID, it will be. The hyphens may not be omitted.

toASCIIBytes :: UUID -> ByteString Source #

Convert a UUID into a hyphentated string using lower-case letters, packed as ASCII bytes into ByteString.

This should be equivalent to toString with pack.

fromASCIIBytes :: ByteString -> Maybe UUID Source #

If the passed in ByteString can be parsed as an ASCII representation of a UUID, it will be. The hyphens may not be omitted.

This should be equivalent to fromString with unpack.

toLazyASCIIBytes :: UUID -> ByteString Source #

Similar to toASCIIBytes except we produce a lazy ByteString.

fromLazyASCIIBytes :: ByteString -> Maybe UUID Source #

Similar to fromASCIIBytes except parses from a lazy ByteString.

Binary Representation

toByteString :: UUID -> ByteString Source #

Encode a UUID into a ByteString in network order.

This uses the same encoding as the Binary instance.

fromByteString :: ByteString -> Maybe UUID Source #

Extract a UUID from a ByteString in network byte order. The argument must be 16 bytes long, otherwise Nothing is returned.

Integer Representation

toWords :: UUID -> (Word32, Word32, Word32, Word32) Source #

Convert a UUID into a sequence of Word32 values. Useful for when you need to serialize a UUID and neither Storable nor Binary are appropriate.

>>> toWords <$> fromString "550e8400-e29b-41d4-a716-446655440000"
Just (1427014656,3801825748,2803254374,1430519808)

See also toWords64.

Since: uuid-1.2.2

Since: 1.0.0

fromWords :: Word32 -> Word32 -> Word32 -> Word32 -> UUID Source #

Create a UUID from a sequence of Word32. The inverse of toWords. Useful when you need a total function for constructing UUID values.

See also fromWords64.

Since: uuid-1.2.2

Since: 1.0.0

toWords64 :: UUID -> (Word64, Word64) Source #

Convert a UUID into a pair of Word64s.

>>> toWords64 <$> fromString "550e8400-e29b-41d4-a716-446655440000"
Just (6128981282234515924,12039885860129472512)

See also toWords.

Since: 1.0.4

fromWords64 :: Word64 -> Word64 -> UUID Source #

Create a UUID from a pair of Word64s.

Inverse of toWords64. See also fromWords.

Since: 1.0.4