2024 Clojure状态调查!中分享您的想法。

欢迎!请参阅关于页面以获取有关此功能的一些更多信息。

+57
Java 互操作
已关闭

将基线移至Java 8使我们能够考虑与关键java.util.Function接口(如Function、Predicate、Supplier等)的内建绑定。需要评估用户可以实现什么,以及自动集成会开启哪些可能性。

https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

备注: 发布于Clojure 1.12.0-alpha12
为什么我们到了2023年还没有任何关于何时实施或解决这个问题的官方回应?
我们已经对这个问题断断续续地关注了好几个版本,有许多方面和多个进行的方案,其中一些我们已经为它们创建了原型,但我们还没有决定要做什么。它在我们1.12的范围内。

13 个答案

+4
by

这是用Java编写的Kafka Streams应用程序的样子

      sb.table("input", Consumed.with(sl, sl))
            .groupBy((k, v) -> KeyValue.pair(k / 10, v), Grouped.with(sl, sl))
            .aggregate(() -> 0L,
                    (k, v, acc) -> acc + v,
                    (k, v, acc) -> acc - v,
                    Materialized.with(sl, sl))
            .toStream()
            .to("output", Produced.with(sl, sl));

相同的应用程序用Clojure编写的样子是这样的

    (-> sb
        (.table "input" (topic->consumed data-in))
        (.groupBy (key-value-mapper
                    (fn [k v] (KeyValue/pair (long (/ k 10)) v)))
                (serdes->grouped "groupie" data-in))
        (.aggregate (reify Initializer
                    (apply [_] 0))
                    (reify Aggregator
                    (apply [_ k v acc]
                        (+ acc v)))
                    (reify Aggregator
                    (apply [_ k v acc]
                        (- acc v)))
                    (serdes->materialised ...))
        (.toStream)
        (.to "output" (topic->produced data-out)))

如果我们能够在期望SAM类型的地方使用Lambdas,我们可以这样做

    (-> sb
        (.table "input" (topic->consumed data-in))
        (.groupBy (fn [k v] (KeyValue/pair (long (/ k 10)) v))
                (serdes->grouped "groupie" data-in))
        (.aggregate (constantly 0)
                    (fn [k v acc] (+ acc v))
                    (fn [k v acc] (- acc v))
                    (serdes->materialised ...))
        (.toStream)
        (.to "output" (topic->produced data-out)))
by
恭喜你,感谢你将此功能实现于Clojure 1.12
https://clojure.atlassian.net/browse/CLJ-2799
+3
by

评论者:jwhitlark

如果我在需要java.util.function.*的地方可以使用IFn,那将是非常棒的!

+2
by

评论者:marctrem

以Java 8作为基本线,我们可以使用默认的接口方法。

some-java-fns-interface.patch补丁实现了IFn上的Consumer、Function、Predicate和Supplier。

如果您想走这条路,我将非常乐意在IFn上实现java.util.function下的所有接口以及相关的测试。我目前正在使用这段代码通过Java客户端来玩转FoundationDB,它对我工作得很好。

https://github.com/marctrem/clojure/commit/97742493f674edd8f6c034ee94da84fa62a76bad

+2

有人制作了一个补丁来解决这个问题,这是目前为止我看到过的最佳解决方案,简单来说,它正好做了 Java 对 lambda 的所做之事,但这是针对 Clojure FN 的。

https://clojure.atlassian.net/plugins/servlet/mobile?originPath=/browse/CLJ-2637#issue/CLJ-2637

我们最好为 CLJ-2637 分配一个“问题”,以免评论在这里因为两种方法而变得混乱。
+1 投票

刚刚发现这个问题,所以我想提供一些使用/上下文信息。

当与使用 CompletableFutureCompletionStage 编写的异步 Java 代码接口时,需要提供实现 FunctionConsumerBiFunction 等,的参数。

我正在使用这些宏

