当前位置：文江博客话题详情

用于测试“自我评估”的单个谓词Clojure 中的原子

发布于 2024-11-18 01:49:13 字数 389 浏览 2 评论 0原文

在 Clojure 的主页上，有以下声明：

字符串、数字、字符、true、 false、nil 和关键字的计算结果为他们自己。

是否有一个组合谓词可以测试其中的任何一个，组合 string?、number?、char?、true?< /code>、false?、nil? 和 keyword?。我应该只使用（补码吗？）吗？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

说好的呢 2024-11-25 01:49:13

也许我遗漏了一些东西，但您可以使用以下内容来测试任何这些条件，如果条件成立则返回 true：

(defn self-eval?
  [x]
  (or (string? x)
      (number? x)
      (char? x)
      (keyword? x)
      (true? x)
      (false? x)
      (nil? x)))

Maybe I'm missing something, but you could use the following to test for any of those conditions and return true if one is true:

(defn self-eval?
  [x]
  (or (string? x)
      (number? x)
      (char? x)
      (keyword? x)
      (true? x)
      (false? x)
      (nil? x)))

回复收藏 0 原文

微暖i 2024-11-25 01:49:13

编写一个询问“给定表达式的计算结果是否为自身”的宏是很容易的。事实上，这是只能使用宏完成的任务的一个很好的例子，因为它们需要查看已计算和未计算的参数。

(defmacro selfp [a] `(= ~a (quote ~a)))
#'user/selfp
user> (selfp 1)
true
user> (selfp +)
false
user> (selfp [1 2])
true
user> (selfp '(+ 1 2 3))
false

虽然字符串、数字、字符、关键字和布尔值都是自评估的，但其他诸如 [1 2] 之类的东西也是如此，所以这通常不是一个有用的测试。

It's easy enough to write a macro that asks "does the given expression evaluate to itself". In fact this is a good example of tasks that can only be done with a macro because they need to see the argument both evaluated and unevaluated.

(defmacro selfp [a] `(= ~a (quote ~a)))
#'user/selfp
user> (selfp 1)
true
user> (selfp +)
false
user> (selfp [1 2])
true
user> (selfp '(+ 1 2 3))
false

While strings, numbers, characters, keywords, and the booleans are all self-evaluating, other things such as [1 2] are as well,so this may not be a useful test in general.

回复收藏 0 原文

自由如风 2024-11-25 01:49:13

另一种选择是创建一个使用映射的函数：

(defn myclassifier? [x]
   (let [types-I-care-about #{java.lang.Sring ...}]
      (if (types-I-care-about (type x))
          true
          false)))

可能具有更好性能的另一种选择是使用 java 的动态性：

(extend-type Object
  IMyClassifier
  (myclassifier? [x]
            (let [c (.getClass x)]
             (if (types-I-care-about (type c))
               (do
                 (extend-type (.getClass x)
                   IMyClassifier
                   (myclassifier? [x] true))
                 true)
               false))))

其中 types-I-care-about 是您关心的一组类型。

Another option is to create a function that uses a map:

(defn myclassifier? [x]
   (let [types-I-care-about #{java.lang.Sring ...}]
      (if (types-I-care-about (type x))
          true
          false)))

Another option which may have better performance is to use java's dynamism:

(extend-type Object
  IMyClassifier
  (myclassifier? [x]
            (let [c (.getClass x)]
             (if (types-I-care-about (type c))
               (do
                 (extend-type (.getClass x)
                   IMyClassifier
                   (myclassifier? [x] true))
                 true)
               false))))

where types-I-care-about is a set of types you care about.

回复收藏 0 原文

~没有更多了~