Helpful library updates

lib/socket.tri

@@ -16,48 +16,68 @@ recv        = sock maxBytes  : pair 76 (pair sock maxBytes)
 send        = sock bytes     : pair 77 (pair sock bytes)
 getSocketName = sock         : pair 78 sock
 
--- ---------------------------------------------------------------------------
--- Convenience helpers
--- ---------------------------------------------------------------------------
+-- Result-aware wrappers over raw socket actions.
+onSocket     = onResult socket
+onBindSocket = sock addr port : onResult (bindSocket sock addr port)
+onListen     = sock backlog   : onResult (listen sock backlog)
+onAccept     = sock           : onResult (accept sock)
+onConnect    = sock addr port : onResult (connect sock addr port)
+onRecv       = sock maxBytes  : onResult (recv sock maxBytes)
+onSend       = sock bytes     : onResult (send sock bytes)
+onGetSocketName = sock        : onResult (getSocketName sock)
 
-onSocket = (action errCase okCase :
-  bind action (result :
-    matchResult errCase okCase result))
+-- Result-aware wrappers that drop the useless 'rest' parameter.
+onSocket_     = onResult_ socket
+onBindSocket_ = sock addr port : onResult_ (bindSocket sock addr port)
+onListen_     = sock backlog   : onResult_ (listen sock backlog)
+onAccept_     = sock           : onResult_ (accept sock)
+onConnect_    = sock addr port : onResult_ (connect sock addr port)
+onRecv_       = sock maxBytes  : onResult_ (recv sock maxBytes)
+onSend_       = sock bytes     : onResult_ (send sock bytes)
+onGetSocketName_ = sock       : onResult_ (getSocketName sock)
+
+-- Close a socket, ignoring errors.
+closeSocket_ = sock : void (closeSocket sock)
 
 -- Create a listening socket bound to an address and port.
 -- Returns ok listenSocket or err message.
 listenSocket = addr port backlog :
-  bind (socket) (result :
-    matchResult
-      (err rest : pure (err "socket creation failed"))
-      (sock rest :
-        bind (bindSocket sock addr port) (bindResult :
-          matchResult
-            (err rest : pure (err "bind failed"))
-            (_ rest :
-              bind (listen sock backlog) (listenResult :
-                matchResult
-                  (err rest : pure (err "listen failed"))
-                  (_ rest : pure (ok sock))
-                  listenResult))
-            bindResult))
-      result)
+  onOk_ socket (server :
+    onOk_ (bindSocket server addr port) (_ :
+      onOk_ (listen server backlog) (_ :
+        pure (ok server))))
 
--- Accept a connection and return (clientSocket, peerAddr).
--- The returned peerAddr is a string like "127.0.0.1:8080".
-onAccept = (sock errCase okCase :
-  bind (accept sock) (result :
-    matchResult errCase okCase result))
+-- Accept a connection with explicit error and ok branches.
+-- okHandler receives (clientSocket, peerAddr).
+withAccepted = (server errHandler okHandler :
+  onResult (accept server)
+    errHandler
+    (accepted rest :
+      okHandler (fst accepted) (snd accepted)))
 
--- Receive all available bytes up to maxBytes.
-onRecv = (sock maxBytes errCase okCase :
-  bind (recv sock maxBytes) (result :
-    matchResult errCase okCase result))
+-- Same as withAccepted, but handlers drop the useless 'rest' parameter.
+withAccepted_ = (server errHandler okHandler :
+  onResult_ (accept server)
+    errHandler
+    (accepted :
+      okHandler (fst accepted) (snd accepted)))
 
--- Send bytes and return number of bytes sent.
-onSend = (sock bytes errCase okCase :
-  bind (send sock bytes) (result :
-    matchResult errCase okCase result))
+serveOnce = (server handler :
+  withAccepted_ server
+    (err : pure t)
+    (client peer :
+      handler client peer))
 
--- Close a socket, ignoring errors.
-closeSocket_ = sock : bind (closeSocket sock) (_ : pure t)
+serveForkingOnce = (server handler :
+  withAccepted_ server
+    (err : pure t)
+    (client peer :
+      fork (handler client peer)))
+
+serveForever = (server handler :
+  forever (serveForkingOnce server handler))
+
+connectTo = (addr port :
+  onOk socket (client rest :
+    onOk (connect client addr port) (_ rest :
+      pure (ok client rest))))