Documentation

Methods

showsPrec :: Int -> Header -> ShowS #

show :: Header -> String #

showList :: [Header] -> ShowS #

Methods

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

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

Methods

showsPrec :: Int -> Packet -> ShowS #

show :: Packet -> String #

showList :: [Packet] -> ShowS #

Methods

put :: Packet -> Put #

get :: Get Packet #

putList :: [Packet] -> Put #

Methods

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

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

Methods

succ :: PacketType -> PacketType #

pred :: PacketType -> PacketType #

toEnum :: Int -> PacketType #

fromEnum :: PacketType -> Int #

enumFrom :: PacketType -> [PacketType] #

enumFromThen :: PacketType -> PacketType -> [PacketType] #

enumFromTo :: PacketType -> PacketType -> [PacketType] #

enumFromThenTo :: PacketType -> PacketType -> PacketType -> [PacketType] #

Methods

showsPrec :: Int -> PacketType -> ShowS #

show :: PacketType -> String #

showList :: [PacketType] -> ShowS #

Methods

put :: PacketType -> Put #

get :: Get PacketType #

putList :: [PacketType] -> Put #

Methods

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

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

Methods

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

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

toConstr :: PacketAttribute -> Constr #

dataTypeOf :: PacketAttribute -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

showsPrec :: Int -> PacketAttribute -> ShowS #

show :: PacketAttribute -> String #

showList :: [PacketAttribute] -> ShowS #

Methods

put :: PacketAttribute -> Put #

get :: Get PacketAttribute #

putList :: [PacketAttribute] -> Put #

Methods

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

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

Methods

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

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

toConstr :: StatusType -> Constr #

dataTypeOf :: StatusType -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: StatusType -> StatusType #

pred :: StatusType -> StatusType #

toEnum :: Int -> StatusType #

fromEnum :: StatusType -> Int #

enumFrom :: StatusType -> [StatusType] #

enumFromThen :: StatusType -> StatusType -> [StatusType] #

enumFromTo :: StatusType -> StatusType -> [StatusType] #

enumFromThenTo :: StatusType -> StatusType -> StatusType -> [StatusType] #

Methods

showsPrec :: Int -> StatusType -> ShowS #

show :: StatusType -> String #

showList :: [StatusType] -> ShowS #

Methods

put :: StatusType -> Put #

get :: Get StatusType #

putList :: [StatusType] -> Put #

Methods

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

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

Methods

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

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

toConstr :: Authentic -> Constr #

dataTypeOf :: Authentic -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: Authentic -> Authentic #

pred :: Authentic -> Authentic #

toEnum :: Int -> Authentic #

fromEnum :: Authentic -> Int #

enumFrom :: Authentic -> [Authentic] #

enumFromThen :: Authentic -> Authentic -> [Authentic] #

enumFromTo :: Authentic -> Authentic -> [Authentic] #

enumFromThenTo :: Authentic -> Authentic -> Authentic -> [Authentic] #

Methods

showsPrec :: Int -> Authentic -> ShowS #

show :: Authentic -> String #

showList :: [Authentic] -> ShowS #

Methods

put :: Authentic -> Put #

get :: Get Authentic #

putList :: [Authentic] -> Put #

Methods

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

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

Methods

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

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

toConstr :: TerminateCause -> Constr #

dataTypeOf :: TerminateCause -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: TerminateCause -> TerminateCause #

pred :: TerminateCause -> TerminateCause #

toEnum :: Int -> TerminateCause #

fromEnum :: TerminateCause -> Int #

enumFrom :: TerminateCause -> [TerminateCause] #

enumFromThen :: TerminateCause -> TerminateCause -> [TerminateCause] #

enumFromTo :: TerminateCause -> TerminateCause -> [TerminateCause] #

enumFromThenTo :: TerminateCause -> TerminateCause -> TerminateCause -> [TerminateCause] #

Methods

showsPrec :: Int -> TerminateCause -> ShowS #

show :: TerminateCause -> String #

