netspec- Simplify static Networking tasks

Safe HaskellSafe-Infered




Use Lazy ByteStrings of JSON to send and receive messages. For this module, a message is prefixed by a 64-bit little-endian signed integer, indicating the length in bytes of the remaining message, which is encoded in JSON format.



receive :: (MonadIO io, FromJSON j) => Handle -> io (Maybe j)Source

Receive a JSON message from a Handle. Unlike Text and ByteString, the result of this MonadIO action is wrapped in a Maybe. Nothing means that the data received could not be parsed from JSON to the correct data type. It is up to you to decide whether or not to explicitly handle the Nothing case.

Notice that this action is polymorphic in its return type. Type annotations are usually unnecessary, since type inference can usually determine the correct target type. Example usage:

  do Just m <- receive h
     case m of Foo x y -> handleFoo x y
               Bar z   -> handleBar z

Here m is inferred to have whatever type Foo and Bar belong to. This example code assumes that the JSON parse will succeed. The fail function will be invoked for the Monad you are working in if such a pattern match fails.


(!) :: (CanSendJson h, MonadIO io) => ToJSON j => h -> j -> io ()Source

The staple for sending a message. ! is typeclassed so that you can send or broadcast using the same simple syntax. The CanSendJson typeclass is not exposed. Instances of CanSendJson include Handle and Traversable t => t Handle.

! produces an IO action lifted into any MonadIO, so can be used without the extra cruft of liftIO for most monad stacks. ! is declared as infix 2.


 destination ! someData

Anything that is an instance of ToJSON can be used on the right-hand side of !.

send :: MonadIO io => ToJSON j => Handle -> j -> io ()Source

Send a JSON message to exactly one Handle.

broadcast :: MonadIO io => (ToJSON j, Foldable f) => f Handle -> j -> io ()Source

Broadcast a JSON message to multiple Handles.


deriveJson :: (String -> String) -> Name -> Q [Dec]Source

Derives ToJSON and FromJSON instances for your data types. These are necessary in order to use the functions this module provides with your custom data types.


  {-# LANGUAGE TemplateHaskell #-}
  data Foo = Bar | Baz { quux :: Int }
  $(deriveJson id ''Foo)

Alteratively, you could write your own instances.

Other re-exports