Both the old JVM interop and the new JVM interop use the same syntax for array types.

1 files changed, 0 insertions, 124 deletions

diff --git a/stdlib/source/lux/world/net/udp.old.lux b/stdlib/source/lux/world/net/udp.old.lux
deleted file mode 100644
index 1f78f4b0d..000000000
--- a/stdlib/source/lux/world/net/udp.old.lux
+++ /dev/null
@@ -1,124 +0,0 @@
-(.module:
-  [lux #*
-   [host (#+ import:)]
-   ["@" target]
-   [abstract
-    monad]
-   [control
-    ["ex" exception (#+ exception:)]
-    ["." io (#+ IO)]
-    [concurrency
-     ["." promise (#+ Promise)]]
-    [security
-     ["!" capability]]]
-   [data
-    ["." error (#+ Error)]
-    ["." maybe]
-    [collection
-     ["." array]]]
-   [world
-    ["." binary (#+ Binary)]]]
-  ["." // (#+ Location Can-Read Can-Write Can-Close)])
-
-(exception: #export (cannot-resolve-address {address //.Address})
-  (ex.report ["Address" address]))
-
-(exception: #export (multiple-candidate-addresses {address //.Address})
-  (ex.report ["Address" address]))
-
-(signature: #export (UDP !)
-  (: (Can-Read ! [Nat Location Binary])
-     read)
-
-  (: (Can-Write ! [Location Binary])
-     write)
-
-  (: (Can-Close !)
-     close))
-
-(def: #export (async udp)
-  (-> (UDP IO) (UDP Promise))
-  (`` (structure (~~ (template [<name> <forge>]
-                       [(def: <name> (<forge> (|>> (!.use (:: udp <name>)) promise.future)))]
-
-                       [read //.can-read]
-                       [write //.can-write]
-                       [close //.can-close])))))
-
-(with-expansions [<for-jvm> (as-is (import: java/lang/AutoCloseable
-                                     (close [] #io #try void))
-
-                                   (import: java/io/Flushable
-                                     (flush [] #io #try void))
-
-                                   (import: java/net/InetAddress
-                                     (#static getAllByName [String] #io #try (Array InetAddress))
-                                     (getHostAddress [] String))
-
-                                   (import: java/net/DatagramPacket
-                                     (new #as new|send [(Array byte) int int InetAddress int])
-                                     (new #as new|receive [(Array byte) int int])
-                                     (getAddress [] InetAddress)
-                                     (getPort [] int)
-                                     (getLength [] int))
-
-                                   (import: java/net/DatagramSocket
-                                     (new #as new|client [] #io #try)
-                                     (new #as new|server [int] #io #try)
-                                     (receive [DatagramPacket] #io #try void)
-                                     (send [DatagramPacket] #io #try void))
-
-                                   (def: (resolve address)
-                                     (-> //.Address (IO (Error InetAddress)))
-                                     (do (error.with io.monad)
-                                       [addresses (InetAddress::getAllByName address)]
-                                       (: (IO (Error InetAddress))
-                                          (case (array.size addresses)
-                                            0 (io.io (ex.throw cannot-resolve-address address))
-                                            1 (wrap (maybe.assume (array.read 0 addresses)))
-                                            _ (io.io (ex.throw multiple-candidate-addresses address))))))
-
-                                   (def: (udp socket)
-                                     (-> DatagramSocket (UDP IO))
-                                     (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)))
-
-                                   (def: #export server
-                                     (-> //.Port (IO (Error (UDP IO))))
-                                     (|>> .int
-                                          DatagramSocket::new|server
-                                          (:: (error.with io.monad) map ..udp)))
-                                   )]
-  (`` (for {(~~ (static @.old))
-            (as-is <for-jvm>)
-
-            (~~ (static @.jvm))
-            (as-is <for-jvm>)})))