-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Library for IP and MAC addresses -- -- The ip package provides types and functions for dealing with -- IPv4 addresses, CIDR blocks, and MAC addresses. We provide instances -- for typeclasses found in commonly used packages like aeson, -- vector, and hashable. We also provide Parsers for -- working with attoparsec. -- -- Notably, this package does not overload functions by introducing any -- typeclasses of its own. Neither does it prefix functions with the name -- of the type that they work on. Instead, functions of the same name are -- exported by several different modules, and it is expected that end -- users disambiguate by importing these modules qualified. -- -- The only module intended to be imported unqualified is -- Net.Types. The types in this package should not conflict with -- the types in any other commonly used packages. -- -- The following packages are intended to be used with this package: -- -- @package ip @version 1.3.0 -- | An IPv4 data type -- -- This module provides the IPv4 data type and functions for working with -- it. There are also encoding and decoding functions provided in this -- module, but they should be imported from Net.IPv4.Text and -- Net.IPv4.ByteString.Char8 instead. They are defined here so -- that the FromJSON and ToJSON instances can use them. -- -- At some point, a highly efficient IPv4-to-ByteString function needs to -- be added to this module to take advantage of aeson's new -- toEncoding method. module Net.IPv4 -- | Create an IPv4 address from four octets. The first argument is -- the most significant octet. The last argument is the least -- significant. Since IP addresses are commonly written using dot-decimal -- notation, this is the recommended way to create an IP address. -- Additionally, it is used for the Show and Read instances -- of IPv4 to help keep things readable in GHCi. -- -- 
--   >>> let addr = ipv4 192 168 1 1
--   
--   >>> addr
--   ipv4 192 168 1 1
--   
--   >>> getIPv4 addr
--   3232235777
--
ipv4 :: Word8 -> Word8 -> Word8 -> Word8 -> IPv4 -- | An alias for the ipv4 smart constructor. fromOctets :: Word8 -> Word8 -> Word8 -> Word8 -> IPv4 -- | An uncurried variant of fromOctets. fromTupleOctets :: (Word8, Word8, Word8, Word8) -> IPv4 -- | Convert an IPv4 address into a quadruple of octets. The first -- element in the quadruple is the most significant octet. The last -- element is the least significant octet. toOctets :: IPv4 -> (Word8, Word8, Word8, Word8) -- | The IP address representing any host: 0.0.0.0 any :: IPv4 -- | The local loopback IP address: 127.0.0.1 loopback :: IPv4 -- | The broadcast IP address: 255.255.255.255 broadcast :: IPv4 -- | Checks to see if the IPv4 address belongs to a private network. -- The three private networks that are checked are 10.0.0.0/8, -- 172.16.0.0/12, and 192.168.0.0/16. private :: IPv4 -> Bool -- | Checks to see if the IPv4 address belongs to a reserved -- network. This includes the three private networks that private -- checks along with several other ranges that are not used on the public -- Internet. reserved :: IPv4 -> Bool -- | Checks to see if the IPv4 address is publicly routable. -- -- 
--   public x == not (reserved x)
--
public :: IPv4 -> Bool -- | Encode an IPv4 address to Text using dot-decimal -- notation: -- -- 
--   >>> T.putStrLn (encode (ipv4 192 168 2 47))
--   192.168.2.47
--
encode :: IPv4 -> Text -- | Decode an IPv4 address. decode :: Text -> Maybe IPv4 -- | Encode an IPv4 address to a text Builder. builder :: IPv4 -> Builder reader :: Reader IPv4 parser :: Parser IPv4 -- | Encode an IPv4 address to a UTF-8 encoded ByteString. encodeUtf8 :: IPv4 -> ByteString decodeUtf8 :: ByteString -> Maybe IPv4 builderUtf8 :: IPv4 -> Builder parserUtf8 :: Parser IPv4 encodeString :: IPv4 -> String decodeString :: String -> Maybe IPv4 print :: IPv4 -> IO () -- | A 32-bit Internet Protocol version 4 address. To use this with the -- network library, it is necessary to use -- Network.Socket.htonl to convert the underlying Word32 -- from host byte order to network byte order. newtype IPv4 IPv4 :: Word32 -> IPv4 [getIPv4] :: IPv4 -> Word32 instance Foreign.Storable.Storable Net.IPv4.IPv4 instance Data.Primitive.Types.Prim Net.IPv4.IPv4 instance GHC.Generics.Generic Net.IPv4.IPv4 instance Data.Hashable.Class.Hashable Net.IPv4.IPv4 instance GHC.Enum.Bounded Net.IPv4.IPv4 instance GHC.Enum.Enum Net.IPv4.IPv4 instance GHC.Classes.Ord Net.IPv4.IPv4 instance GHC.Classes.Eq Net.IPv4.IPv4 instance GHC.Show.Show Net.IPv4.IPv4 instance GHC.Read.Read Net.IPv4.IPv4 instance Data.Vector.Unboxed.Base.Unbox Net.IPv4.IPv4 instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector Net.IPv4.IPv4 instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector Net.IPv4.IPv4 instance Data.Aeson.Types.ToJSON.ToJSON Net.IPv4.IPv4 instance Data.Aeson.Types.FromJSON.FromJSON Net.IPv4.IPv4 instance Data.Aeson.Types.ToJSON.ToJSONKey Net.IPv4.IPv4 instance Data.Aeson.Types.FromJSON.FromJSONKey Net.IPv4.IPv4 instance Data.Bits.Bits Net.IPv4.IPv4 instance Data.Bits.FiniteBits Net.IPv4.IPv4 module Net.IPv4.Range -- | Smart constructor for IPv4Range. Ensures the mask is -- appropriately sized and sets masked bits in the IPv4 to zero. range :: IPv4 -> Word8 -> IPv4Range -- | Given an inclusive lower and upper ip address, create the smallest -- IPv4Range that contains the two. This is helpful in situations -- where input given as a range like 192.168.16.0-192.168.19.255 -- needs to be handled. This makes the range broader if it cannot be -- represented in CIDR notation. -- -- 
--   >>> print $ fromBounds (fromOctets 192 168 16 0) (fromOctets 192 168 19 255)
--   192.168.16.0/22
--   
--   >>> print $ fromBounds (fromOctets 10 0 5 7) (fromOctets 10 0 5 14)
--   10.0.5.0/28
--
fromBounds :: IPv4 -> IPv4 -> IPv4Range -- | Normalize an IPv4Range. The first result of this is that the -- IPv4 inside the IPv4Range is changed so that the -- insignificant bits are zeroed out. For example: -- -- 
--   >>> print $ normalize $ IPv4Range (fromOctets 192 168 1 19) 24
--   192.168.1.0/24
--   
--   >>> print $ normalize $ IPv4Range (fromOctets 192 168 1 163) 28
--   192.168.1.160/28
--
-- -- The second effect of this is that the mask length is lowered to be 32 -- or smaller. Working with IPv4Ranges that have not been -- normalized does not cause any issues for this library, although other -- applications may reject such ranges (especially those with a mask -- length above 32). -- -- Note that normalize is idempotent, that is: -- -- 
--   normalize r == (normalize . normalize) r
--
normalize :: IPv4Range -> IPv4Range -- | Checks to see if an IPv4 address belongs in the -- IPv4Range. -- -- 
--   >>> let ip = fromOctets 10 10 1 92
--   
--   >>> contains (IPv4Range (fromOctets 10 0 0 0) 8) ip
--   True
--   
--   >>> contains (IPv4Range (fromOctets 10 11 0 0) 16) ip
--   False
--
-- -- Typically, element-testing functions are written to take the element -- as the first argument and the set as the second argument. This is -- intentionally written the other way for better performance when -- iterating over a collection. For example, you might test elements in a -- list for membership like this: -- -- 
--   >>> let r = IPv4Range (fromOctets 10 10 10 6) 31
--   
--   >>> mapM_ (P.print . contains r) (take 5 $ iterate succ $ fromOctets 10 10 10 5)
--   False
--   True
--   True
--   False
--   False
--
-- -- The implementation of contains ensures that (with GHC), the -- bitmask creation and range normalization only occur once in the above -- example. They are reused as the list is iterated. contains :: IPv4Range -> IPv4 -> Bool -- | This is provided to mirror the interface provided by -- Data.Set. It behaves just like contains but with -- flipped arguments. -- -- 
--   member ip r == contains r ip
--
member :: IPv4 -> IPv4Range -> Bool -- | The inclusive lower bound of an IPv4Range. This is -- conventionally understood to be the broadcast address of a subnet. For -- example: -- -- 
--   >>> T.putStrLn $ I.encode $ lowerInclusive $ IPv4Range (ipv4 10 10 1 160) 25
--   10.10.1.128
--
-- -- Note that the lower bound of a normalized IPv4Range is simply -- the ip address of the range: -- -- 
--   lowerInclusive r == ipv4RangeBase (normalize r)
--
lowerInclusive :: IPv4Range -> IPv4 upperInclusive :: IPv4Range -> IPv4 -- | Convert an IPv4Range into a list of the IPv4 addresses -- that are in it. >>> let r = IPv4Range (fromOctets 192 168 1 -- 8) 30 >>> mapM_ (T.putStrLn . I.encode) (toList r) -- 192.168.1.8 192.168.1.9 192.168.1.10 192.168.1.11 toList :: IPv4Range -> [IPv4] toGenerator :: MonadPlus m => IPv4Range -> m IPv4 -- | The RFC1918 24-bit block. Subnet mask: 10.0.0.0/8 private24 :: IPv4Range -- | The RFC1918 20-bit block. Subnet mask: 172.16.0.0/12 private20 :: IPv4Range -- | The RFC1918 16-bit block. Subnet mask: 192.168.0.0/16 private16 :: IPv4Range encode :: IPv4Range -> Text decode :: Text -> Maybe IPv4Range builder :: IPv4Range -> Builder parser :: Parser IPv4Range -- | This exists mostly for testing purposes. print :: IPv4Range -> IO () -- | The length should be between 0 and 32. These bounds are inclusive. -- This expectation is not in any way enforced by this library because it -- does not cause errors. A mask length greater than 32 will be treated -- as if it were 32. data IPv4Range IPv4Range :: {-# UNPACK #-} !IPv4 -> {-# UNPACK #-} !Word8 -> IPv4Range [ipv4RangeBase] :: IPv4Range -> {-# UNPACK #-} !IPv4 [ipv4RangeLength] :: IPv4Range -> {-# UNPACK #-} !Word8 instance GHC.Generics.Generic Net.IPv4.Range.IPv4Range instance GHC.Read.Read Net.IPv4.Range.IPv4Range instance GHC.Show.Show Net.IPv4.Range.IPv4Range instance GHC.Classes.Ord Net.IPv4.Range.IPv4Range instance GHC.Classes.Eq Net.IPv4.Range.IPv4Range instance Data.Hashable.Class.Hashable Net.IPv4.Range.IPv4Range instance Data.Aeson.Types.ToJSON.ToJSON Net.IPv4.Range.IPv4Range instance Data.Aeson.Types.FromJSON.FromJSON Net.IPv4.Range.IPv4Range instance Data.Vector.Unboxed.Base.Unbox Net.IPv4.Range.IPv4Range instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector Net.IPv4.Range.IPv4Range instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector Net.IPv4.Range.IPv4Range instance Data.Bits.Bits Net.IPv4.Range.IPv4Range instance Data.Bits.FiniteBits Net.IPv4.Range.IPv4Range module Net.IPv6 -- | A 128-bit Internet Protocol version 6 address. data IPv6 IPv6 :: {-# UNPACK #-} !Word64 -> {-# UNPACK #-} !Word64 -> IPv6 [ipv6A] :: IPv6 -> {-# UNPACK #-} !Word64 [ipv6B] :: IPv6 -> {-# UNPACK #-} !Word64 -- | Create an IPv6 address from the eight 16-bit fragments that -- make it up. This closely resembles the standard IPv6 notation, so is -- used for the Show instance. Note that this lacks the formatting -- feature for suppress zeroes in an IPv6 address, but it should -- be readable enough for hacking in GHCi. -- -- 
--   >>> let addr = ipv6 0x3124 0x0 0x0 0xDEAD 0xCAFE 0xFF 0xFE00 0x1
--   
--   >>> addr
--   ipv6 0x3124 0x0000 0x0000 0xdead 0xcafe 0x00ff 0xfe00 0x0001
--   
--   >>> T.putStrLn (encode addr)
--   3124::dead:cafe:ff:fe00:1
--
ipv6 :: Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> IPv6 fromOctets :: Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> IPv6 -- | An alias for the ipv6 smart constructor. fromWord16s :: Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> IPv6 -- | Build an IPv6 from four 32-bit words. The leftmost argument is -- the high word and the rightword is the low word. fromWord32s :: Word32 -> Word32 -> Word32 -> Word32 -> IPv6 -- | Uncurried variant of fromWord16s. fromTupleWord16s :: (Word16, Word16, Word16, Word16, Word16, Word16, Word16, Word16) -> IPv6 -- | Uncurried variant of fromWord32s. fromTupleWord32s :: (Word32, Word32, Word32, Word32) -> IPv6 -- | Convert an IPv6 to eight 16-bit words. toWord16s :: IPv6 -> (Word16, Word16, Word16, Word16, Word16, Word16, Word16, Word16) -- | Convert an IPv6 to four 32-bit words. toWord32s :: IPv6 -> (Word32, Word32, Word32, Word32) any :: IPv6 loopback :: IPv6 -- | Encodes the IP, using zero-compression on the leftmost-longest string -- of zeroes in the address. Per RFC 5952 Section 5, this uses -- mixed notation when encoding an IPv4-mapped IPv6 address: -- -- 
--   >>> T.putStrLn $ encode $ fromWord16s 0xDEAD 0xBEEF 0x0 0x0 0x0 0x0 0x0 0x1234
--   dead:beef::1234
--   
--   >>> T.putStrLn $ encode $ fromWord16s 0x0 0x0 0x0 0x0 0x0 0xFFFF 0x6437 0xA5B4
--   ::ffff:100.55.165.180
--   
--   >>> T.putStrLn $ encode $ fromWord16s 0x0 0x0 0x0 0x0 0x0 0x0 0x0 0x0
--   ::
--
encode :: IPv6 -> Text -- | Decode an IPv6 address. This accepts both standard IPv6 notation (with -- zero compression) and mixed notation for IPv4-mapped IPv6 addresses. decode :: Text -> Maybe IPv6 parser :: Parser IPv6 print :: IPv6 -> IO () instance GHC.Classes.Ord Net.IPv6.IPv6 instance GHC.Classes.Eq Net.IPv6.IPv6 instance GHC.Show.Show Net.IPv6.IPv6 instance Data.Primitive.Types.Prim Net.IPv6.IPv6 instance GHC.Read.Read Net.IPv6.IPv6 instance Data.Aeson.Types.ToJSON.ToJSON Net.IPv6.IPv6 instance Data.Aeson.Types.FromJSON.FromJSON Net.IPv6.IPv6 -- | An IP data type representing either an IPv4 address or an IPv6 -- address. The user can think of this as though it were a sum type. -- However, to minimize indirections, it is actually implemented as an -- IPv6 address, with IPv4 addresses being represented as -- an IPv4-mapped IPv6 addresses: -- -- 
--   +---------+---------+--------------+
--   | 80 bits | 16 bits | 32 bits      |
--   +---------+---------+--------------+
--   | 00...00 | FFFF    | IPv4 address |
--   +---------+---------+--------------+
--
-- -- All functions and instance methods that deal with textual conversion -- will encode an IP using either dot-decimal notation (for IPv4) -- or RFC 5952 (for IPv6). They will decode an IP from either -- format as well. The Show instance presents an address in as -- valid haskell code that resembles the formatted address: -- -- 
--   >>> decode "192.168.3.100"
--   Just (ipv4 192 168 3 100)
--   
--   >>> decode "A3F5:12:F26::1466:8B91"
--   Just (ipv6 0xa3f5 0x0012 0x0f26 0x0000 0x0000 0x0000 0x1466 0x8b91)
--
module Net.IP case_ :: (IPv4 -> a) -> (IPv6 -> a) -> IP -> a -- | Construct an IP address from the four octets of an IPv4 -- address. ipv4 :: Word8 -> Word8 -> Word8 -> Word8 -> IP -- | Construct an IP address from the eight 16-bit chunks of an IPv6 -- address. ipv6 :: Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> Word16 -> IP fromIPv4 :: IPv4 -> IP fromIPv6 :: IPv6 -> IP encode :: IP -> Text decode :: Text -> Maybe IP print :: IP -> IO () -- | A 32-bit IPv4 address or a 128-bit IPv6 address. -- Internally, this is just represented as an IPv6 address. The -- functions provided in Net.IP help simulate constructing and -- pattern matching on values of this type. All functions and typeclass -- methods that convert IP values to text will display it as an -- IPv4 address if possible. newtype IP IP :: IPv6 -> IP [getIP] :: IP -> IPv6 instance GHC.Classes.Ord Net.IP.IP instance GHC.Classes.Eq Net.IP.IP instance GHC.Show.Show Net.IP.IP instance GHC.Read.Read Net.IP.IP instance Data.Aeson.Types.ToJSON.ToJSON Net.IP.IP instance Data.Aeson.Types.FromJSON.FromJSON Net.IP.IP module Net.Mac -- | Construct a Mac address from a Word64. Only the lower 48 -- bits are used. mac :: Word64 -> Mac -- | Create a Mac address from six octets. fromOctets :: Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Mac -- | Convert a Mac address to the six octets that make it up. This -- function and fromOctets are inverses: -- -- 
--   m == (let (a,b,c,d,e,f) = toOctets m in fromOctets a b c d e f)
--
toOctets :: Mac -> (Word8, Word8, Word8, Word8, Word8, Word8) -- | Encode a Mac address lowercase hex, separating every two -- characters with a colon: -- -- 
--   >>> T.putStrLn (encode (Mac 0xA47F247AB423))
--   a4:7f:24:7a:b4:23
--
encode :: Mac -> Text encodeWith :: MacCodec -> Mac -> Text decode :: Text -> Maybe Mac decodeWith :: MacCodec -> Text -> Maybe Mac builder :: Mac -> Builder parser :: Parser Mac parserWith :: MacCodec -> Parser Mac -- | Encode a Mac address, as lowercase hexadecimal digits separated -- by a colon: -- -- 
--   >>> BC.putStrLn (encodeUtf8 (mac 0x64255A0F2C47))
--   64:25:5a:0f:2c:47
--
encodeUtf8 :: Mac -> ByteString encodeWithUtf8 :: MacCodec -> Mac -> ByteString -- | Lenient decoding of MAC address that accepts lowercase, uppercase, and -- any kind separator. -- -- 
--   >>> decodeUtf8 "A2:DE:AD:BE:EF:67"
--   Just (mac 0xa2deadbeef67)
--   
--   >>> decodeUtf8 "13-a2-fe-a4-17-96"
--   Just (mac 0x13a2fea41796)
--   
--   >>> decodeUtf8 "0A42.47BA.67C2"
--   Just (mac 0x0a4247ba67c2)
--
decodeUtf8 :: ByteString -> Maybe Mac decodeWithUtf8 :: MacCodec -> ByteString -> Maybe Mac -- | Make a bytestring builder from a Mac address using a colon as -- the separator. builderUtf8 :: Mac -> Builder -- | Lenient parser for a Mac address using any character as the -- separator and accepting any digit grouping (i.e. -- FA:43:B2:C0:0F:99 or A065.647B.87FA). parserUtf8 :: Parser Mac -- | Parser for a Mac address using the provided settings. parserWithUtf8 :: MacCodec -> Parser Mac -- | Decode a Mac address from a ByteString. Each byte is -- interpreted as an octet of the Mac address. Consequently, -- ByteStrings of length 6 successfully decode, and all other -- ByteStrings fail to decode. -- -- 
--   >>> decodeBytes (B.pack [0x6B,0x47,0x18,0x90,0x55,0xC3])
--   Just (mac 0x6b47189055c3)
--   
--   >>> decodeBytes (B.replicate 6 0x3A)
--   Just (mac 0x3a3a3a3a3a3a)
--   
--   >>> decodeBytes (B.replicate 7 0x3A)
--   Nothing
--
decodeBytes :: ByteString -> Maybe Mac print :: Mac -> IO () -- | A 48-bit MAC address. Do not use the data constructor for this type. -- It is not considered part of the stable API, and it allows you to -- construct invalid MAC addresses. newtype Mac Mac :: Word64 -> Mac data MacCodec MacCodec :: !MacGrouping -> !Bool -> MacCodec [macCodecGrouping] :: MacCodec -> !MacGrouping [macCodecUpperCase] :: MacCodec -> !Bool -- | The format expected by the mac address parser. The Word8 taken -- by some of these constructors is the ascii value of the character to -- be used as the separator. This is typically a colon, a hyphen, or a -- space character. All decoding functions are case insensitive. data MacGrouping -- | Two-character groups, FA:2B:40:09:8C:11 MacGroupingPairs :: !Char -> MacGrouping -- | Three-character groups, 24B-F0A-025-829 MacGroupingTriples :: !Char -> MacGrouping -- | Four-character groups, A220.0745.CAC7 MacGroupingQuadruples :: !Char -> MacGrouping -- | No separator, 24AF4B5B0780 MacGroupingNoSeparator :: MacGrouping instance GHC.Generics.Generic Net.Mac.MacCodec instance GHC.Read.Read Net.Mac.MacCodec instance GHC.Show.Show Net.Mac.MacCodec instance GHC.Classes.Ord Net.Mac.MacCodec instance GHC.Classes.Eq Net.Mac.MacCodec instance GHC.Generics.Generic Net.Mac.MacGrouping instance GHC.Read.Read Net.Mac.MacGrouping instance GHC.Show.Show Net.Mac.MacGrouping instance GHC.Classes.Ord Net.Mac.MacGrouping instance GHC.Classes.Eq Net.Mac.MacGrouping instance GHC.Generics.Generic Net.Mac.Mac instance GHC.Classes.Ord Net.Mac.Mac instance GHC.Classes.Eq Net.Mac.Mac instance Data.Primitive.Types.Prim Net.Mac.Mac instance GHC.Show.Show Net.Mac.Mac instance GHC.Read.Read Net.Mac.Mac instance Data.Hashable.Class.Hashable Net.Mac.Mac instance Data.Aeson.Types.ToJSON.ToJSON Net.Mac.Mac instance Data.Aeson.Types.ToJSON.ToJSONKey Net.Mac.Mac instance Data.Aeson.Types.FromJSON.FromJSONKey Net.Mac.Mac instance Data.Aeson.Types.FromJSON.FromJSON Net.Mac.Mac module Net.Types -- | A 32-bit Internet Protocol version 4 address. To use this with the -- network library, it is necessary to use -- Network.Socket.htonl to convert the underlying Word32 -- from host byte order to network byte order. newtype IPv4 IPv4 :: Word32 -> IPv4 [getIPv4] :: IPv4 -> Word32 -- | A 128-bit Internet Protocol version 6 address. data IPv6 IPv6 :: {-# UNPACK #-} !Word64 -> {-# UNPACK #-} !Word64 -> IPv6 [ipv6A] :: IPv6 -> {-# UNPACK #-} !Word64 [ipv6B] :: IPv6 -> {-# UNPACK #-} !Word64 -- | A 32-bit IPv4 address or a 128-bit IPv6 address. -- Internally, this is just represented as an IPv6 address. The -- functions provided in Net.IP help simulate constructing and -- pattern matching on values of this type. All functions and typeclass -- methods that convert IP values to text will display it as an -- IPv4 address if possible. newtype IP IP :: IPv6 -> IP [getIP] :: IP -> IPv6 -- | The length should be between 0 and 32. These bounds are inclusive. -- This expectation is not in any way enforced by this library because it -- does not cause errors. A mask length greater than 32 will be treated -- as if it were 32. data IPv4Range IPv4Range :: {-# UNPACK #-} !IPv4 -> {-# UNPACK #-} !Word8 -> IPv4Range [ipv4RangeBase] :: IPv4Range -> {-# UNPACK #-} !IPv4 [ipv4RangeLength] :: IPv4Range -> {-# UNPACK #-} !Word8 -- | A 48-bit MAC address. Do not use the data constructor for this type. -- It is not considered part of the stable API, and it allows you to -- construct invalid MAC addresses. newtype Mac Mac :: Word64 -> Mac data MacCodec MacCodec :: !MacGrouping -> !Bool -> MacCodec [macCodecGrouping] :: MacCodec -> !MacGrouping [macCodecUpperCase] :: MacCodec -> !Bool -- | The format expected by the mac address parser. The Word8 taken -- by some of these constructors is the ascii value of the character to -- be used as the separator. This is typically a colon, a hyphen, or a -- space character. All decoding functions are case insensitive. data MacGrouping -- | Two-character groups, FA:2B:40:09:8C:11 MacGroupingPairs :: !Char -> MacGrouping -- | Three-character groups, 24B-F0A-025-829 MacGroupingTriples :: !Char -> MacGrouping -- | Four-character groups, A220.0745.CAC7 MacGroupingQuadruples :: !Char -> MacGrouping -- | No separator, 24AF4B5B0780 MacGroupingNoSeparator :: MacGrouping