(defmacro as-function [f]
  `(reify java.util.function.Function
     (apply [this arg#]
       (~f arg#))))

(defmacro as-consumer [f]
  `(reify java.util.function.Consumer
     (accept [this arg#]
       (~f arg#))))

但这样很快就会变得麻烦,因为根据函数参数的不同,需要不同的变体。

java.util.function 定义了很多接口,但在我看来,我需要最常用的一些,特别是那些由 CompletionStageCompletableFuture 需要的。

此外,还需要一些基本的 Java 接口,如 java.util.Map。  为了最有效地使用并发哈希表,需要使用 compute、computeIfPresent、computeIfAbsent 方法 - (https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ConcurrentHashMap.html#compute-K-java.util.function.BiFunction-).
+1 投票

数据请求

除了 java.util.stream.Streamnew Thread(() -> doSomething(x)) 这样的现有 JDK API 的重定向之外,还有哪些是难以从 Clojure 中使用的 lambda/SAM 使用库的例子?

0 投票
_评论者:jwhitlark_


;; 我从一些实验性的 kafka streams 的 scratch 代码中挖掘出了这个。最初所有的 reify 都填充了 java 8 的 lambda。

;; 我会挖掘另一个使用 java.utils.funstion.* 中的内容的例子。

;; 这些部分是从一个 franzy 示例中提取的吗?

;; 注意,例如,
;; https://kafka.apache.org/0102/javadoc/org/apache/kafka/streams/kstream/Predicate.html
;; 与
;; https://docs.oracle.com/javase/8/docs/api/java/util/function/Predicate.html

(ns utils
  (:import (org.apache.kafka.streams.kstream Reducer KeyValueMapper ValueMapper Predicate))

(defmacro reducer [kv & body]
  `(reify Reducer
     (apply [_# ~(first kv) ~(second kv)]
       ~@body)))

;; public interface KeyValueMapper
;; apply(K key, V value)
(defmacro kv-mapper [kv & body]
  `(reify KeyValueMapper
     (apply [_# ~(first kv) ~(second kv)]
       ~@body)))

;; public interface ValueMapper
;; apply(V1 value)
(defmacro v-mapper [v & body]
  `(reify ValueMapper
     (apply [_# ~v]
       ~@body)))

(defmacro pred [kv & body]
  `(reify Predicate
     (test [_# ~(first kv) ~(second kv)]
       ~@body)))

;; 我是这样使用的

(ns our-service.kafka-streams
  (:require
   [our-service.util :as k]
   [clojure.string :as str]
  (:import
           (org.apache.kafka.streams StreamsConfig KafkaStreams KeyValue)
           (org.apache.kafka.streams.kstream KStreamBuilder ValueMapper)))

(defn create-word-count-topology []
  (let [builder (KStreamBuilder.)
        init-stream (.stream builder (into-array ["streams-str-input"]))
        wc (-> init-stream
            (.flatMapValues (k/v-mapper [& value]
                                           `(str/split (apply str value) #"\s")))
            (.map (k/kv-mapper [k v]
                               (KeyValue/pair v v)))
            (.filter (k/pred [k v]
                             (println v)
                             (not= v "the")))
            (.groupByKey)
            (.count "CountStore")
            显示项目
            此行需要映射值
            (.mapValues (实现 ValueMapper
                          应用 [_ v]
                            (println v)
                            (str v))))
            (.toStream)
            (.to "wordcount-output"))]
    [builder wc]))
0 投票

评论者:gshayban

JLS通过搜索匹配的功能接口,即所谓的“单抽象方法”类(链接:1)来推断lambda类型(无论是接口还是抽象类)。我们可以有一个类似reify的辅助函数来检测这些类(链接:2)。您需要指定目标类。我们并不真正需要同时是IFn和j.u.f.Predicate等的类。

`
(导入'[java.util.function Predicate Consumer]))

(让 [1 2 3] = orig)

  st (atom [])]

(.forEach orig (jfn Consumer [x] (swap! st conj x)))
(= @st orig))
`

(链接:1) https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html#jls-9.8
(链接:2) spike https://gist.github.com/ghadishayban/0ac41e81d4df02ff176c22d16ee8b972

0 投票

评论者:jwhitlark

这将是改进。我在实践中遇到的实际问题是,我经常在流式接口中,不一定知道确切的类。话虽如此,这通常只在几个地方。是否应该有一个注册表?也许像这样

(自动推断lambda (链接:java.util.function, org.apache.kafka.streams.kstream))

0 投票

评论者:gshayban

您是否曾经使用过抽象类而不是接口的SAM类?

0 投票

评论者:ajoberstar

这里是我的库中的一种替代方法(链接:https://github.com/ajoberstar/ike.cljj/blob/master/src/main/clojure/ike/cljj/function.clj 文本:ike.cljj)。它使用MethodHandles(即java.lang.invoke包)而不是常规反射。我不确定是否在抽象类上测试过这种方法。

用法看起来与Ghadi发布的类似

`
(defsam my-sam
java.util.function.Predicate
[x]
(= x "it matched"))

(-> (Stream/of "not a match" "it matched")

(.filter my-sam)
(.collect Collectors/toList)

(-> (IntStream/range 0 10)

(.filter (sam* java.util.function.IntPredicate odd?))
(.collect Collectors/toList)

`

它使用(链接:https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandleProxies.html#asInterfaceInstance-java.lang.Class-java.lang.invoke.MethodHandle- 文本:MethodHandleProxies.asInterfaceInstance)来创建一个代理实例的接口,该接口调用一个调用Clojure函数的方法处理器。它不尝试验证参数数量,而是将参数作为可变参数委托给IFn.applyTo(ISeq)。不确定这是否是最高效的,但对我来说是有效的。

我认为(链接:https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/invoke/MethodHandles.html 文本:LambdaMetaFactory)可能是满足此类用例的首选方式。但对我来说,要确切地了解如何使用它比较困难,所以最终没有深入研究。

我的方法(以及Ghadi的)的主要功能问题是必须显式提供要代理的接口。Java的lambdas和Groovy的Closures可以对需要SAM的函数使用,并且可以根据方法期望的内容对其进行骄化。理想情况下,Clojure也应该支持这一点。

而不是这样做

`
(-> (IntStream/range 0 10)

(.filter (sam* java.util.function.IntPredicate odd?))
(.collect Collectors/toList)

`

我想这样做

`
(-> (IntStream/range 0 10)

(.filter odd?)
(.collect Collectors/toList)

`

0 投票
by

评论者:gshayban

另一个可能的方法是将java.util.function.Supplier扩展到Clojure函数,带有显式的0个参数。这个接口在实践中越来越普遍;这可能是一个值得特殊处理的情况。(我们不应该(也无法)对defrecords做类似的事情,因为它们已经有了一个名为get的方法,这会与Supplier的唯一方法冲突。)

0 投票
by
参考: https://clojure.atlassian.net/browse/CLJ-2365(由alexmiller报告)
...