Safe Haskell	None
Language	Haskell2010

Servant.Subscriber

Synopsis

Documentation

notify :: forall api endpoint. (IsElem endpoint api, HasLink endpoint, IsValidEndpoint endpoint, IsSubscribable endpoint api) => Subscriber api -> Event -> Proxy endpoint -> (MkLink endpoint -> URI) -> STM () Source #

Notify the subscriber about a changed resource. You have to provide a typesafe link to the changed resource. Only Symbols and Captures are allowed in this link.

You need to provide a proxy to the API too. This is needed to check that the endpoint is valid and points to a Subscribable resource.

One piece is still missing - we have to fill out captures, that's what the getLink parameter is for: You will typicall provide a lamda there providing needed parameters.

TODO: Example!

makeSubscriber :: Path -> LogRunner -> STM (Subscriber api) Source #

serveSubscriber :: forall api. HasServer api '[] => Subscriber api -> Server api -> Application Source #

data Subscriber api Source #

data Event Source #

Constructors

DeleteEvent
ModifyEvent

Instances

Eq Event Source #
Methods (==) :: Event -> Event -> Bool # (/=) :: Event -> Event -> Bool #

type family IsElem endpoint api :: Constraint where ... #

Closed type family, check if endpoint is within api

Equations

IsElem e ((:<\|>) sa sb) = Or (IsElem e sa) (IsElem e sb)
IsElem ((:>) k * e sa) ((:>) k * e sb) = IsElem sa sb
IsElem sa ((:>) * * (Header sym x) sb) = IsElem sa sb
IsElem sa ((:>) * * (ReqBody k y x) sb) = IsElem sa sb
IsElem ((:>) * * (Capture k z y) sa) ((:>) * * (Capture k x y) sb) = IsElem sa sb
IsElem ((:>) * * (CaptureAll k z y) sa) ((:>) * * (CaptureAll k x y) sb) = IsElem sa sb
IsElem sa ((:>) * * (QueryParam k x y) sb) = IsElem sa sb
IsElem sa ((:>) * * (QueryParams k x y) sb) = IsElem sa sb
IsElem sa ((:>) * * (QueryFlag x) sb) = IsElem sa sb
IsElem (Verb k1 k m s ct typ) (Verb k1 k m s ct' typ) = IsSubList * ct ct'
IsElem e e = ()
IsElem e a = IsElem' e a

class HasLink k endpoint #

Construct a toLink for an endpoint.

Minimal complete definition

toLink

Associated Types

type MkLink k (endpoint :: k) :: * #

Instances

HasLink * Raw
Associated Types type MkLink Raw (endpoint :: Raw) :: * # Methods toLink :: Proxy Raw endpoint -> Link -> MkLink Raw endpoint #
HasLink * sub => HasLink * ((:>) * * Subscribable sub) #
Associated Types type MkLink ((:>) * * Subscribable sub) (endpoint :: (:>) * * Subscribable sub) :: * # Methods toLink :: Proxy ((* :> ) Subscribable sub) endpoint -> Link -> MkLink (( :> *) Subscribable sub) endpoint #
(KnownSymbol sym, ToHttpApiData v, HasLink k sub) => HasLink * ((:>) * k (QueryParam * sym v) sub)
Associated Types type MkLink ((:>) * k (QueryParam * sym v) sub) (endpoint :: (:>) * k (QueryParam * sym v) sub) :: * # Methods toLink :: Proxy ((* :> k) (QueryParam * sym v) sub) endpoint -> Link -> MkLink ((* :> k) (QueryParam * sym v) sub) endpoint #
(KnownSymbol sym, ToHttpApiData v, HasLink k sub) => HasLink * ((:>) * k (QueryParams * sym v) sub)
Associated Types type MkLink ((:>) * k (QueryParams * sym v) sub) (endpoint :: (:>) * k (QueryParams * sym v) sub) :: * # Methods toLink :: Proxy ((* :> k) (QueryParams * sym v) sub) endpoint -> Link -> MkLink ((* :> k) (QueryParams * sym v) sub) endpoint #
(KnownSymbol sym, HasLink k sub) => HasLink * ((:>) * k (QueryFlag sym) sub)
Associated Types type MkLink ((:>) * k (QueryFlag sym) sub) (endpoint :: (:>) * k (QueryFlag sym) sub) :: * # Methods toLink :: Proxy ((* :> k) (QueryFlag sym) sub) endpoint -> Link -> MkLink ((* :> k) (QueryFlag sym) sub) endpoint #
HasLink k sub => HasLink * ((:>) * k (ReqBody k1 ct a) sub)
Associated Types type MkLink ((:>) * k (ReqBody k1 ct a) sub) (endpoint :: (:>) * k (ReqBody k1 ct a) sub) :: * # Methods toLink :: Proxy ((* :> k) (ReqBody k1 ct a) sub) endpoint -> Link -> MkLink ((* :> k) (ReqBody k1 ct a) sub) endpoint #
(ToHttpApiData v, HasLink k sub) => HasLink * ((:>) * k (Capture * sym v) sub)
Associated Types type MkLink ((:>) * k (Capture * sym v) sub) (endpoint :: (:>) * k (Capture * sym v) sub) :: * # Methods toLink :: Proxy ((* :> k) (Capture * sym v) sub) endpoint -> Link -> MkLink ((* :> k) (Capture * sym v) sub) endpoint #
(ToHttpApiData v, HasLink k sub) => HasLink * ((:>) * k (CaptureAll * sym v) sub)
Associated Types type MkLink ((:>) * k (CaptureAll * sym v) sub) (endpoint :: (:>) * k (CaptureAll * sym v) sub) :: * # Methods toLink :: Proxy ((* :> k) (CaptureAll * sym v) sub) endpoint -> Link -> MkLink ((* :> k) (CaptureAll * sym v) sub) endpoint #
HasLink k sub => HasLink * ((:>) * k (Header sym a) sub)
Associated Types type MkLink ((:>) * k (Header sym a) sub) (endpoint :: (:>) * k (Header sym a) sub) :: * # Methods toLink :: Proxy ((* :> k) (Header sym a) sub) endpoint -> Link -> MkLink ((* :> k) (Header sym a) sub) endpoint #
HasLink k sub => HasLink * ((:>) * k RemoteHost sub)
Associated Types type MkLink ((:>) * k RemoteHost sub) (endpoint :: (:>) * k RemoteHost sub) :: * # Methods toLink :: Proxy ((* :> k) RemoteHost sub) endpoint -> Link -> MkLink ((* :> k) RemoteHost sub) endpoint #
HasLink k sub => HasLink * ((:>) * k (BasicAuth realm a) sub)
Associated Types type MkLink ((:>) * k (BasicAuth realm a) sub) (endpoint :: (:>) * k (BasicAuth realm a) sub) :: * # Methods toLink :: Proxy ((* :> k) (BasicAuth realm a) sub) endpoint -> Link -> MkLink ((* :> k) (BasicAuth realm a) sub) endpoint #
(KnownSymbol sym, HasLink k sub) => HasLink * ((:>) Symbol k sym sub)
Associated Types type MkLink ((:>) Symbol k sym sub) (endpoint :: (:>) Symbol k sym sub) :: * # Methods toLink :: Proxy ((Symbol :> k) sym sub) endpoint -> Link -> MkLink ((Symbol :> k) sym sub) endpoint #
HasLink * (Verb k1 k m s ct a)
Associated Types type MkLink (Verb k1 k m s ct a) (endpoint :: Verb k1 k m s ct a) :: * # Methods toLink :: Proxy (Verb k1 k m s ct a) endpoint -> Link -> MkLink (Verb k1 k m s ct a) endpoint #

type family IsValidEndpoint endpoint :: Constraint where ... Source #

A valid endpoint may only contain Symbols and captures & for convenince Subscribable:

Equations

IsValidEndpoint ((sym :: Symbol) :> sub) = IsValidEndpoint sub
IsValidEndpoint (Capture z y :> sub) = IsValidEndpoint sub
IsValidEndpoint (Subscribable :> sub) = IsValidEndpoint sub
IsValidEndpoint (Verb (method :: k1) (statusCode :: Nat) (contentTypes :: []) (a :: )) = ()

type family IsSubscribable endpoint api :: Constraint where ... Source #

Equations

IsSubscribable sa (Subscribable :> sb) = ()
IsSubscribable e (sa :<\|> sb) = Or (IsSubscribable e sa) (IsSubscribable e sb)
IsSubscribable ((sym :: Symbol) :> sa) (sym :> sb) = IsSubscribable sa sb
IsSubscribable (e :> sa) (e :> sb) = IsSubscribable sa sb
IsSubscribable sa (Header sym x :> sb) = IsSubscribable sa sb
IsSubscribable sa (ReqBody y x :> sb) = IsSubscribable sa sb
IsSubscribable (Capture z y :> sa) (Capture x y :> sb) = IsSubscribable sa sb
IsSubscribable sa (QueryParam x y :> sb) = IsSubscribable sa sb
IsSubscribable sa (QueryParams x y :> sb) = IsSubscribable sa sb
IsSubscribable sa (QueryFlag x :> sb) = IsSubscribable sa sb
IsSubscribable e a = IsSubscribable' e a

data Proxy k t :: forall k. k -> * #

A concrete, poly-kinded proxy type

Instances

Monad (Proxy *)
Methods (>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b # (>>) :: Proxy * a -> Proxy * b -> Proxy * b # return :: a -> Proxy * a # fail :: String -> Proxy * a #
Functor (Proxy *)
Methods fmap :: (a -> b) -> Proxy * a -> Proxy * b # (<$) :: a -> Proxy * b -> Proxy * a #
Applicative (Proxy *)
Methods pure :: a -> Proxy * a # (<>) :: Proxy (a -> b) -> Proxy * a -> Proxy * b # (>) :: Proxy a -> Proxy * b -> Proxy * b # (<) :: Proxy a -> Proxy * b -> Proxy * a #
Foldable (Proxy *)
Methods fold :: Monoid m => Proxy * m -> m # foldMap :: Monoid m => (a -> m) -> Proxy * a -> m # foldr :: (a -> b -> b) -> b -> Proxy * a -> b # foldr' :: (a -> b -> b) -> b -> Proxy * a -> b # foldl :: (b -> a -> b) -> b -> Proxy * a -> b # foldl' :: (b -> a -> b) -> b -> Proxy * a -> b # foldr1 :: (a -> a -> a) -> Proxy * a -> a # foldl1 :: (a -> a -> a) -> Proxy * a -> a # toList :: Proxy * a -> [a] # null :: Proxy * a -> Bool # length :: Proxy * a -> Int # elem :: Eq a => a -> Proxy * a -> Bool # maximum :: Ord a => Proxy * a -> a # minimum :: Ord a => Proxy * a -> a # sum :: Num a => Proxy * a -> a # product :: Num a => Proxy * a -> a #
Traversable (Proxy *)
Methods traverse :: Applicative f => (a -> f b) -> Proxy * a -> f (Proxy * b) # sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a) # mapM :: Monad m => (a -> m b) -> Proxy * a -> m (Proxy * b) # sequence :: Monad m => Proxy * (m a) -> m (Proxy * a) #
Generic1 (Proxy *)
Associated Types type Rep1 (Proxy * :: * -> ) :: -> * # Methods from1 :: Proxy * a -> Rep1 (Proxy ) a # to1 :: Rep1 (Proxy ) a -> Proxy * a #
Contravariant (Proxy *)
Methods contramap :: (a -> b) -> Proxy * b -> Proxy * a # (>$) :: b -> Proxy * b -> Proxy * a #
Representable (Proxy *)
Associated Types type Rep (Proxy * :: * -> ) :: # Methods tabulate :: (Rep (Proxy ) -> a) -> Proxy a # index :: Proxy * a -> Rep (Proxy *) -> a #
Alternative (Proxy *)
Methods empty :: Proxy * a # (<\|>) :: Proxy * a -> Proxy * a -> Proxy * a # some :: Proxy * a -> Proxy * [a] # many :: Proxy * a -> Proxy * [a] #
MonadPlus (Proxy *)
Methods mzero :: Proxy * a # mplus :: Proxy * a -> Proxy * a -> Proxy * a #
Eq1 (Proxy *)	Since: 4.9.0.0
Methods liftEq :: (a -> b -> Bool) -> Proxy * a -> Proxy * b -> Bool #
Ord1 (Proxy *)	Since: 4.9.0.0
Methods liftCompare :: (a -> b -> Ordering) -> Proxy * a -> Proxy * b -> Ordering #
Read1 (Proxy *)	Since: 4.9.0.0
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy * a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy * a] #
Show1 (Proxy *)	Since: 4.9.0.0
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy * a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy * a] -> ShowS #
Bounded (Proxy k s)
Methods minBound :: Proxy k s # maxBound :: Proxy k s #
Enum (Proxy k s)
Methods succ :: Proxy k s -> Proxy k s # pred :: Proxy k s -> Proxy k s # toEnum :: Int -> Proxy k s # fromEnum :: Proxy k s -> Int # enumFrom :: Proxy k s -> [Proxy k s] # enumFromThen :: Proxy k s -> Proxy k s -> [Proxy k s] # enumFromTo :: Proxy k s -> Proxy k s -> [Proxy k s] # enumFromThenTo :: Proxy k s -> Proxy k s -> Proxy k s -> [Proxy k s] #
Eq (Proxy k s)
Methods (==) :: Proxy k s -> Proxy k s -> Bool # (/=) :: Proxy k s -> Proxy k s -> Bool #
Data t => Data (Proxy * t)
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy * t -> c (Proxy * t) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy * t) # toConstr :: Proxy * t -> Constr # dataTypeOf :: Proxy * t -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Proxy t)) # dataCast2 :: Typeable (* -> * -> ) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Proxy t)) # gmapT :: (forall b. Data b => b -> b) -> Proxy * t -> Proxy * t # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r # gmapQ :: (forall d. Data d => d -> u) -> Proxy * t -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy * t -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) #
Ord (Proxy k s)
Methods compare :: Proxy k s -> Proxy k s -> Ordering # (<) :: Proxy k s -> Proxy k s -> Bool # (<=) :: Proxy k s -> Proxy k s -> Bool # (>) :: Proxy k s -> Proxy k s -> Bool # (>=) :: Proxy k s -> Proxy k s -> Bool # max :: Proxy k s -> Proxy k s -> Proxy k s # min :: Proxy k s -> Proxy k s -> Proxy k s #
Read (Proxy k s)
Methods readsPrec :: Int -> ReadS (Proxy k s) # readList :: ReadS [Proxy k s] # readPrec :: ReadPrec (Proxy k s) # readListPrec :: ReadPrec [Proxy k s] #
Show (Proxy k s)
Methods showsPrec :: Int -> Proxy k s -> ShowS # show :: Proxy k s -> String # showList :: [Proxy k s] -> ShowS #
Ix (Proxy k s)
Methods range :: (Proxy k s, Proxy k s) -> [Proxy k s] # index :: (Proxy k s, Proxy k s) -> Proxy k s -> Int # unsafeIndex :: (Proxy k s, Proxy k s) -> Proxy k s -> Int inRange :: (Proxy k s, Proxy k s) -> Proxy k s -> Bool # rangeSize :: (Proxy k s, Proxy k s) -> Int # unsafeRangeSize :: (Proxy k s, Proxy k s) -> Int
Generic (Proxy k t)
Associated Types type Rep (Proxy k t) :: * -> * # Methods from :: Proxy k t -> Rep (Proxy k t) x # to :: Rep (Proxy k t) x -> Proxy k t #
Semigroup (Proxy k s)
Methods (<>) :: Proxy k s -> Proxy k s -> Proxy k s # sconcat :: NonEmpty (Proxy k s) -> Proxy k s # stimes :: Integral b => b -> Proxy k s -> Proxy k s #
Monoid (Proxy k s)
Methods mempty :: Proxy k s # mappend :: Proxy k s -> Proxy k s -> Proxy k s # mconcat :: [Proxy k s] -> Proxy k s #
FromJSON (Proxy k a)
Methods parseJSON :: Value -> Parser (Proxy k a) # parseJSONList :: Value -> Parser [Proxy k a] #
ToJSON (Proxy k a)
Methods toJSON :: Proxy k a -> Value # toEncoding :: Proxy k a -> Encoding # toJSONList :: [Proxy k a] -> Value # toEncodingList :: [Proxy k a] -> Encoding #
type Rep1 (Proxy *)
type Rep1 (Proxy *) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1)
type Rep (Proxy *)
type Rep (Proxy *) = Void
type Rep (Proxy k t)
type Rep (Proxy k t) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1)

