A partial implementation of delimited continuation

dc.rs

fn expand_shift0(b: &Fn(&Fn()), k: &Fn()) {
   b(k);
}

//fn expand_shift1<B>(b: &Fn(&Fn() -> B) -> B, k: &Fn() -> B) -> B {
//   b(k)
//}

//fn expand_shift2<A, B>(b: &Fn(&Fn(A) -> B) -> B, k: &Fn(A) -> B) -> B {
//   b(k)
//}

macro_rules! reset {
  (; $($b:tt)*) => (reset!($($b)*));
  (shift |$k:ident| {
      $($b:tt)*
    }
    $($res:tt)*) => (expand_shift0(&|$k| {
                reset!($($b)*)
              },
              &|| {
                reset!($($res)*)
              }));
  (cps $f:ident ($($e:expr),*) $($res:tt)* ) => ($f (&|| {
                              reset!($($res)*)
                            },
                            $($e),*));
  (if $e:expr {
      $($t:tt)*
    } else {
      $($f:tt)*
    }
    $($res:tt)*) => (
    if $e {
      reset!($($t)*; $($res)*)
    } else {
      reset!($($f)*; $($res)*)
    });
  (if $e:expr {
      $($t:tt)*
    }
    $($res:tt)*) => (
    if $e {
      reset!($($t)*; $($res)*)
    });
  (while $e:expr {
      $($b:tt)*
    }
    $($res:tt)*) => {{
    struct Fact<'a> { f: &'a Fn(&Fact, &Fn())};
    let f = &Fact {
      f: &|f: &Fact, k: &Fn()|{ reset!(if $e {$($b)*; (f.f)(f, k);} else {k();};)}
    };
    (f.f)(f, &||{reset!($($res)*)});
  }};
  {$s:stmt} => {{$s}};
  {$s:stmt ; $($res:tt)* } => {{$s ; reset!($($res)*) }};
  () => {{}};
}

macro_rules! cps {
  (fn $f:ident ($($a:ident : $t:ty),*) {$($b:tt)*}) => (
    fn $f (k: &Fn(), $($a : $t),*) {
      reset!($($b)*; k(););
    }
  )
}


cps!(fn foo (){
  println!("dd");
  shift |k| {
    k();
  };
  println!("aa");
});


fn main() {
  reset!{
    println!("aaa");
    shift |k| {
      k();
      shift |k| {
        k();
      };
      println!("aa");
    };
    cps foo();
    println!("bb");
    if true {
      shift |k| { println!("if"); k();};
    } else {
      ;
    };
    while true {
      shift |k| { println!("while"); }
    };
    println!("cc");
  }
}