idata

目前这个 lib 是为个人使用而准备的。因此，只要我需要，我就会添加新功能。

• 仓库
• 文档
• rust-crate

用于与 Rust 减少可变性以及以更函数式的方式编程的小工具。

• 可变性和共享是坏事。
• 病毒式可变性是坏事。
• 在大型代码块上的可变性是坏事。

在 Rust 中，我们可以没有病毒式，没有共享的可变性。让我们利用这个特性。

这个小工具旨在帮助解决这些问题

使用方法

添加到 cargo.toml

[dependencies]
idata = "0.1.0"

修改

0.1.0   First version

待办事项

目前这个 lib 是为个人使用而准备的。因此，只要我需要，我就会添加新功能。

一些示例

一个非常基本的示例...

   extern crate idata;
   use idata::cont::IVec;
   fn main() {
        let v = vec![1, 2];
        let v = v.ipush(3)
                 .ipush(4);
       assert!(v == vec![1,2,3,4]);
   }

向向量中推入一个元素，并返回相同的向量

    extern crate idata;
    use idata::cont::IVec;

    fn main() {
         let v = vec![1, 2];
         let v = v.ipush(3)
                  .ipush(4);

        assert!(v == vec![1,2,3,4]);
    }

将一个向量追加到另一个向量中

    extern crate idata;
    use idata::cont::IVec;

    fn main() {
         let v1 = vec![1, 2];
         let v2 = vec![3, 4, 5];
         let v1 = v1.iappend(v2);

         assert!(v1 == vec![1,2,3,4, 5]);
    }

从向量的末尾移除一个元素

    extern crate idata;
    use idata::cont::IVec;

    fn main() {
         let v1 = vec![1, 2, 3, 4, 5, 6];
         let (o, v1) = v1.ipop();

         assert!(v1 == vec![1,2,3,4, 5]);
         assert!(o.unwrap() == 6);
    }

尝试从字符顶部获取一个字符，如果可能的话，返回 (char, remaining_chars)

    extern crate idata;

    fn main() {
         let chars = "Hello world".chars();
         let (ch, chars) = idata::consume_char(chars).unwrap();

         assert!(ch == 'H');
         assert!(chars.as_str() == "ello world");
    }

向字符串添加字符

    extern crate idata;
    use idata::IString;

    fn main() {
            let s = "Hello world".to_string();
            let s = s.ipush('!');

            assert!(s == "Hello world!");
    }

向字符串添加字符串

    extern crate idata;
    use idata::IString;

    fn main() {
            let s = "Hello world".to_string();
            let s = s.iappend("!!!");

            assert!(s == "Hello world!!!");
    }

从字符串中移除最后一个字符

    extern crate idata;
    use idata::IString;
        fn main() {
        let s = "Hello world!".to_string();
        let s = s.ipop().unwrap();
            assert!(s == "Hello world");
    }

使用 TCO 进行递归模拟

我们无法在 Rust 的 for 循环中使用 SSA

它与递归配合得很好，但是...alloc

Rust 在递归中没有 TCO (尾调用优化)

在某些情况下，这可能会很昂贵，甚至危险

一个选项，可能是使用下一个“跳板”

    extern crate idata;
    use idata::tc::*;

    fn main() {
            let (sum, _) = tail_call((0, 0), |(acc, counter)| {
                if counter < 101 {
                    TailCall::Call((acc + counter, counter + 1))
                } else {
                    TailCall::Return((acc, counter))
                }
            });
            assert!(sum == 5050);
    }