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

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 未声明 [=13=]。这意味着 ImmutableSocketAddress 可以在任何时间的任何地方被其他线程更改（例如关闭套接字）。所以 Frege 编译器将其标记为 Mutable。您可以将此类数据传递给仅用 Mutable 污点包裹的 Java 函数。你可以在 Frege 中编写一个不需要 Mutable 污点的函数，但是要向它传递一个参数，你需要使用一些 readonly 或 Freezable 来摆脱 Mutable .

Answer 2

关于异常：有两种管理异常的方法。

第一种方法是将 return 类型包装在 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 个，但请确保对它们进行排序，以便最具体的出现在不太具体的之前，即如果 ExceptionDerive 扩展了 ExceptionSuper，则捕获 ExceptionDerived必须发生在另一个之前。 finally 子句是可选的。请注意，无论是在 catch 子句中还是在 finally 子句中，您都无法访问 do 块中绑定的变量。如果你需要这个，你需要在较低级别上进行异常处理（即，某些变量绑定到你需要的值）。

请在 frege 文档或 Froogle 上查找 catch 和 finally。

确保 catch 比它保护的 do 中的代码缩进少。这是为了确保编译器看到：

 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 中抛出异常的本机构造函数的类型是什么？

What is type of native constructor which throws exception in Frege?

frege