Function Clojure简单排序函数错误

我是clojure的新手，我尝试创建将对集合进行排序的函数，并将其存储在对象中

我的代码：

(defn uniq [ilist]
  ([] [])
  (def sorted (sort ilist))) 

我尝试运行它：

(uniq '(1,2,3,6,1,2,3))

但是得到错误：

#<CompilerException java.lang.IllegalArgumentException: Key must be integer (NO_SOURCE_FILE:0)>

#

怎么了

---

谢谢。

要将已排序的集合存储到变量中，请执行以下操作：

要理解let和def之间的区别

---

您只能在let的范围内使用let生成的词法绑定（开始和结束参数）。让我们创建一组词汇绑定。def和让我们做几乎相同的事情。我使用def进行全局绑定，使用let绑定我只想在let范围内绑定的东西，因为它可以保持内容的整洁。它们都有各自的用途。

要将已排序的集合存储到变量中，请执行以下操作：

要理解let和def之间的区别

您只能在let的范围内使用let生成的词法绑定（开始和结束参数）。让我们创建一组词汇绑定。def和让我们做几乎相同的事情。我使用def进行全局绑定，使用let绑定我只想在let范围内绑定的东西，因为它可以保持内容的整洁。它们都有各自的用途。

与您的一样，您尝试在不适用的地方使用模式匹配。如果您完全删除

（[]]）

，您的函数将正常工作

1您也不应该在此处使用

def

；正如其他受访者所指出的，您希望使用

let

来建立本地绑定。但是，这里您根本不需要任何绑定：只需返回

sort

调用的结果即可。事实上，

def

将导致您返回一个Var，而不是实际的排序列表。

与您的一样，您尝试在不适用的地方使用模式匹配。如果您完全删除

（[]]）

，您的函数将正常工作

---

1您也不应该在此处使用

def

；正如其他受访者所指出的，您希望使用

let

来建立本地绑定。但是，这里您根本不需要任何绑定：只需返回

sort

调用的结果即可。事实上，

def

将导致您返回一个Var，而不是实际的排序列表。

由于根本不需要使用“let”或“def”，我必须同意amalloy关于Bart J的回答。当然，这保证了投票，因为这是有用的信息，但这不是正确的答案

实际上，定义函数是没有用的，因为（sort-ilist）就可以做到这一点。函数的结果就是您想要的“对象”。也就是说，除非您希望在函数体的不同位置多次使用排序结果。在这种情况下，将sort的结果绑定到函数局部变量

如果您只需要一次排序，那么根本不必绑定它，只需将它嵌套在其他函数中即可。例如，如果您想在一个独特的函数中使用它（我猜这就是您想要做的）：

同样，您也可以使用内置的distinct函数，并查看其源代码：

(distinct '(1,2,3,6,1,2,3))
(1 2 3 6)

(source distinct)
(defn distinct
  "Returns a lazy sequence of the elements of coll with duplicates removed"
  {:added "1.0"}
  [coll]
    (let [step (fn step [xs seen]
                   (lazy-seq
                    ((fn [[f :as xs] seen]
                      (when-let [s (seq xs)]
                        (if (contains? seen f) 
                          (recur (rest s) seen)
                          (cons f (step (rest s) (conj seen f))))))
                     xs seen)))]
      (step coll #{})))

---

由于根本不需要使用“let”或“def”，我必须同意amalloy关于Bart J的回答。当然，这保证了投票，因为这是有用的信息，但这不是正确的答案

实际上，定义函数是没有用的，因为（sort-ilist）就可以做到这一点。函数的结果就是您想要的“对象”。也就是说，除非您希望在函数体的不同位置多次使用排序结果。在这种情况下，将sort的结果绑定到函数局部变量

如果您只需要一次排序，那么根本不必绑定它，只需将它嵌套在其他函数中即可。例如，如果您想在一个独特的函数中使用它（我猜这就是您想要做的）：

同样，您也可以使用内置的distinct函数，并查看其源代码：

(distinct '(1,2,3,6,1,2,3))
(1 2 3 6)

(source distinct)
(defn distinct
  "Returns a lazy sequence of the elements of coll with duplicates removed"
  {:added "1.0"}
  [coll]
    (let [step (fn step [xs seen]
                   (lazy-seq
                    ((fn [[f :as xs] seen]
                      (when-let [s (seq xs)]
                        (if (contains? seen f) 
                          (recur (rest s) seen)
                          (cons f (step (rest s) (conj seen f))))))
                     xs seen)))]
      (step coll #{})))

---

您想要什么输出？集合的唯一元素？要存储和返回变量，请使用let。您应该这样做：（让[sorted（sort list elements）]排序）在您的函数中，您想要什么输出？集合的唯一元素？要存储和返回变量，请使用let。您应该这样做：（让[sorted（sort list elements）]排序）在您的函数中为什么每个人都忽略show stopping语法错误，而关注一个重要但微妙的细节？如果他的代码在到达之前抛出异常，他就无法了解使用“local”

def

s的坏处。我不能删除我的答案，因为它已被接受。为什么每个人都忽略了show stopping语法错误，而关注一个重要但微妙的细节呢？如果他的代码在到达之前抛出异常，他就无法了解使用“local”

def

s的坏处。我不能删除我的答案，因为它已被接受。因此，将其改为“社区维基”。+1对你和amalloy来说，这基本上是一个巨大的问题：这里有无数的“答案”根本不是答案，它们不仅被接受，而且被投票支持。有80多张选票的答案是完全虚假的，而且看起来是“第一”的，尽管有真正正确的答案在后面，有数百张选票。整个“接受答案”和“接受答案的因果报应”（顺便说一句，我不是在说“Bart J”，我是在说非常简单的概念）完全被打破了。应该有赞成票和反对票，但没有“被接受的答案”的概念。对你和amalloy来说，这基本上是一个巨大的问题：这里有无数的“答案”根本不是答案，它们仍然不仅被接受，而且还被投了赞成票。有80多票的答案是完全虚假的，而且看起来是“第一”的，尽管在更远的地方有真正正确的答案，比如洪德

(distinct '(1,2,3,6,1,2,3))
(1 2 3 6)

(source distinct)
(defn distinct
  "Returns a lazy sequence of the elements of coll with duplicates removed"
  {:added "1.0"}
  [coll]
    (let [step (fn step [xs seen]
                   (lazy-seq
                    ((fn [[f :as xs] seen]
                      (when-let [s (seq xs)]
                        (if (contains? seen f) 
                          (recur (rest s) seen)
                          (cons f (step (rest s) (conj seen f))))))
                     xs seen)))]
      (step coll #{})))