小编Rul*_*lle的帖子

我使用一个实例化另一个匿名类的方法实例化一个匿名类,并且从这个内部匿名类我想调用一个属于外部匿名类的方法.为了说明它,假设我有这个界面:

interface ReturnsANumber {
    int getIt();
}

然后,在我的代码中的某个地方,我这样做:

    ReturnsANumber v = new ReturnsANumber() {
            int theNumber() {
                return 119;
            }

            public int getIt() {

                // In a modern version of Java, maybe I could do
                //   var a = this;
                // and then call a.theNumber();

                ReturnsANumber w = new ReturnsANumber() {
                        int theNumber() {
                            return 1;
                        }

                        public int getIt() {
                            return this.theNumber();
                        }
                    };

                return w.getIt();
            }
        };
    System.out.println("The number is " + v.getIt());

问题: 在最里面的方法中getIt,我想调用theNumber() …

我有一个 Python3 Poetry 项目，其中有一个pyproject.toml指定依赖项的文件：

[tool.poetry.dependencies]
python = "^3.10"
nltk = "^3.7"
numpy = "^1.23.4"
scipy = "^1.9.3"
scikit-learn = "^1.1.3"
joblib = "^1.2.0"

[tool.poetry.dev-dependencies]
pytest = "^5.2"

我requirements.txt使用命令将这些依赖项导出到文件中poetry export --without-hashes -f requirements.txt --output requirements.txt，生成以下文件requirements.txt：

click==8.1.3 ; python_version >= "3.10" and python_version < "4.0"
colorama==0.4.6 ; python_version >= "3.10" and python_version < "4.0" and platform_system == "Windows"
joblib==1.2.0 ; python_version >= "3.10" and python_version < "4.0"
nltk==3.8.1 ; python_version >= "3.10" and python_version …

我正在计算 Clojure 中 3d 点云的边界框。点云表示为 Java 原始浮点数组，点云中的每个点都使用 4 个浮点存储，其中最后一个浮点未使用。像这样：

[x0 y0 z0 u0  x1 y1 z1 u1 .... ]

点云的大小为 19200，即数组中的 4*19200 个浮点数。

其中一些值可能不是有限的（它们是无限的或 NaN）。因此，任何包含非有限值的点都应完全排除在计算之外。我已经在 J​​ava 和 Clojure 中实现了这个计算，但是出于某种原因，Clojure 版本仍然慢了大约 4 到 5 倍。

这是 Clojure 代码的样子：

(defn good-compute-bbox [^floats data]
  (let [n (alength data)]
    (loop [i (int 0)
           minx (float (aget data 0))
           maxx (float (aget data 0))
           miny (float (aget data 1))
           maxy (float (aget data 1))
           minz (float (aget data 2))
           maxz (float (aget data 2))]
      (if …

我正在使用clojure.spec解析 DSL。不幸的是，测试是否符合我的规范的计算时间似乎呈指数增长。我想了解原因，以及如何解决。

这是规范的样子：

(spec/def ::settings map?)

(spec/def ::header (spec/spec
                    (spec/cat :prefix #{:begin-example}
                              :label string?
                              :settings (spec/? ::settings))))

(def end-block [:end-example])

(spec/def ::not-end (partial not= end-block))

(spec/def ::end #{end-block})

(spec/def ::block (spec/cat
                   :header ::header
                   :data (spec/* ::not-end)
                   :suffix ::end))

(spec/def ::form (spec/alt :block ::block
                           :form any?))

(spec/def ::forms (spec/* ::form))

为了执行规范，我编写了一个小函数，为规范生成有效数据，并编写了一个大小参数来控制数据的大小：

(defn make-sample-data [size]
  (transduce
   (comp (take size)
         cat)
   conj
   []
   (repeat [:a 1 :b :c [:begin-example "a" {:indent 4}] :d :e [:end-example] 9])))

(make-sample-data 1)
;; …

我想要一个宏this-ns，以便它返回被调用位置的名称空间。例如，如果我有这个代码

(ns nstest.main
  (:require [nstest.core :as nstest]))

(defn ns-str [x]
  (-> x (.getName) name))

(defn -main [& args]
  (println "The ns according to *ns*:" (ns-str *ns*))
  (println "The actual ns:" (ns-str (nstest/this-ns))))

我希望调用lein run会产生这个输出：

The ns according to *ns*: user
The actual ns: nstest.main

我想出的实现是以下代码：

(ns nstest.core)

(defmacro this-ns []
  (let [s (gensym)]
    `(do (def ~s)
         (-> (var ~s)
             (.ns)))))

它似乎确实有效，但感觉非常hacky。值得注意的是，在上面的例子中，它会扩展到在函数内部def调用，感觉不是很干净。-main