Question

我试图找出原生界面。我尝试使用UDP发送一些消息。我在这里：

module UDPTest where    

data StringAsBytes = native java.lang.String where
  native getBytes :: String -> ST s (Mutable s (JArray Byte))    

data InetSocketAddress = native java.net.InetSocketAddress where
  native new :: String -> Int -> ST s (Mutable s InetSocketAddress)

data DatagramPacket = native java.net.DatagramPacket where
  native new :: Mutable s (JArray Byte)  -> Int -> Mutable s InetSocketAddress ->  ST s (Mutable s DatagramPacket)    

data DatagramSocket = native java.net.DatagramSocket where
  native new :: () -> IOMutable DatagramSocket throws SocketException
  native send ::  Mutable RealWorld DatagramSocket -> MutableIO DatagramPacket -> IO () throws IOException
  native close :: MutableIO DatagramSocket -> IO ()    

data SocketException = native java.net.SocketException
derive Exceptional SocketException   

main _ = do
  messageStr = "hello world;\n"
  messageAsBytes <- StringAsBytes.getBytes messageStr
  address <- InetSocketAddress.new "localhost" 3003
  messageLen <- messageAsBytes.getLength
  packet <- DatagramPacket.new messageAsBytes messageLen address
  socket <- DatagramSocket.new ()
  socket.send packet
  socket.close

这段代码意外运行，但它让我想到了一些事情。首先，应该是一种DatagramSocket.new来反映抛出异常的事实？我试图将它打包到Maybe但它最终陷入了混乱。有什么办法吗？目前，我不知道如何处理main中的例外情况，this没有完全解决它或者我错过了什么。其次，为什么我被编译器强迫将InetSocketAddress从pure更改为不纯，在DatagramSocket.new中使用它？我还被迫在代码中需要的任何地方使用JArray的可变版本。

Answer 1

首先：你可以将函数（方法）的结果包装成Either，例如：native fn :: A -> Either SomeException B或加糖版本：native fn :: (SomeException | B)。

其次：弗雷格值是不可变的。如果你有一些在Frege中定义的数据类型A，它是不可变的。您可以包装一些Java类型，对于不可变的，您可以标记它们pure：data D = pure native com.acme.D。 InetSocketAddress未声明为pure。这意味着ImmutableSocketAddress可以被任何其他线程在任何时间更改（例如关闭套接字）。因此，Frege编译器将其标记为Mutable。您可以将此类数据传递给仅包含Mutable污点的Java函数。您可以在Frege中编写一个不需要Mutable污染的函数，但要传递一个参数，您需要使用一些readonly或Freezable来摆脱{{1 }}

Answer 2

关于例外：有两种管理例外的方法。

第一种方法是将返回类型包装在Either中。这将为您提供Right中所需的值以及Left发生时的例外情况。要处理异常，通常使用模式匹配或either函数。不幸的是，在IO代码中（就像你的情况一样），这将导致像

这样的代码

do
   r1 <- Socket.new ...
   case r1 of
      Left -> -- handle exception
      Right x -> do
           r2 -> x.send ....
           case r2 of
              ....

哪个不太好看。因此，Either样式是纯函数的首选，而对于IO / ST动作，则首选其他样式。

为此，请使用throws ...子句声明您的原生函数，就像您已为send和new所做的那样。然后，异常感知的IO / ST操作如下所示：

foo = do
          s <- Socket.new
          d <- s.send ....
          ...
   `catch` (\x1::SocketException -> ...)
   `catch` (\x2::IOException -> ....)
   ....
   `finally` finallyaction

您可能需要尽可能多的catch es，但请务必对它们进行排序，以便最具体的一个出现在不太具体的一个之前，即如果ExceptionDerive扩展了ExceptionSuper，则必须发生ExceptionDerived的catch在另一个之前。 finally子句是可选的。请注意，您无法访问catch子句和finally子句中do块中绑定的变量。如果需要，需要在较低级别进行异常处理（即某些变量绑定到您需要的值）。

请查看catch，最后在frege doc或Froogle上查找。

确保catch缩进少，而不是执行守卫中的代码。这是为了确保编译器看到：

 do { .... } `catch` handler

您也可以在不关心异常的情况下编写代码，并在以后添加它们。例如，您从：

开始

 action1 a b c = do 
       dothis a
       dothat b
       dosomethingelse c
       pure whatyouwant

稍后，您可以将action1重命名为action1noex并写入

action1 a b c = action1noex a b c
      `catch`   ....

第二点。对于只能在IO Monad中使用的数据类型，建议将它们声明为

data Socket = mutable native java......

这样就可以简单地编写Socket而不是Mutable s Socket或Mutable RealWorld Socket，因为编译器知道这样的值总是可变的。您只能在具有IO结果的本机函数中使用此类型。

相反，对于刚刚构建但从不以不纯的方式使用的数据类型，您可以将它们定义为pure native。

我不确定InetSockAddress，但我猜它一旦构建就不会被修改？

同样，rgd。字节数组。如果你总是只想要将它转换为字符串，那么它可以被视为utf8文本类型（遗憾的是我们在库中还没有）。这看起来像

data Charset = pure native java.nio.charset.Charset
pure native utf8 "java.nio.charset.StandardCharsets.UTF_8" :: Charset
data Bytes = pure native "byte[]" 
pure native getBytes :: String -> Charset -> Bytes
pure native getString new :: Bytes -> Charset -> String
toBytes s = getBytes s utf8
fromBytes bs = getString bs utf8

（未经测试，请暂时忽略有关byte[]的警告）

什么是在Frege中抛出异常的本机构造函数？

2 个答案: