铁锈与闭合速度的比较，对Clojure代码有什么改进吗？

Question

我将一段锈蚀代码示例翻译到Clojure。

Rust (命令式和函数式)：注意:为了清楚起见，这里的命令式代码和函数式代码都在一起。在测试中，我分别运行它们。

// The `AdditiveIterator` trait adds the `sum` method to iterators
use std::iter::AdditiveIterator;
use std::iter;  
    fn main() {
    println!("Find the sum of all the squared odd numbers under 1000");
    let upper = 1000u;

    // Imperative approach
    // Declare accumulator variable
    let mut acc = 0;
    // Iterate: 0, 1, 2, ... to infinity
    for n in iter::count(0u, 1) {
        // Square the number
        let n_squared = n * n;

        if n_squared >= upper {
            // Break loop if exceeded the upper limit
            break;
        } else if is_odd(n_squared) {
            // Accumulate value, if it's odd
            acc += n_squared;
        }
    }
    println!("imperative style: {}", acc);

    // Functional approach
    let sum_of_squared_odd_numbers =
        // All natural numbers
        iter::count(0u, 1).
        // Squared
        map(|n| n * n).
        // Below upper limit
        take_while(|&n| n < upper).
        // That are odd
        filter(|n| is_odd(*n)).
        // Sum them
        sum();
    println!("functional style: {}", sum_of_squared_odd_numbers);
}

fn is_odd(n: uint) -> bool {
    n % 2 == 1
}  

生锈(命令式)时间：

~/projects/rust_proj $> time ./hof_imperative 
Find the sum of all the squared odd numbers under 1000
imperative style: 5456

real    0m0.006s
user    0m0.001s
sys 0m0.004s

~/projects/rust_proj $> time ./hof_imperative 
Find the sum of all the squared odd numbers under 1000
imperative style: 5456

real    0m0.004s
user    0m0.000s
sys 0m0.004s

~/projects/rust_proj $> time ./hof_imperative 
Find the sum of all the squared odd numbers under 1000
imperative style: 5456

real    0m0.005s
user    0m0.004s
sys 0m0.001s

锈蚀(功能)时间：

~/projects/rust_proj $> time ./hof 
Find the sum of all the squared odd numbers under 1000
functional style: 5456

real    0m0.007s
user    0m0.001s
sys 0m0.004s

~/projects/rust_proj $> time ./hof 
Find the sum of all the squared odd numbers under 1000
functional style: 5456

real    0m0.007s
user    0m0.007s
sys 0m0.000s

~/projects/rust_proj $> time ./hof 
Find the sum of all the squared odd numbers under 1000
functional style: 5456

real    0m0.007s
user    0m0.004s
sys 0m0.003s

Clojure:

(defn sum-square-less-1000 []
  "Find the sum of all the squared odd numbers under 1000
"
  (->> (iterate inc 0)
       (map (fn [n] (* n n)))
       (take-while (partial > 1000))
       (filter odd?)
       (reduce +)))

关闭时间：

user> (time (sum-square-less-1000))
"Elapsed time: 0.443562 msecs"
5456
user> (time (sum-square-less-1000))
"Elapsed time: 0.201981 msecs"
5456
user> (time (sum-square-less-1000))
"Elapsed time: 0.4752 msecs"
5456

问题：

1. (reduce +)和(apply +)在Clojure中有什么区别？
2. 这个Clojure代码是惯用的方式吗？
3. 我能得出这样的结论:速度:闭合>生锈命令>锈蚀功能？Clojure在这里的表现让我大吃一惊。

Answer 1

如果您查看+的来源，您将看到(reduce +)和(apply +)对于更高的参数计数是相同的。不过，(apply +)是针对1或2个参数版本进行优化的。

在大多数情况下，(range)将比(iterate inc 0)快得多。

partial比一个简单的匿名函数慢，应该为您不知道还会提供多少args的情况保留它。

通过展示使用criterium进行基准测试的结果，我们可以看到，应用这些更改可以减少36%的执行时间：

user> (crit/bench (->> (iterate inc 0)
                       (map (fn [n] (* n n)))
                       (take-while (partial > 1000))
                       (filter odd?)
                       (reduce +)))
WARNING: Final GC required 2.679748643529675 % of runtime
Evaluation count : 3522840 in 60 samples of 58714 calls.
             Execution time mean : 16.954649 µs
    Execution time std-deviation : 140.180401 ns
   Execution time lower quantile : 16.720122 µs ( 2.5%)
   Execution time upper quantile : 17.261693 µs (97.5%)
                   Overhead used : 2.208566 ns

Found 2 outliers in 60 samples (3.3333 %)
    low-severe   2 (3.3333 %)
 Variance from outliers : 1.6389 % Variance is slightly inflated by outliers
nil
user> (crit/bench (->> (range)
                       (map (fn [n] (* n n)))
                       (take-while #(> 1000 %))
                       (filter odd?)
                       (reduce +)))
Evaluation count : 5521440 in 60 samples of 92024 calls.
             Execution time mean : 10.993332 µs
    Execution time std-deviation : 118.100723 ns
   Execution time lower quantile : 10.855536 µs ( 2.5%)
   Execution time upper quantile : 11.238964 µs (97.5%)
                   Overhead used : 2.208566 ns

Found 2 outliers in 60 samples (3.3333 %)
    low-severe   1 (1.6667 %)
    low-mild     1 (1.6667 %)
 Variance from outliers : 1.6389 % Variance is slightly inflated by outliers
nil

Answer 2

在我看来，Clojure代码看起来是惯用的，但它做了很多不必要的工作。这是另一种方法。

(reduce #(+ %1 (* %2 %2)) 0 (range 1 32 2))


user=> (time (reduce #(+ %1 (* %2 %2)) 0 (range 1 32 2)))
"Elapsed time: 0.180778 msecs"
5456
user=> (time (reduce #(+ %1 (* %2 %2)) 0 (range 1 32 2)))
"Elapsed time: 0.255972 msecs"
5456
user=> (time (reduce #(+ %1 (* %2 %2)) 0 (range 1 32 2)))
"Elapsed time: 0.346192 msecs"
5456
user=> (time (reduce #(+ %1 (* %2 %2)) 0 (range 1 32 2)))
"Elapsed time: 0.162615 msecs"
5456
user=> (time (reduce #(+ %1 (* %2 %2)) 0 (range 1 32 2)))
"Elapsed time: 0.257901 msecs"
5456
user=> (time (reduce #(+ %1 (* %2 %2)) 0 (range 1 32 2)))
"Elapsed time: 0.175507 msecs"
5456

但是，您不能根据这个测试得出一个比另一个更快的结论。基准测试是一项棘手的游戏。您需要在具有大量输入的类似产品的环境中测试您的程序，以获得任何有意义的结果。

Clojure中的(还原+)和(apply +)有什么不同？

apply是一个具有可变性的高阶函数。它的第一个参数是变量的函数，接受一堆中间的arg，然后最后一个arg必须是一个arg的列表。它的工作方式是首先将中间的args转换为args的列表，然后将args传递给函数。

示例：

(apply + 0 1 2 3 '(4 5 6 7))
=> (apply + '(0 1 2 3 4 5 6 7))
=> (+ 0 1 2 3 4 5 6 7)
=> result

至于reduce，我想医生说的很清楚

user=> (doc reduce)
-------------------------
clojure.core/reduce
([f coll] [f val coll])
  f should be a function of 2 arguments. If val is not supplied,
  returns the result of applying f to the first 2 items in coll, then
  applying f to that result and the 3rd item, etc. If coll contains no
  items, f must accept no arguments as well, and reduce returns the
  result of calling f with no arguments.  If coll has only 1 item, it
  is returned and f is not called.  If val is supplied, returns the
  result of applying f to val and the first item in coll, then
  applying f to that result and the 2nd item, etc. If coll contains no
  items, returns val and f is not called.
nil

在有些情况下，您可以使用apply f coll或reduce f coll，但当f具有变量性时，通常使用apply，而当f是2进制函数时，则使用reduce。