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

这是用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类型的Lambda处使用,可以写成这样

    (-> 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)))
恭喜,感谢您在Clojure 1.12中实现了这一功能
https://clojure.atlassian.net/browse/CLJ-2799
+3

评论者:jwhitlark

如果可以在需要使用java.util.function.*的地方使用IFn,那就太棒了!

+2

评论者: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

Oops,我们最好为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
by

数据请求

抛开java.util.stream.Stream和现有的JDK API重构,如new Thread(() -> doSomething(x)),有什么是使用lambda/SAM库时在Clojure中感觉不适的例子?

0
by
_评论者:jwhitlark_


;; 我从一些实验kafka streams的临时代码中找到了这个。原始代码中所有的reify都使用了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"))]
    [builder wc]))
0

评论者:gshayban

JLS 通过寻找相匹配的功能接口,即所谓的“单抽象方法”类(链接:1)(无论是接口还是抽象类)来推断 lambda 类型。我们可以有一个类似 reify 的辅助函数来检测这些类(链接:2)。您需要提示目标类。我们真的不需要同时具备 IFnj.u.f.Predicate 等功能的东西。

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

(let [orig [1 2 3]

  st (atom [])]

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

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

0

评论者:jwhitlark

嗯,这将是一个改进。我遇到的实际问题是,我经常深入流畅接口,不一定知道确切的类。话虽如此,通常只在几个地方。有一个登记册有意义吗?或许类似这样的东西

(auto-infer-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函数。它不尝试验证参数数量,只是将其视为varargs并将其委托给IFn.applyTo(ISeq)。不确定这是否是最有效的方法,但对我来说已经足够有效。

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

我的方法(以及Ghadi的)的主要功能性问题是您必须显式提供要代理的接口。Java lambda和Groovy closure可以用作期望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扩展到具有显式0个参数的Clojure函数。在实际应用中,该接口变得越来越普遍;它可能值得特别对待。(我们不应也不能为defrecords做同样的事情,因为它们已经有了与Supplier的get方法冲突的get方法。)

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