showList :: [TerminateCause] -> ShowS #

Methods

put :: TerminateCause -> Put #

get :: Get TerminateCause #

putList :: [TerminateCause] -> Put #

Methods

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

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

Methods

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

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

toConstr :: ServiceType -> Constr #

dataTypeOf :: ServiceType -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: ServiceType -> ServiceType #

pred :: ServiceType -> ServiceType #

toEnum :: Int -> ServiceType #

fromEnum :: ServiceType -> Int #

enumFrom :: ServiceType -> [ServiceType] #

enumFromThen :: ServiceType -> ServiceType -> [ServiceType] #

enumFromTo :: ServiceType -> ServiceType -> [ServiceType] #

enumFromThenTo :: ServiceType -> ServiceType -> ServiceType -> [ServiceType] #

Methods

showsPrec :: Int -> ServiceType -> ShowS #

show :: ServiceType -> String #

showList :: [ServiceType] -> ShowS #

Methods

put :: ServiceType -> Put #

get :: Get ServiceType #

putList :: [ServiceType] -> Put #

Methods

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

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

Methods

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

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

toConstr :: FramedProtocol -> Constr #

dataTypeOf :: FramedProtocol -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: FramedProtocol -> FramedProtocol #

pred :: FramedProtocol -> FramedProtocol #

toEnum :: Int -> FramedProtocol #

fromEnum :: FramedProtocol -> Int #

enumFrom :: FramedProtocol -> [FramedProtocol] #

enumFromThen :: FramedProtocol -> FramedProtocol -> [FramedProtocol] #

enumFromTo :: FramedProtocol -> FramedProtocol -> [FramedProtocol] #

enumFromThenTo :: FramedProtocol -> FramedProtocol -> FramedProtocol -> [FramedProtocol] #

Methods

showsPrec :: Int -> FramedProtocol -> ShowS #

show :: FramedProtocol -> String #

showList :: [FramedProtocol] -> ShowS #

Methods

put :: FramedProtocol -> Put #

get :: Get FramedProtocol #

putList :: [FramedProtocol] -> Put #

Methods

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

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

Methods

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

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

toConstr :: FramedRouting -> Constr #

dataTypeOf :: FramedRouting -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: FramedRouting -> FramedRouting #

pred :: FramedRouting -> FramedRouting #

toEnum :: Int -> FramedRouting #

fromEnum :: FramedRouting -> Int #

enumFrom :: FramedRouting -> [FramedRouting] #

enumFromThen :: FramedRouting -> FramedRouting -> [FramedRouting] #

enumFromTo :: FramedRouting -> FramedRouting -> [FramedRouting] #

enumFromThenTo :: FramedRouting -> FramedRouting -> FramedRouting -> [FramedRouting] #

Methods

showsPrec :: Int -> FramedRouting -> ShowS #

show :: FramedRouting -> String #

showList :: [FramedRouting] -> ShowS #

Methods

put :: FramedRouting -> Put #

get :: Get FramedRouting #

putList :: [FramedRouting] -> Put #

Methods

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

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

Methods

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

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

toConstr :: FramedCompression -> Constr #

dataTypeOf :: FramedCompression -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: FramedCompression -> FramedCompression #

pred :: FramedCompression -> FramedCompression #

toEnum :: Int -> FramedCompression #

fromEnum :: FramedCompression -> Int #

enumFrom :: FramedCompression -> [FramedCompression] #

enumFromThen :: FramedCompression -> FramedCompression -> [FramedCompression] #

enumFromTo :: FramedCompression -> FramedCompression -> [FramedCompression] #

enumFromThenTo :: FramedCompression -> FramedCompression -> FramedCompression -> [FramedCompression] #

Methods

showsPrec :: Int -> FramedCompression -> ShowS #

show :: FramedCompression -> String #

showList :: [FramedCompression] -> ShowS #

Methods

put :: FramedCompression -> Put #

get :: Get FramedCompression #

putList :: [FramedCompression] -> Put #

