如果函数可以是不同类型的，那么一元规则将如何应用

Question

我正在研究clojure和Scala之间的互操作。由于java本身现在有lambda，所以我想在数据和如何将函数应用到集合之间进行一个概括

• Clojure函数扩展了Clojure.lang.IFN并概括了Clojure.lang.ISEQ
上的集合操作
• Scala函数扩展了Scala.Function并概括了Scala.collection.Traversable
上的集合操作
• Java lambda扩展java.util.function.function并概括了java.util.stream.stream
上的集合操作

问题：

null

  (map (scala-fn +) 
       [1 2 3]
       (scala-seq [1 2 3]) 
       (.stream [1 2 3]))
  => (scala-seq [3 6 9])

Clojure、Scala和Java中都有这样的操作：获取集合、将函数应用到该集合并返回新的集合。

• 所有这些语言都运行在JVM上。
• 但是，每种语言都定义自己的类来表示函数。

我更熟悉clojure，所以有类似的操作：

 (into {} [[:a 1] [:b 2]]) => {:a 1 :b 2}

该功能看起来如下所示：

 (into {} (scala-list [:a 1] [:b 2])) => {:a 1 :b 2}

 (into (scala-map) [[:a 1] [:b 2]]) => (scala-map :a 1 :b 2)

 (concat (scala-list 1 2) [3 4]) => (scala-list 1 2 3 4)

 (concat [1 2] (scala-list 3 4)) => (1 2 3 4) ;lazy seq

 (map + [1 2] (scala-list 3 4)) => [4 6]

 (map (scala-fn +) [1 2] (scala-list 3 4)) => [4 6]

• 我需要的是在收集操作中同时使用clojure和scala函数的能力。
• 我可以在不使用单子的情况下做到这一点（通过检查集合和函数类型，并在函数应用之前进行一些强制操作）
• 我在这里问的问题对我来说有点好奇心，因为我读过的关于单子的所有文献似乎都假定任何函数f:x->y都是通用的。
• 但是，在clojure/scala/lambda互操作的情况下，clojure、scala函数和java lambda不是通用的。我很好奇范畴理论是如何用来解决这个问题的。

Answer 1

我只能给你哈斯克尔的答案，因为我不会说任何其他语言。然而，在我看来，您似乎主要是在寻找一种将输入自动转换为函数的方法。这似乎与单子无关。

(concat (scala-list 1 2) [3 4]) => (scala-list 1 2 3 4)

如果我把它翻译成Haskell，我会给它一个像这样的类型

concat :: (IsList l1, IsList l2) => l1 elem -> l2 elem -> [elem]

其中，ToList是一个类型类，它将把这个容器转换成一个列表

class IsListOf a where
    toList :: a elem -> [elem]

(map + [1 2] (scala-list 3 4)) => [4 6]

zipWith :: (IsList l1, IsList l2) => (a -> b -> c) -> l1 a -> l2 b -> [c]

zipWith :: (IsList l1, IsList l2, Is2Function f) => f a b c -> l1 a -> l2 b -> [c]

class Is2Function f where
    toFunction :: f a b c -> a -> b -> c