Copyright	(c) 2017-2018 Herbert Valerio Riedel (c) 20082012 Antoine Latter
License	BSD-style
Maintainer	hvr@gnu.org
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell2010

Data.UUID.Types

Contents

The UUID Type
Nil UUID
Textual Representation
Binary Representation
Integer Representation

Description

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

Synopsis

data UUID
nil :: UUID
null :: UUID -> Bool
toString :: UUID -> String
fromString :: String -> Maybe UUID
toText :: UUID -> Text
fromText :: Text -> Maybe UUID
toASCIIBytes :: UUID -> ByteString
fromASCIIBytes :: ByteString -> Maybe UUID
toLazyASCIIBytes :: UUID -> ByteString
fromLazyASCIIBytes :: ByteString -> Maybe UUID
toByteString :: UUID -> ByteString
fromByteString :: ByteString -> Maybe UUID
toWords :: UUID -> (Word32, Word32, Word32, Word32)
fromWords :: Word32 -> Word32 -> Word32 -> Word32 -> UUID
toWords64 :: UUID -> (Word64, Word64)
fromWords64 :: Word64 -> Word64 -> UUID

The `UUID` Type

data UUID #

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

Instances

Instances details

Eq UUID #
Instance details Defined in Data.UUID.Types.Internal Methods (==) :: UUID -> UUID -> Bool # (/=) :: UUID -> UUID -> Bool #
Data UUID #
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 #
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 #
Instance details Defined in Data.UUID.Types.Internal Methods readsPrec :: Int -> ReadS UUID # readList :: ReadS [UUID] # readPrec :: ReadPrec UUID # readListPrec :: ReadPrec [UUID] #
Show UUID #	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 #	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 #	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 #
Instance details Defined in Data.UUID.Types.Internal Methods rnf :: UUID -> () #
Hashable UUID #
Instance details Defined in Data.UUID.Types.Internal Methods hashWithSalt :: Int -> UUID -> Int # hash :: UUID -> Int #
Random UUID #	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 #
Instance details Defined in Data.UUID.Types.Internal Methods uniformM :: StatefulGen g m => g -> m UUID #
Lift UUID #
Instance details Defined in Data.UUID.Types.Internal Methods lift :: UUID -> Q Exp # liftTyped :: UUID -> Q (TExp UUID) #

Nil UUID

nil :: UUID #

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

null :: UUID -> Bool #

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

Textual Representation

toString :: UUID -> String #

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 #

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 #

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

fromText :: Text -> Maybe UUID #

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 #

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 #

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 #

Similar to toASCIIBytes except we produce a lazy ByteString.

fromLazyASCIIBytes :: ByteString -> Maybe UUID #

Similar to fromASCIIBytes except parses from a lazy ByteString.

Binary Representation

toByteString :: UUID -> ByteString #

Encode a UUID into a ByteString in network order.

This uses the same encoding as the Binary instance.

fromByteString :: ByteString -> Maybe UUID #

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) #

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)