builder_test.rs

#[deriving(Eq)]
struct ParamsBuilder {
    foo: uint,
    bar: ~str,
    baz: uint,
    run: bool
}

impl ParamsBuilder {
  fn default() -> ParamsBuilder{
    ParamsBuilder { foo: 0, bar: ~"", baz: 0, run: false }
  }

  fn foo(mut self, foo: uint) -> ParamsBuilder {
    self.foo = foo;
    self
  }

  fn bar(mut self, bar: ~str) -> ParamsBuilder {
    self.bar = bar;
    self
  }

  fn baz(mut self, baz: uint) -> ParamsBuilder {
    self.baz = baz;
    self
  }

  fn run(mut self) -> ParamsBuilder {
    self.run = true;
    println!("{:?}", self);
    self
  }
}

#[test]
fn test_chain(){
  let mp = ParamsBuilder::default().foo(1).bar(~"bar").baz(2).run();

  assert_eq!(ParamsBuilder { foo: 1, bar: ~"bar", baz: 2, run: true }, mp);
}

struct MyParams {
    foo: uint,
    bar: ~str,
    baz: uint
}

impl MyParams {
  fn default() -> MyParams{
    MyParams { foo: 0, bar: ~"", baz: 0 }
  }

  fn foo(mut self, foo: uint) -> MyParams{
    self.foo = foo;
    self
  }

  fn bar(mut self, bar: ~str) -> MyParams{
    self.bar = bar;
    self
  }
}

#[test]
fn test_chain(){
  let mp = MyParams::default().foo(1).bar(~"bar");

  println!("{:?}", mp);

}