🏽 💦 👩🏾‍🤝‍👩🏻 为什么Rust应该成为一种功能编程语言 📈 👩🏼 👩🏿‍💻

哈Ha！

开始研究Scala之后，我立即发现一个事实，即最简单的快速排序算法的功能实现比类似的命令性实现慢得多，并且消耗的内存明显更多。同时，没有人认为功能代码更简洁，更具表现力和更耐错误。在Rust中重写了两个示例，我发现了一些我想分享的重要内容。削减的细节，在这里我只给出简要的结论：

对于命令式实施，Rust的收益仅为20％。这意味着JVM已接近本机性能，没有任何可改进之处。
对于功能性实现，Rust的速度提高了4.5倍，内存消耗降低了5.5倍，而且不存在垃圾收集器使程序更稳定（指标的变化更少）。对于那些想编写快速功能程序的人来说，这很有趣。
Rust所采用的数据的唯一所有者（和唯一可变的引用）的概念与不变性的概念非常相似，因此基于不变性，递归和复制的功能算法很容易落在Rust上，几乎无需重写，而命令式算法则强制重新设计代码。考虑链接可变性，生存期等。

结论 -Rust似乎是为FP专门创建的，尽管其语法的可能性尚未达到Scala。

因此，让我们从Scala开始，以两种样式实现快速排序：

命令式 -我们使用相同的数组，并使用递归过程重新排列其中的元素。我们看到了冗长的代码，可能容易受到拼写错误的影响，但是最好使用内存，并且要尽可能快。

def sort_imp(arr: Array[Double]) {
  def swap(i: Int, j: Int) {
    val t = arr(i)
    arr(i) = arr(j)
    arr(j) = t
  }

  def sort1(l: Int, r: Int) {
    val pivot = arr((l + r) / 2)
    var i = l
    var j = r
    while (i <= j) {
      while (arr(i) < pivot) i += 1
      while (arr(j) > pivot) j -= 1
      if (i <= j) {
        swap(i, j)
        i += 1
        j -= 1
      }
    }
    if (l < j) sort1(l, j)
    if (i < r) sort1(i, r)
  }

  if (arr.length > 1)
    sort1(0, arr.length - 1)
}

— , , . , , (, GC).

def sort_fun(arr: Array[Double]): Array[Double] = {
  if (arr.length <= 1) 
    arr
  else {
    val pivot = arr(arr.length / 2)
    Array.concat(
      sort_fun(arr filter (pivot > _)),
      arr filter (pivot == _),
      sort_fun(arr filter (pivot < _))
    )
  }
}

($ sbt run) 10 . :

— 2.5
— 40

, java 3.6 .

UPD
LLVM nativeMode := «release» «immix gc», :

— 2.3
— 63

Rust:

— , , , , , . , borrow-checker.

fn sort_imp(arr: &mut Vec<f64>) {
  fn swap(arr: &mut Vec<f64>, i: usize, j: usize) {
    let t = arr[i];
    arr[i] = arr[j];
    arr[j] = t;
  };

  fn sort1(arr: &mut Vec<f64>, l: usize, r: usize) {
    let pivot = arr[(l + r) / 2];
    let mut i = l;
    let mut j = r;
    while i <= j {
      while arr[i] < pivot { i += 1; }
      while arr[j] > pivot { j -= 1; }
      if i <= j {
        swap(arr, i, j);
        i += 1;
        j -= 1;
      }
    }
    if l < j { sort1(arr, l, j); }
    if i < r { sort1(arr, i, r); }
  };

  if arr.len() > 1 {
    sort1(arr, 0, arr.len() - 1);
  }
}

— , , Rust , .

iter() filter() , x &&f64, **. . append() , , .

fn sort_fun(arr: Vec<f64>) -> Vec<f64> {
  if arr.len() <= 1 {
    arr
  } else {
    let pivot = arr[arr.len() / 2];
    let mut a = Vec::<f64>::with_capacity(arr.len());
    a.append(&mut sort_fun(arr.iter().filter(|x| pivot > **x).cloned().collect()));
    a.append(&mut arr.iter().filter(|x| pivot == **x).cloned().collect());
    a.append(&mut sort_fun(arr.iter().filter(|x| pivot < **x).cloned().collect()));
    a
  }
}

UPD
:

fn sort_fun(arr: Vec<f64>) -> Vec<f64> {
    if arr.len() <= 1 {
        arr
    } else {
        let pivot = arr[arr.len() / 2];
        [
            sort_fun(arr.iter().filter(|&&x| pivot > x).cloned().collect()),
            arr.iter().filter(|&&x| pivot == x).cloned().collect(),
            sort_fun(arr.iter().filter(|&&x| pivot < x).cloned().collect()),
        ]
        .concat()
    }
}

, — iter().filter(...).chain(...). zero-cost, , , — . , .

— , — , ( ).

($ cargo build --release):

— 2
— 9

— 650 .

:

, — , . , — , Rust -, , Rust , (, null ).

-, zero-cost — . Rust — - . , 2019 Scala Rust .

Scala.
Rust.

.

为什么Rust应该成为一种功能编程语言

More articles: