Nitro is a fast, secure transport layer for sending messages across TCP and Inproc sockets. It is ideal for building scalable network applications. Nitro depends on the c libraries nitro and nitronacl (https://github.com/bumptech/nitro).

 {-# LANGUAGE OverloadedStrings, ForeignFunctionInterface #-}
 import System.Nitro

 main = do
     nitroRuntimeStart

     server <- bind "tcp://127.0.0.1:7777" defaultOpts
     client <- connect "tcp://127.0.0.1:7777" defaultOpts

     fr <- bstrToFrame "Hi I'm a client"
     send client fr []
     recv server [] >>= frameToBstr >>= print

 {-# LANGUAGE OverloadedStrings, ForeignFunctionInterface #-}
 import System.Nitro
 import Control.Concurrent (forkIO, threadDelay)
 import Control.Monad (forever)

 main = do
     nitroRuntimeStart

     server <- bind "tcp://*:7777" defaultOpts

     let serverWorker = (\i -> forkIO $ forever $ do
                             fr <- recv server []
                             threadDelay 1000000
                             print ("Thread #" ++ (show i))
                             print . frameToBstr $ msg
                         )

     mapM_ serverWorker [1..2]

     client <- connect "tcp://127.0.0.1:7777" client
     fr1 <- bstrToFrame "Here's a request"
     send client fr1 []
     fr2 <- bstrToFrame "Here's another request"
     send client fr2 []

     threadDelay 2000000

Nitro wraps messages in a transport layer called a NitroFrame. NitroFrames encode routing information about the sender of a message. When you receive a NitroFrame you can use it to reply to the original sender. Compile all multithreaded Nitro code with ghc-option: -threaded

 {-# LANGUAGE OverloadedStrings, ForeignFunctionInterface #-}
 import System.Nitro
 import Control.Concurrent (forkIO, threadDelay)
 import Control.Monad (forever)

 main = do
     nitroRuntimeStart

     client1 <- connect "tcp://127.0.0.1:7777" defaultOpts
     client2 <- connect "tcp://127.0.0.1:7777" defaultOpts

     fr1 <- bstrToFrame "Hi I want a response"
     send client1 fr1 []
     fr2 <- bstrToFrame "Hi I also want a response"
     send client2 fr2 []

     forkIO $ withSocket (bind "tcp://127.0.0.1:7777" defaultOpts)
                         (\echoServer -> forever $ do
                             frame <- recv echoServer []
                             reply echoServer frame frame []
                         )

     recv client1 [] >>= frameToBstr >>= print
     recv client2 [] >>= frameToBstr >>= print

Nitro sockets are threadsafe. Many worker threads can receive messages on a shared socket without overlap.

 {-# LANGUAGE OverloadedStrings, ForeignFunctionInterface #-}
 import System.Nitro
 import Data.ByteString as BS
 import Control.Concurrent (threadDelay, forkIO)
 import Control.Monad (forever, when)

 proxy = withSocket (bind "tcp://127.0.0.1:7777" defaultOpts)
                    (\proxyRecv -> do
                        withSocket (connect "tcp://127.0.0.1:7778" defaultOpts)
                        (\proxySend -> forever $ do
                            frame <- recv proxyRecv []
                            msg <- frameToBstr
                            when (BS.length msg < 50) $
                            relayFw proxySend frame frame []
                        )
                    )

 server = withSocket (bind "tcp://127.0.0.1:7778" defaultOpts)
                     (\server -> forever $ do
                         fr <- recv server []
                         print . frameToBstr $ fr
                     )

 main = do
     nitroRuntimeStart

     forkIO $ server
     forkIO $ proxy

     client <- connect "tcp://127.0.0.1:7777" defaultOpts
     fr1 <- bstrToFrame "Here's a short message"
     send client fr1  []
     fr2 <- "This message is too long for our server, it will be blocked"
     send client fr2  []
     threadDelay 1000000

 {-# LANGUAGE OverloadedStrings, ForeignFunctionInterface #-}
 import System.Nitro
 import Control.Concurrent (threadDelay)

 main = do
    nitroRuntimeStart

    server <- bind "tcp://127.0.0.1:7777" defaultOpts
    client <- connect "tcp://127.0.0.1:7777" defaultOpts

    sub client "con"
    threadDelay 1000000

    fr <- bstrToFrame "You don't understand"
    pub server fr "contender" []

    recv client [] >>= frameToBstr >>= print

Nitro sockets support a NoWait flag, which makes calls to recv nonblocking. To make this useful, Nitro exposes an Int that represents the file descriptor of a Nitro socket. Registering an intent to read from this file descriptor using the GHC event manager is one way to know when it is safe to do a nonblocking recv.