type family MkLink k (endpoint :: k) :: * #

Instances

type MkLink * Raw
type MkLink * Raw = URI
type MkLink * ((:>) * * Subscribable sub) #
type MkLink * ((:>) * * Subscribable sub) = MkLink * sub
type MkLink * ((:>) * k (BasicAuth realm a) sub)
type MkLink * ((:>) * k (BasicAuth realm a) sub) = MkLink k sub
type MkLink * ((:>) * k RemoteHost sub)
type MkLink * ((:>) * k RemoteHost sub) = MkLink k sub
type MkLink * ((:>) * k (Header sym a) sub)
type MkLink * ((:>) * k (Header sym a) sub) = MkLink k sub
type MkLink * ((:>) * k (CaptureAll * sym v) sub)
type MkLink * ((:>) * k (CaptureAll * sym v) sub) = [v] -> MkLink k sub
type MkLink * ((:>) * k (Capture * sym v) sub)
type MkLink * ((:>) * k (Capture * sym v) sub) = v -> MkLink k sub
type MkLink * ((:>) * k (ReqBody k1 ct a) sub)
type MkLink * ((:>) * k (ReqBody k1 ct a) sub) = MkLink k sub
type MkLink * ((:>) * k (QueryFlag sym) sub)
type MkLink * ((:>) * k (QueryFlag sym) sub) = Bool -> MkLink k sub
type MkLink * ((:>) * k (QueryParams * sym v) sub)
type MkLink * ((:>) * k (QueryParams * sym v) sub) = [v] -> MkLink k sub
type MkLink * ((:>) * k (QueryParam * sym v) sub)
type MkLink * ((:>) * k (QueryParam * sym v) sub) = Maybe v -> MkLink k sub
type MkLink * ((:>) Symbol k sym sub)
type MkLink * ((:>) Symbol k sym sub) = MkLink k sub
type MkLink * (Verb k1 k m s ct a)
type MkLink * (Verb k1 k m s ct a) = URI

