use std::fs::File;

use naan::prelude::*;

fn copy_file_to_dir(dir: String, file: File) -> std::io::Result<()> {
  // ...
  # Ok(())
}

fn main() {
  let dir = std::env::var("DEST_DIR").unwrap();
  let copy = copy_file_to_dir.curry().call(dir);

  File::open("a.txt").bind1(copy.clone())
                     .bind1(|_| File::open("b.txt"))
                     .bind1(copy.clone())
                     .bind1(|_| File::open("c.txt"))
                     .bind1(copy);
}

/*
  equivalent to:
  fn main() {
    let dir = std::env::var("DEST_DIR").unwrap();

    copy_file_to_dir(dir.clone(), File::open("a.txt")?)?;
    copy_file_to_dir(dir.clone(), File::open("b.txt")?)?;
    copy_file_to_dir(dir, File::open("c.txt")?)?;
  }
*/

use std::fs::File;

use naan::prelude::*;

fn append_contents(from: File, to: File) -> std::io::Result<()> {
  // ...
  # Ok(())
}

fn main() -> std::io::Result<()> {
  Ok(append_contents.curry()).apply1(File::open("from.txt"))
                             .apply1(File::open("to.txt"))
                             .flatten()
}

/*
equivalent to:
fn main() -> std::io::Result<()> {
  let from = File::open("from.txt")?;
  let to = File::open("to.txt")?;
  append_contents(from, to)
}
*/

pub trait F2Once<A, B, C>: Sized {
  /// The concrete type that `curry` returns.
  type Curried;

  /// Call the function
  fn call1(self, a: A, b: B) -> C;

  /// Curry this function, transforming it from
  ///
  /// `fn(A, B) -> C`
  /// to
  /// `fn(A) -> fn(B) -> C`
  fn curry(self) -> Self::Curried;
}

pub trait F2<A, B, C>: F2Once<A, B, C> {
  /// Call the function with all arguments
  fn call(&self, a: A, b: B) -> C;
}

impl<F, A, B, C> F2<A, B, C> for F where F: Fn(A, B) -> C { /* <snip> */ }
impl<F, A, B, C> F2Once<A, B, C> for F where F: FnOnce(A, B) -> C { /* <snip> */ }

use std::io;

fn network_fetch_name() -> io::Result<String> {
  Ok("harry".into())
}
fn network_send_message(msg: String) -> io::Result<()> {
  Ok(())
}
fn global_state_store_name(name: &str) -> io::Result<()> {
  Ok(())
}

// Declarative
fn foo0() -> io::Result<()> {
  network_fetch_name().and_then(|name| {
                        global_state_store_name(&name)?;
                        Ok(name)
                      })
                      .map(|name| format!("hello, {name}!"))
                      .and_then(network_send_message)
}

// Idiomatic
fn foo1() -> io::Result<()> {
  let name = network_fetch_name()?;
  global_state_store_name(&name)?;
  network_send_message(format!("hello, {name}!"))
}

// Imperative
fn foo2() -> io::Result<()> {
  let name = match network_fetch_name() {
    | Ok(name) => name,
    | Err(e) => return Err(e),
  };

  match global_state_store_name(&name) {
    | Err(e) => return Err(e),
    | _ => (),
  };

  network_send_message(format!("hello, {name}!"))
}

一些注意事项

• “惯用”实现最简洁且易于扫描
• 由于作用域共享，惯用和命令式实现更难重构；命令式语句依赖于前面的语句才有意义，而声明式表达式与状态或作用域几乎没有耦合。