Shared via Rust Playground

playground.rs

#![allow(non_camel_case_types, unused_variables, dead_code, unused_mut)]
#![feature(concat_idents)]
//use std::char;

macro_rules! chain2 {
    [ [$all:expr] | #end
    ] => [
        $all
    ];

    [ ( $( $arg:expr ),+ ) | $func:ident : $xs:tt
    ] => [
        chain2! {  [$func( $( $arg ),+ )] | $xs  #end  }
    ];
    
    [ [$prev:expr] | $func:ident( $( $args:expr ),+ ) : $xs:tt  #end
    ] => [
        chain2! {  [$func( $($args),+ , $prev )] | $xs  #end}
    ];
}

macro_rules! chain3 {
    [ ( $($first:expr),+ ) | $all:expr
    ] => [
        chain3! { [$($first:expr),+] $all }
    ];
    
    [ $prev:tt $func:ident : $funcs:expr
    ] => [
        chain3! { [$func( $prev )] $funcs }
    ];
    
    [ $prev:tt $func:ident( $($args:expr),+ ) : $funcs:expr
    ] => [
        chain3! { [$func( $($args:expr,)+ $prev )] $funcs }
    ];
}

macro_rules! chain4 {
    [ ( $($first:expr),+ ) :: $func:ident; $($rest:tt)*
    ] => [
        chain4! { [ $func( $($first),+ ) ] :: $($rest)* }
    ];
    
    [ [ $prev:expr ] :: $func:ident( $($args:expr),+ ) ;
    ] => [
        { $func( $( $args, )+ $prev ) }
    ];
    
    [ [ $prev:expr ] :: $func:ident ;
    ] => [
        { $func( $prev ) }
    ];
    
    [ [ $prev:expr ] :: $func:ident( $($args:expr),+ ); $($rest:tt)*
    ] => [
        chain4! { [ $func( $( $args, )+ $prev ) ] :: $($rest)* }
    ];
    
    [ [ $prev:expr ] :: $func:ident; $($rest:tt)*
    ] => [
        chain4! { [ $func( $prev ) ] :: $($rest)* }
    ];
}

macro_rules! cc {
    [ ( $($first:expr),+ ) : $func:ident $($rest:tt)*
    ] => [
        cc! { [ $func( $($first),+ ) ] # $($rest)*; }
    ];
    
    /*[ ( $($first:expr),+ ) : $func:ident( $($args:expr),+ ) $($rest:tt)*
    ] => [
        chain4! { [ $func( $( $args, )+ $($first),+ ) ] :: $($rest)* }
    ];*/
    
    [ [ $prev:expr ] # : $func:ident( $($args:expr),+ ) ;
    ] => [
        { $func( $( $args, )+ $prev ) }
    ];
    
    [ [ $prev:expr ] # : $func:ident ;
    ] => [
        { $func( $prev ) }
    ];
    
    [ [ $prev:expr ] # : $func:ident( $($args:expr),+ ) $($rest:tt)*
    ] => [
        cc! { [ $func( $( $args, )+ $prev ) ] # $($rest)* }
    ];
    
    [ [ $prev:expr ] # : $func:ident $($rest:tt)*
    ] => [
        cc! { [ $func( $prev ) ] # $($rest)* }
    ];
}


// FIXME \ Add support for `<Ty as Tr>::func()` function calls
//       \ as well as `.method()` calls on returned objects.
macro_rules! c2 {
    [ ( $($first:expr),+ ) : $func:ident $($rest:tt)*
    ] => [
        chainx! { [ $func( $($first),+ ) ] # $($rest)*; }
    ];
    
    /*[ ( $($first:expr),+ ) : $func:ident( $($args:expr),+ ) $($rest:tt)*
    ] => [
        chain4! { [ $func( $( $args, )+ $($first),+ ) ] :: $($rest)* }
    ];*/
    
    [ [ $prev:expr ] # : $func:ident( $($args:expr),+ ) ;
    ] => [
        { $func( $( $args, )+ $prev ) }
    ];
    
    [ [ $prev:expr ] # : $func:ident ;
    ] => [
        { $func( $prev ) }
    ];
    
    [ [ $prev:expr ] # : $func:ident( $($args:expr),+ ) $($rest:tt)*
    ] => [
        chainx! { [ $func( $( $args, )+ $prev ) ] # $($rest)* }
    ];
    
    [ [ $prev:expr ] # : $func:ident $($rest:tt)*
    ] => [
        chainx! { [ $func( $prev ) ] # $($rest)* }
    ];
}

macro_rules! chain {
    /*
    /*(   ( $($args:ident),* ) $(| $func:ident )+
    ) => {{
        
    }}*/
    
    /*(   ( $($args:ident),* ) $funcs:tt
    ) => {{
       chain!( $func($args) $funcs ); 
    }};*/
    
    /*(   ( $args:expr ) [$func:ident $funcs:tt]
    ) => {{
        chain!( $func($args) $funcs );
    }};
    
    (   ( $args:expr ) | $func:ident $funcs:tt
    ) => {{
        chain!( $func($args) $funcs );
    }};
    
    (   $done:expr   ) => {{
        $done
    }};*/
    */
    
    [  ( $($args:expr),+ ) : $func:ident $( : $funcs:ident )*
    ] => [
        chain!{ [$func( $($args),+ )] : $( $funcs ),* #end }
    ];
    
    [  [$all:expr] : #end  ] => { ($all) };
    
    [  [$all:expr] : $func:ident $(, $funcs:ident )* #end
    ] => [
        chain!{ [$func( $all )] : $( $funcs ),* #end }
    ];
    
    [ //( $(arg:expr),+ ) >> 
    ] =>
    {
    
    }

    //(  ( $($args:expr),+ ) .. $func:ident $(.. $funcs:ident)*
    //) => {
    //    chain!( $func ( $($args),+ ) $(.. $funcs)* );
    //};
    //(  $all:tt in ) => { $all };
}

macro_rules! tie_seq {

    [ # $( $vars:ident ),+ = $( $vals:expr ),+
    ] => [
        $(
            $vars = $vals;
        )+
    ];
    
    [ shadow; $( $vars:ident ),+ = $( $vals:expr ),+
    ] => [
            let ($($vars),*) = ($($vals),*);
    ];
    
    [ copy; $( $vars:ident ),+ = $( $vals:expr ),+
    ] => [
            let ($(mut $vars),*) = ($($vals),*);
    ];
    
    [ [$t:ident] $( $vars:ident ),+ = $( $vals:expr ),+
    ] => [
            let ( $($t $vars),*) = ($($vals),*);
    ];
}

macro_rules! mutall {
    
    ( $( $vars:ident ),+ = $( $vals:expr ),+ ) => { let ( $( mut $vars ),+ ) = ( $( $vals ),+ ); };

}

fn addd( s: i32 ) -> i32 { 1 + s }

fn times( g: i32, s: i32 ) -> i32 { g * s }

fn main() {
    let () = ();
    /*println!("{:?}", (32, 'a', false).try_me());
    println!("{:?}", (2, false).overloaded_func());
    println!("{:?}", (56, 51, 'a').overloaded_func());
    
    println!("{:?}", (6, 2, 'b').overloaded_2());
    println!("{:?}", ( 'g', false ).overloaded_2());
    
    println!("{:?}", ('a', true).new_one());
    //println!("{}", ("MAAK".to_string(), false).new_one());
    ("MAAK".to_string(), false).new_one();*/
    
    println!("Hello, world!");
    
    let ( mut x, mut y, mut z ) = (1, 2, 3);
    
    mutall!{
        c, v, b = 2, 3, 4
    }
    
    println!("1: {}, {}, {}", x, y, z);
    
    tie_seq!{
        copy; z, x, y = y, x, z
    }
    
    println!("2: {}, {}, {}", x, y, z);
    println!("{}", chain!{ (4) : addd : addd : addd });
    //println!("{}", chain3!{ (4) | addd : addd : addd });
    
    /* ' */println!("{}",
        chain4!{ (4) ::
            addd;
            times(3); 
            addd;
        }
    );/* ' */
    
    println!("{}",
        cc!{
        (4) : addd
            : times(2)
            : addd
        }
    );
    
    println!("3: {}, {}, {}", c, v, b);
}