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类型的地方使用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)))
恭喜您实现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为lambdas所做的所有事情,但它是为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.util.Map 这样的基本 Java 接口。为了最有效地使用并发哈希表,您需要使用 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 的重铸,例如 new Thread(() -> doSomething(x)),还有哪些 lambda/SAM 使用库在 Clojure 中难以使用?

0
_评论由:jwhitlark_ 提供


;; 从一些 kafka streams 的实验代码中挖出来的。最初的 reify 中都填充了 java8 lambda。

;; 我会找出另一个使用 java.utils.funstion.* 实例的例子。

;; 以下部分是从 franzey 的例子或其他东西中提取出来的?

;; 例如,请注意
;; 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 []
  (创建一个 [builder (KStreamBuilder.)
        初始化流 (.stream builder (数组 ["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)。您需要指定目标类。我们不需要既是 IFn 又是 j.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))
`

(链接:1) https://docs.oracle.com/javase/specs/jls/se8/html/jls-9.html#jls-9.8
(链接:2) 针锋《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 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

评论由:gshayban

另一个可能的方法是将java.util.function.Supplier扩展到Clojure函数,具有明确的0个参数。在实际操作中,该接口正变得越来越普遍;这可能是一个值得特殊处理的例子。》(由于defrecords已经有一个名为get的方法,与Supplier的唯一方法相冲突,我们不应该也无法做类似的事情。)

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