Ported tests for world-related modules.

3 files changed, 82 insertions, 62 deletions

diff --git a/stdlib/source/lux/world/net.lux b/stdlib/source/lux/world/net.lux
index a56c9c62e..ff753f527 100644
--- a/stdlib/source/lux/world/net.lux
+++ b/stdlib/source/lux/world/net.lux
@@ -4,7 +4,7 @@
     [error (#+ Error)]]
    [control
     [security
-     [capability (#+ Capability)]]]])
+     ["!" capability (#+ capability:)]]]])
 
 (type: #export Address Text)
 
@@ -16,11 +16,11 @@
   {#address Address
    #port Port})
 
-(type: #export (Can-Read ! o)
-  (Capability Nat (! (Error o))))
+(capability: #export (Can-Read ! o)
+  (can-read Nat (! (Error o))))
 
-(type: #export (Can-Write ! i)
-  (Capability i (! (Error Any))))
+(capability: #export (Can-Write ! i)
+  (can-write i (! (Error Any))))
 
-(type: #export (Can-Close !)
-  (Capability [] (! (Error Any))))
+(capability: #export (Can-Close !)
+  (can-close [] (! (Error Any))))
diff --git a/stdlib/source/lux/world/net/tcp.jvm.lux b/stdlib/source/lux/world/net/tcp.jvm.lux
index 35b2e31f0..7ff25d6ee 100644
--- a/stdlib/source/lux/world/net/tcp.jvm.lux
+++ b/stdlib/source/lux/world/net/tcp.jvm.lux
@@ -3,8 +3,10 @@
    [control
     monad
     [concurrency
-     ["." promise (#+ Promise promise)]
-     ["." frp]]]
+     ["." promise (#+ Promise Resolver)]
+     ["." frp (#+ Channel Sink)]]
+    [security
+     ["!" capability]]]
    [data
     ["." error (#+ Error)]]
    [world
@@ -53,10 +55,12 @@
 
 (def: #export (async tcp)
   (-> (TCP IO) (TCP Promise))
-  (`` (structure (~~ (do-template [<capability>]
-                       [(def: <capability> (|>> (:: tcp <capability>) promise.future))]
+  (`` (structure (~~ (do-template [<capability> <forge>]
+                       [(def: <capability> (<forge> (|>> (!.use (:: tcp <capability>)) promise.future)))]
 
-                       [read] [write] [close])))))
+                       [read //.can-read]
+                       [write //.can-write]
+                       [close //.can-close])))))
 
 (`` (for {(~~ (static host.jvm))
           (as-is (def: (tcp socket)
@@ -65,24 +69,30 @@
                      [input (Socket::getInputStream socket)
                       output (Socket::getOutputStream socket)]
                      (wrap (: (TCP IO)
-                              (structure (def: (read size)
-                                           (do (error.with io.monad)
-                                             [#let [data (binary.create size)]
-                                              bytes-read (InputStream::read data +0 (.int size) input)]
-                                             (wrap [(.nat bytes-read)
-                                                    data])))
+                              (structure (def: read
+                                           (//.can-read
+                                            (function (read size)
+                                              (do (error.with io.monad)
+                                                [#let [data (binary.create size)]
+                                                 bytes-read (InputStream::read data +0 (.int size) input)]
+                                                (wrap [(.nat bytes-read)
+                                                       data])))))
                                          
-                                         (def: (write data)
-                                           (do (error.with io.monad)
-                                             [_ (OutputStream::write data +0 (.int (binary.size data))
-                                                                     output)]
-                                             (Flushable::flush output)))
-
-                                         (def: (close _)
-                                           (do (error.with io.monad)
-                                             [_ (AutoCloseable::close input)
-                                              _ (AutoCloseable::close output)]
-                                             (AutoCloseable::close socket))))))))
+                                         (def: write
+                                           (//.can-write
+                                            (function (write data)
+                                              (do (error.with io.monad)
+                                                [_ (OutputStream::write data +0 (.int (binary.size data))
+                                                                        output)]
+                                                (Flushable::flush output)))))
+
+                                         (def: close
+                                           (//.can-close
+                                            (function (close _)
+                                              (do (error.with io.monad)
+                                                [_ (AutoCloseable::close input)
+                                                 _ (AutoCloseable::close output)]
+                                                (AutoCloseable::close socket))))))))))
 
                  (def: #export (client address port)
                    (-> //.Address //.Port (IO (Error (TCP IO))))
@@ -91,17 +101,17 @@
                      (io.io (tcp socket))))
 
                  (def: #export (server port)
-                   (-> //.Port (IO (Error [(Promise Any)
-                                           (frp.Channel (TCP IO))])))
+                   (-> //.Port (IO (Error [(Resolver Any)
+                                           (Channel (TCP IO))])))
                    (do (error.with io.monad)
                      [server (ServerSocket::new (.int port))
-                      #let [close-signal (: (Promise Any)
-                                            (promise #.None))
+                      #let [[close-signal close-resolver] (: [(Promise Any) (Resolver Any)]
+                                                             (promise.promise []))
                             _ (promise.await (function (_ _)
                                                (AutoCloseable::close server))
                                              close-signal)
-                            output (: (frp.Channel (TCP IO))
-                                      (frp.channel []))
+                            [output sink] (: [(Channel (TCP IO)) (Sink (TCP IO))]
+                                             (frp.channel []))
                             _ (: (Promise Any)
                                  (promise.future
                                   (loop [_ []]
@@ -115,6 +125,6 @@
                                         
                                         (#error.Success client)
                                         (do @
-                                          [_ (frp.publish output client)]
+                                          [_ (:: sink feed client)]
                                           (recur [])))))))]]
-                     (wrap [close-signal output]))))}))
+                     (wrap [close-resolver output]))))}))
diff --git a/stdlib/source/lux/world/net/udp.jvm.lux b/stdlib/source/lux/world/net/udp.jvm.lux
index 833b72e08..f7228aed3 100644
--- a/stdlib/source/lux/world/net/udp.jvm.lux
+++ b/stdlib/source/lux/world/net/udp.jvm.lux
@@ -4,7 +4,9 @@
     monad
     ["ex" exception (#+ exception:)]
     [concurrency
-     ["." promise (#+ Promise)]]]
+     ["." promise (#+ Promise)]]
+    [security
+     ["!" capability]]]
    [data
     ["." error (#+ Error)]
     ["." maybe]
@@ -64,10 +66,12 @@
 
 (def: #export (async udp)
   (-> (UDP IO) (UDP Promise))
-  (`` (structure (~~ (do-template [<name>]
-                       [(def: <name> (|>> (:: udp <name>) promise.future))]
+  (`` (structure (~~ (do-template [<name> <forge>]
+                       [(def: <name> (<forge> (|>> (!.use (:: udp <name>)) promise.future)))]
 
-                       [read] [write] [close])))))
+                       [read //.can-read]
+                       [write //.can-write]
+                       [close //.can-close])))))
 
 (`` (for {(~~ (static host.jvm))
           (as-is (def: (resolve address)
@@ -82,34 +86,40 @@
 
                  (def: (udp socket)
                    (-> DatagramSocket (UDP IO))
-                   (structure (def: (read size)
-                                (let [data (binary.create size)
-                                      packet (DatagramPacket::new|receive data +0 (.int size))]
-                                  (do (error.with io.monad)
-                                    [_ (DatagramSocket::receive packet socket)
-                                     #let [bytes-read (.nat (DatagramPacket::getLength packet))]]
-                                    (wrap [bytes-read
-                                           {#//.address (|> packet DatagramPacket::getAddress InetAddress::getHostAddress)
-                                            #//.port (.nat (DatagramPacket::getPort packet))}
-                                           data]))))
-
-                              (def: (write [location data])
-                                (do (error.with io.monad)
-                                  [address (resolve (get@ #//.address location))]
-                                  (DatagramSocket::send (DatagramPacket::new|send data +0 (.int (binary.size data)) address (.int (get@ #//.port location)))
-                                                        socket)))
-
-                              (def: (close _)
-                                (AutoCloseable::close socket))))
+                   (structure (def: read
+                                (//.can-read
+                                 (function (read size)
+                                   (let [data (binary.create size)
+                                         packet (DatagramPacket::new|receive data +0 (.int size))]
+                                     (do (error.with io.monad)
+                                       [_ (DatagramSocket::receive packet socket)
+                                        #let [bytes-read (.nat (DatagramPacket::getLength packet))]]
+                                       (wrap [bytes-read
+                                              {#//.address (|> packet DatagramPacket::getAddress InetAddress::getHostAddress)
+                                               #//.port (.nat (DatagramPacket::getPort packet))}
+                                              data]))))))
+
+                              (def: write
+                                (//.can-write
+                                 (function (write [location data])
+                                   (do (error.with io.monad)
+                                     [address (resolve (get@ #//.address location))]
+                                     (DatagramSocket::send (DatagramPacket::new|send data +0 (.int (binary.size data)) address (.int (get@ #//.port location)))
+                                                           socket)))))
+
+                              (def: close
+                                (//.can-close
+                                 (function (close _)
+                                   (AutoCloseable::close socket))))))
 
                  (def: #export client
                    (IO (Error (UDP IO)))
                    (|> (DatagramSocket::new|client)
-                       (:: (error.with io.monad) map udp)))
+                       (:: (error.with io.monad) map ..udp)))
 
                  (def: #export server
                    (-> //.Port (IO (Error (UDP IO))))
                    (|>> .int
                         DatagramSocket::new|server
-                        (:: (error.with io.monad) map udp)))
+                        (:: (error.with io.monad) map ..udp)))
                  )}))