我用谷歌搜索并得到一些答案，Java 和 Haskell 之间的通信可以通过 GCJNI（现在站点已关闭）和 LambdaVM 来完成。要使用 LambdaVM/GCJNI，我是否需要下载任何构建工具？我在哪里可以了解更多关于它们的信息，因为我在网上找不到太多资源？
我想开发一个在 Java 和 Haskell 之间进行通信的应用程序（我将从 Java 获取输入并将其传递给 Haskell 并在那里处理并将结果返回给 Java）。这就是我想要做的。请帮帮我...
【问题讨论】：
标签： java haskell java-native-interface
Calling Haskell from C 看起来很简单，因此也可以使用JavaCPP 从 Java 中轻松调用。例如，调用示例代码Safe.hs中的fibonacci_hs()函数：
{-# LANGUAGE ForeignFunctionInterface #-}
module Safe where
import Foreign.C.Types
fibonacci :: Int -> Int
fibonacci n = fibs !! n
where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
fibonacci_hs :: CInt -> CInt
fibonacci_hs = fromIntegral . fibonacci . fromIntegral
foreign export ccall fibonacci_hs :: CInt -> CInt
我们可以在 Java 中这样做：
import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;
@Platform(include={"<HsFFI.h>","Safe_stub.h"})
public class Safe {
static { Loader.load(); }
public static native void hs_init(int[] argc, @Cast("char***") @ByPtrPtr PointerPointer argv);
public static native int fibonacci_hs(int i);
public static void main(String[] args) {
hs_init(null, null);
int i = fibonacci_hs(42);
System.out.println("Fibonacci: " + i);
}
}
在Linux下，编译过程如下：
$ ghc -fPIC -dynamic -c -O Safe.hs
$ javac -cp javacpp.jar Safe.java
$ java -jar javacpp.jar -Dplatform.compiler=ghc -Dplatform.compiler.output="-optc-O3 -Wall Safe.o -dynamic -fPIC -shared -lstdc++ -lHSrts-ghc7.6.3 -o " -Dplatform.linkpath.prefix2="-optl -Wl,-rpath," Safe
并且程序使用通常的java命令正常运行：
$ java -cp javacpp.jar:. Safe
Fibonacci: 267914296
Safe.h：
inline int fibonacci_c(int n) {
return n < 2 ? n : fibonacci_c(n - 1) + fibonacci_c(n - 2);
}
以下 Java 类：
import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;
@Platform(include={"<HsFFI.h>","Safe_stub.h", "Safe.h"})
public class Safe {
static { Loader.load(); }
public static native void hs_init(int[] argc, @Cast("char***") @ByPtrPtr PointerPointer argv);
public static native int fibonacci_hs(int i);
public static native int fibonacci_c(int n);
public static int fibonacci(int n) {
return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
}
public static void main(String[] args) {
hs_init(null, null);
for (int i = 0; i < 1000000; i++) {
fibonacci_hs(0);
fibonacci_c(0);
fibonacci(0);
}
long t1 = System.nanoTime();
for (int i = 0; i < 1000000; i++) {
fibonacci_hs(0);
}
long t2 = System.nanoTime();
for (int i = 0; i < 1000000; i++) {
fibonacci_c(0);
}
long t3 = System.nanoTime();
for (int i = 0; i < 1000000; i++) {
fibonacci(0);
}
long t4 = System.nanoTime();
System.out.println("fibonacci_hs(0): " + (t2 - t1)/1000000 + " ns");
System.out.println("fibonacci_c(0): " + (t3 - t2)/1000000 + " ns");
System.out.println("fibonacci(0): " + (t4 - t3)/1000000 + " ns");
}
}
使用 Intel Core i7-3632QM CPU @ 2.20GHz、Fedora 20 x86_64、GCC 4.8.3、GHC 7.6.3 和 OpenJDK 8 输出：
fibonacci_hs(0): 200 ns
fibonacci_c(0): 9 ns
fibonacci(0): 2 ns
平心而论，我应该提一下，将 调用到 JVM 也是相当昂贵的......
Main.hs 中放置以下代码：
{-# LANGUAGE ForeignFunctionInterface #-}
module Main where
import Foreign.C -- get the C types
import Foreign.Ptr (Ptr,nullPtr)
-- impure function
foreign import ccall "JavaCPP_init" c_javacpp_init :: CInt -> Ptr (Ptr CString) -> IO ()
javacpp_init :: IO ()
javacpp_init = c_javacpp_init 0 nullPtr
-- pure function
foreign import ccall "fibonacci" c_fibonacci :: CInt -> CInt
fibonacci :: Int -> Int
fibonacci i = fromIntegral (c_fibonacci (fromIntegral i))
main = do
javacpp_init
print $ fibonacci 42
还有一个 fibonacci 以这种方式在 Java 中定义的函数：
import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;
@Platform
public class Main {
public static class Fibonacci extends FunctionPointer {
public @Name("fibonacci") int call(int n) {
return n < 2 ? n : call(n - 1) + call(n - 2);
}
}
}
我们可以在 Linux x86_64 下构建类似的东西：
$ javac -cp javacpp.jar Main.java
$ java -jar javacpp.jar Main -header
$ ghc --make Main.hs linux-x86_64/libjniMain.so
程序正确执行并给出以下输出：
$ ./Main
267914296
【讨论】：
FunctionPointer)，Haskell FFI 也支持 C 函数指针 (FunPtr)，因此 Haskell 也可以通过这种方式调用 Java。如果您正在寻找类似的东西，请告诉我。
如果您选择 Haskell 服务器进程方法，您可以使用 MessagePack 序列化/rpc 库。它具有 Java 和 Haskell 的绑定，并且 Haskell 绑定似乎维护得很好。在 Hackage 上查找 msgpack 和 msgpack-rpc。
这是一个使用 MessagePack 进行 Java/Haskell 交互的玩具示例：Java server、Haskell client（链接到 GitHub）。但是，沟通的方向与您想要的相反。
【讨论】：
这取决于您希望他们如何交流。让 Java 和 Haskell 代码在同一个进程中本地运行并通过它们各自的 FFI 交换内存中的数据是一个巨大的问题，尤其是因为您有两个 GC 争夺数据，并且两个编译器都有自己的关于表示的想法各种数据类型。在 JVM 下编译 Haskell 也很困难，因为 JVM（目前）没有任何闭包的概念。
这些事情当然可以做到，但是从演示器到工业工具需要付出巨大的努力。我的理解是，您提到的工具从未通过演示阶段。
一个更简单但不那么优雅的解决方案是将您的 Haskell 程序编写为一个服务器进程，该进程通过 Java 的套接字发送数据。如果性能和容量不太高，那么用 JSON 编码可能会很简单，因为双方都有库来支持它。
【讨论】：
TL;DR：使用消息传递（即 RPC 客户端-服务器或对等方）模式。
为什么？它更安全、可扩展、灵活且可调试。调用 FFI 将是脆弱且难以测试的。
RPC 框架/规范
gRPC Google 的 Protobufs RPC over HTTP/2 的公共分支
msgpack-rpc 不包括传输。
zerorpc ZeroMQ + msgpack。只有 Python 和 Node 实现。似乎也被遗弃了。
XML-RPC 成熟。广泛的互操作性，但它也是 XML。
JSON-RPC 更易于调试。不是二进制协议，尽管 BSON 可能会侵入某些库。
序列化
Protocol Buffers (protobufs) 与其他工具相比，它有很多很多的工具。它支持不需要重新编译（或破坏）世界即可互操作的版本化/可选数据成员。
msgpack 可爱、简单、高效，但不支持向前兼容的架构更改。它纯粹是一个愚蠢的二进制编解码器。可能过于简单和低级，不适合实际使用。
交通
【讨论】：