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类型的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)))
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.Stream,以及现有的JDK API的retrofit,例如 new Thread(() -> doSomething(x)),还有哪些是用Clojure难以消费的lambda/SAM使用库的例子?

0
_评论者: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<K,V,R>
;; apply(K key, V value)
(defmacro kv-mapper [kv & body]
  `(reify KeyValueMapper
     (apply [_# ~(first kv) ~(second kv)]
       ~@body)))

;; public interface ValueMapper<V1,V2>
;; 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]
samtcompan
           (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")
            show-item
            ;; this needs to be mapValues
            (.mapValues (reify ValueMapper
                          (apply [_ v]
                            (println v))
                            (str v)))
            (.toStream)
            (.to "wordcount-output"))]
    [builder wc])
0
回答链接: by

评论者:gshayban

JLS 通过寻找匹配的功能接口(即 "具有单个抽象方法的" 类)来推断lambda类型(链接:1)(无论它们是接口还是抽象类)。我们可以有一个reify-like辅助工具来检测这些类(链接:2)。您需要提示目标类。我们并不真正需要同时是 IFnj.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

0
by

评论者:jwhitlark

嗯,这将是一种改进。我所遇到的实际问题是我通常深深地处在Fluid接口中,不一定知道确切的类。话虽如此,这通常只在几个地方。是否需要有一个注册表?也许像这样

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

0
by

评论者:gshayban

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

0
by

评论者: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 "它匹配了"))

(-> (Stream/of "不匹配" "它匹配了")

(.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 lambda和Groovy闭包可以针对期望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 报告)
...