与java.util.function接口集成

Question

将基础版本移动到Java 8使我们能够考虑内置的与关键java.util.Function接口（如Function、Predicate、Supplier等）的联系。需要评估可能的范围以及将为用户提供的自动集成。

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

Comments

为什么我们在2023年还没有任何关于何时实施或处理此问题的官方回应？

---

我们已经断断续续地考虑了这个问题好几个版本了。它有很多方面和一些进行下去的选项，其中一些我们已经为原型创建了，但我们还没有决定要做什么。它在我们的1.12范围列表中。

Answer 1

这是用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)))

Comments

恭喜并感谢你将这个功能实现在Clojure 1.12中
https://clojure.atlassian.net/browse/CLJ-2799

Answer 2

由：jwhitlark发表的评论

如果我只在需要java.util.function.*的地方使用IFn会太棒了！

Comments

这个补丁似乎做到了这一点：https://clojure.atlassian.net/plugins/servlet/mobile?originPath=%2Fbrowse%2FCLJ-2637#issue/CLJ-2637

Answer 3

由：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

Answer 4

有人做了一个补丁，以我迄今为止看到的最优方式解决了这个问题，它简单地做了 Java 对 lambda 做的事情，但对于 Clojure FN 也做了同样的处理。

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

Comments

糟糕，我们最好为 CLJ-2637 分配一个 "问题"，以免这里的评论在这两种方法之间全部纠缠在一起。

Answer 5

刚遇到这个问题，我想提供一些用法/上下文信息。

在与使用 CompletableFuture 和 CompletionStage 编写的异步 Java 代码进行接口交互时，需要提供实现 Function、Consumer、BiFunction 以及其他类型的参数。

我使用这些宏

(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 定义了许多接口，但从我的（有限的）观点来看，我需要最常见的那些，尤其是那些由 CompletionStage 和 CompletableFuture 所需要的。

Comments

此外，还有基本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-）。

Answer 6

数据请求

除了java.util.stream.Stream，和现有的JDK API的retrofit版如new Thread(() -> doSomething(x))，还有哪些lambda/SAM使用库在Clojure中使用起来有些棘手？

Answer 7

_评论者：jwhitlark_


;; 我从一个名叫kafka streams的实验性代码中找到了这个。原著里全是没有原型的java8 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
            （.mapValues (reify ValueMapper
                          (apply [_ v]
                            (println v)
                            (str v))))
            （.toStream）
            （.to "wordcount-output"）】）
[构造函数 wc]）

Answer 8

评论者：gshayban

Java语言规范（JLS）通过寻找匹配的功能接口（即名为“单个抽象方法”的类）来推断lambda类型（链接：1）（无论这些是接口还是抽象类）。我们可以有一个类似于reify的帮助器来检测这些类（链接：2）。您需要提示目标类。我们并不真的需要同时是IFn和j.u.f.Predicate等的东西。

`
（导入 '[java.util.function Predicate Consumer]）

（let [orig [1 2 3]）

  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

Answer 9

由：jwhitlark发表的评论

嗯，这将是一个改进。我在实际应用中遇到的问题是我经常陷入流畅接口，并不一定知道确切的类。话说回来，这通常只在几个地方。是否有一个注册表会有帮助？也许像这样

（auto-infer-lambda (链接：java.util.function, org.apache.kafka.streams.kstream)）

Answer 10

评论者：gshayban

你是否使用过那些是抽象类而不是接口的SAM类？

Answer 11

评论者：ajoberstar

以下是在我（链接：[ike.cljj 库](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)

`

它使用（链接：[MethodHandleProxies.asInterfaceInstance](https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandleProxies.html#asInterfaceInstance-java.lang.Class-java.lang.invoke.MethodHandle-) 文本）来创建一个代理实例，该实例通过调用Clojure函数的方法句柄调用接口。它不尝试验证参数数量，只是将其视为varargs，委托给IFn.applyTo(ISeq)。不确定这是否是最有效的方式，但对我来说是有效的。

我认为（链接：[LambdaMetaFactory](https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/invoke/MethodHandles.html) 文本）可能是满足这类使用需求的最佳方式。但是，对我来说，跟随它确实更难，所以我最终没有深入研究它。

我对我的方法（以及Ghadi的方法）的主要功能问题是您必须显式提供要代理的接口。Java lambda和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)

`

Answer 12

评论者：gshayban

另一条可能的途径是将java.util.function.Supplier扩展到具有显式0个参数的Clojure函数。该接口在实践中的应用越来越广泛；它可能很有价值进行特别处理。（我们不应对defrecords做类似的事情，因为它们已经有了名为get的方法，这会与Supplier的唯一方法冲突。）

Answer 13

参考：[CLJ-2365](https://clojure.atlassian.net/browse/CLJ-2365)（由alexmiller报告）