Methods

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

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

Methods

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

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

toConstr :: LoginService -> Constr #

dataTypeOf :: LoginService -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: LoginService -> LoginService #

pred :: LoginService -> LoginService #

toEnum :: Int -> LoginService #

fromEnum :: LoginService -> Int #

enumFrom :: LoginService -> [LoginService] #

enumFromThen :: LoginService -> LoginService -> [LoginService] #

enumFromTo :: LoginService -> LoginService -> [LoginService] #

enumFromThenTo :: LoginService -> LoginService -> LoginService -> [LoginService] #

Methods

showsPrec :: Int -> LoginService -> ShowS #

show :: LoginService -> String #

showList :: [LoginService] -> ShowS #

Methods

put :: LoginService -> Put #

get :: Get LoginService #

putList :: [LoginService] -> Put #

Methods

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

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

Methods

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

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

toConstr :: TerminationAction -> Constr #

dataTypeOf :: TerminationAction -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: TerminationAction -> TerminationAction #

pred :: TerminationAction -> TerminationAction #

toEnum :: Int -> TerminationAction #

fromEnum :: TerminationAction -> Int #

enumFrom :: TerminationAction -> [TerminationAction] #

enumFromThen :: TerminationAction -> TerminationAction -> [TerminationAction] #

enumFromTo :: TerminationAction -> TerminationAction -> [TerminationAction] #

enumFromThenTo :: TerminationAction -> TerminationAction -> TerminationAction -> [TerminationAction] #

Methods

showsPrec :: Int -> TerminationAction -> ShowS #

show :: TerminationAction -> String #

showList :: [TerminationAction] -> ShowS #

Methods

put :: TerminationAction -> Put #

get :: Get TerminationAction #

putList :: [TerminationAction] -> Put #

Methods

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

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

Methods

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

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

toConstr :: NASPortType -> Constr #

dataTypeOf :: NASPortType -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: NASPortType -> NASPortType #

pred :: NASPortType -> NASPortType #

toEnum :: Int -> NASPortType #

fromEnum :: NASPortType -> Int #

enumFrom :: NASPortType -> [NASPortType] #

enumFromThen :: NASPortType -> NASPortType -> [NASPortType] #

enumFromTo :: NASPortType -> NASPortType -> [NASPortType] #

enumFromThenTo :: NASPortType -> NASPortType -> NASPortType -> [NASPortType] #

Methods

showsPrec :: Int -> NASPortType -> ShowS #

show :: NASPortType -> String #

showList :: [NASPortType] -> ShowS #

Methods

put :: NASPortType -> Put #

get :: Get NASPortType #

putList :: [NASPortType] -> Put #

Methods

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

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

Methods

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

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

toConstr :: ARAPZoneAccess -> Constr #

dataTypeOf :: ARAPZoneAccess -> DataType #

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

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

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

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

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

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

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

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

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

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

Methods

succ :: ARAPZoneAccess -> ARAPZoneAccess #

pred :: ARAPZoneAccess -> ARAPZoneAccess #

toEnum :: Int -> ARAPZoneAccess #

fromEnum :: ARAPZoneAccess -> Int #

enumFrom :: ARAPZoneAccess -> [ARAPZoneAccess] #

enumFromThen :: ARAPZoneAccess -> ARAPZoneAccess -> [ARAPZoneAccess] #

enumFromTo :: ARAPZoneAccess -> ARAPZoneAccess -> [ARAPZoneAccess] #

enumFromThenTo :: ARAPZoneAccess -> ARAPZoneAccess -> ARAPZoneAccess -> [ARAPZoneAccess] #

Methods

showsPrec :: Int -> ARAPZoneAccess -> ShowS #

show :: ARAPZoneAccess -> String #

showList :: [ARAPZoneAccess] -> ShowS #

Methods

put :: ARAPZoneAccess -> Put #

get :: Get ARAPZoneAccess #

putList :: [ARAPZoneAccess] -> Put #

Methods

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

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