cout << format("Hello, are you feeling lucky, punk? %d\n") % "Nope";

fn main() {
    println!("Hello, world! {:d}\n", 13);
    println!("Hello, world! {:d}\n", "Hello");
}

cyberax@cybmac:~/some$ rustc test.rs 
test.rs:3:38: 3:45 error: failed to find an implementation of trait std::fmt::Signed for &'static str
test.rs:3     println!("Hello, world! {:d}\n", "Hello");
                                               ^~~~~~~
note: in expansion of format_args!
<std macros>:2:23: 2:77 note: expansion site
<std macros>:1:1: 3:2 note: in expansion of println!
test.rs:3:5: 3:47 note: expansion site

#include <iostream>
#include <boost/xpressive/xpressive.hpp>
using namespace boost::xpressive;
int main()
{
    cregex test = *_s >> +_d >> "--" >> +_d >> *_s;
    cmatch what;
    for(int f=0;f<10000000;++f)
        regex_match("  123--541", what, test);
    return 0;
}

cyberax@cybmac:~/some$ time clang++ -O2 -I /opt/local/include/ regtest.cpp 

real    0m2.584s
user    0m2.334s
sys    0m0.210s
cyberax@cybmac:~/some$ time ./a.out 

real    0m9.922s
user    0m9.873s
sys    0m0.017s

#![feature(phase)]
#[phase(syntax)]
extern crate regex_macros;
extern crate regex;
static tst: &'static str = "  123-451";
fn main() {
    let re = regex!(r"\s+\d+--\d+\s*");
    for r in range(0,10000000) {
        re.is_match(tst);
    }
}

cyberax@cybmac:~/some$ time rustc -O test.rs 
test.rs:10:9: 10:10 warning: unused variable: `r`, #[warn(unused_variable)] on by default
test.rs:10     for r in range(0,10000000) {
                   ^

real    0m0.118s
user    0m0.071s
sys    0m0.027s
cyberax@cybmac:~/some$ time ./test

real    0m4.459s
user    0m4.436s
sys    0m0.011s

C>cout << format("Hello, are you feeling lucky, punk? %d\n") % "Nope"; 
C>

C>real    0m9.922s
C>user    0m9.873s
C>sys    0m0.017s

C>real    0m4.459s
C>user    0m4.436s
C>sys    0m0.011s

cout << format("Hello, are you feeling %2, punk? %1\n") % "Nope";

...
                    #[allow(unused_variable)]
                    #[inline]
                    fn step(&self, groups: &mut Captures, nlist: &mut Threads,
                            caps: &mut Captures, pc: uint) -> StepState {
                        match pc {
                            0u => { },
                            1u => {
                                if self.chars.prev.is_some() {
                                    let c = self.chars.prev.unwrap();
                                    let found =
                                        match c {
                                            '\t' ..'\n' => true,
                                            '\x0c' ..'\r' => true,
                                            ' ' ..' ' => true,
                                            '\xa0' ..'\xa0' => true,
                                            '\u1680' ..'\u1680' => true,
                                            '\u2000' ..'\u200a' => true,
                                            '\u2028' ..'\u2029' => true,
                                            '\u202f' ..'\u202f' => true,
                                            '\u205f' ..'\u205f' => true,
                                            '\u3000' ..'\u3000' => true,
                                            _ => false
                                        };
                                    if found { self.add(nlist, 2u, caps); }
                                }
                            },
                            2u => { },
                            3u => {
                                if self.chars.prev.is_some() {
                                    let c = self.chars.prev.unwrap();
                                    let found =
                                        match c {
                                            '0' ..'9' => true,
                                            '\u0660' ..'\u0669' => true,
                                            '\u06f0' ..'\u06f9' => true,
                                            '\u07c0' ..'\u07c9' => true,
:
...

They exist in a separate, global namespace.
Exporting macros feels like a hack.
Importing macros feels like a hack.

#include <iostream>

using namespace std;

template <int m, int n>
struct ack
{
    enum {value = ack<m - 1, ack<m, n - 1>::value>::value};
};


template <int n>
struct ack<0, n>
{
    enum {value = n + 1};
};

template <int m>
struct ack<m, 0>
{
    enum {value = ack<m - 1, 1>::value};
};


int main()
{
constexpr int x = ack<3, 6>::value;
cout << x << endl;
}

def ack(m, n):
    if m == 0:
        return n + 1
    if(m > 0 and n == 0):
        return ack(m - 1, 1)
    if(m > 0 and n > 0):
        return ack(m - 1, ack(m, n - 1))
    assert(0)

print ack(3, 6)

$time g++-4.8 -pedantic -Os -std=c++0x  ack_template_cpp.cpp -o ack_template_cpp
 
real    0m0.199s
user    0m0.176s
sys    0m0.023s
$time clang++ -std=c++1y -pthread ack_template_cpp.cpp -o ack_template_cpp

real    0m0.195s
user    0m0.162s
sys    0m0.032s
$
$
$time python -u "ack_py.py"
509

real    0m0.045s
user    0m0.036s
sys    0m0.011s

//int frob(int a);
int frob(float a);
int frob(double a);

int res = frob(11);

#include <iostream>
using namespace std;
template <int m>
struct ack
{
        enum {value = ack<m-1>::value+m};
};
template <>
struct ack<0>
{
        enum {value = 0};
};

int main()
{
    constexpr int x = ack<256>::value;
    cout << x << endl;
}

cyberax@cybmac:~/some$ time clang++ -std=c++1y -pthread test2.cpp 

real    0m0.407s
user    0m0.372s
sys    0m0.031s
cyberax@cybmac:~/some$ cat test.py 
num = 0
for i in range(0, 256):
   num += i

cyberax@cybmac:~/some$ time python test.py 

real    0m0.025s
user    0m0.013s
sys    0m0.010s

FR>Ну тоже чуть мухлюешь , итеративный конечно шустрее будет, надо на D попробовать, там и итеративный

cyberax@cybmac:~/some$ cat test.py 
def summer(num):
    if num == 0:
        return 0
    return num+summer(num-1)
summer(256)
cyberax@cybmac:~/some$ time python test.py 

real    0m0.025s
user    0m0.013s
sys    0m0.010s

import std.stdio;

ulong tst(ulong m) pure
{
ulong result = 0;
while(m)
    result += m--;
return result;
}

void main()
{
enum {x = tst(1000000)};
writeln(x);
}

num = 0
for i in xrange(0, 1000001):
   num += i
print num

$time dmd  tst001.d

real    0m0.843s
user    0m0.779s
sys    0m0.064s
$
$time python -u "tst001.py"
500000500000

real    0m0.083s
user    0m0.082s
sys    0m0.000s
$

open Printf

let _ = printf "%d" "compile time fail"

File "printf_tst.ml", line 3, characters 20-39:
Error: This expression has type string but an expression was expected of type
         int