data URI :: * #

Represents a general universal resource identifier using its component parts.

For example, for the URI

  foo://anonymous@www.haskell.org:42/ghc?query#frag

the components are:

Instances

Eq URI
Methods (==) :: URI -> URI -> Bool # (/=) :: URI -> URI -> Bool #
Data URI
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URI -> c URI # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c URI # toConstr :: URI -> Constr # dataTypeOf :: URI -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c URI) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URI) # gmapT :: (forall b. Data b => b -> b) -> URI -> URI # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URI -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URI -> r # gmapQ :: (forall d. Data d => d -> u) -> URI -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> URI -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> URI -> m URI # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URI -> m URI # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URI -> m URI #
Ord URI
Methods compare :: URI -> URI -> Ordering # (<) :: URI -> URI -> Bool # (<=) :: URI -> URI -> Bool # (>) :: URI -> URI -> Bool # (>=) :: URI -> URI -> Bool # max :: URI -> URI -> URI # min :: URI -> URI -> URI #
Show URI
Methods showsPrec :: Int -> URI -> ShowS # show :: URI -> String # showList :: [URI] -> ShowS #
Generic URI
Associated Types type Rep URI :: * -> * # Methods from :: URI -> Rep URI x # to :: Rep URI x -> URI #
NFData URI
Methods rnf :: URI -> () #
type Rep URI
type Rep URI = D1 (MetaData "URI" "Network.URI" "network-uri-2.6.1.0-6PuDgH21OiwGLI4QZ1g9kt" False) (C1 (MetaCons "URI" PrefixI True) ((::) ((::) (S1 (MetaSel (Just Symbol "uriScheme") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) (S1 (MetaSel (Just Symbol "uriAuthority") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe URIAuth)))) ((::) (S1 (MetaSel (Just Symbol "uriPath") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) ((::) (S1 (MetaSel (Just Symbol "uriQuery") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) (S1 (MetaSel (Just Symbol "uriFragment") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))))))

data STM a :: * -> * #

A monad supporting atomic memory transactions.

Instances

Monad STM
Methods (>>=) :: STM a -> (a -> STM b) -> STM b # (>>) :: STM a -> STM b -> STM b # return :: a -> STM a # fail :: String -> STM a #
Functor STM
Methods fmap :: (a -> b) -> STM a -> STM b # (<$) :: a -> STM b -> STM a #
Applicative STM
Methods pure :: a -> STM a # (<>) :: STM (a -> b) -> STM a -> STM b # (>) :: STM a -> STM b -> STM b # (<*) :: STM a -> STM b -> STM a #
Alternative STM
Methods empty :: STM a # (<\|>) :: STM a -> STM a -> STM a # some :: STM a -> STM [a] # many :: STM a -> STM [a] #
MonadPlus STM
Methods mzero :: STM a # mplus :: STM a -> STM a -> STM a #
MonadBaseControl STM STM
Associated Types type StM (STM :: * -> ) a :: # Methods liftBaseWith :: (RunInBase STM STM -> STM a) -> STM a # restoreM :: StM STM a -> STM a #
MonadBase STM STM
Methods liftBase :: STM α -> STM α #
type StM STM a
type StM STM a = a