$ cargo new hello-world --bin
     Created binary (application) `hello-world` project
$ cd hello-world/
$ tree
.
├── Cargo.toml
└── src
    └── main.rs

1 directory, 2 files

fn main() {
    println!("Hello, World!");
}

$ cargo run
   Compiling hello-world v0.1.0 (file:///home/naufraghi/.../hello-world)
    Finished dev [unoptimized + debuginfo] target(s) in 0.41 secs
     Running `target/debug/hello-world`
Hello world!

//! Programma di esempio per _PyCon Otto_,
//! l'immancabile «Hello, World!».
fn main() {
    println!("Hello, World!");
}

//! Libreria di esempio per _PyCon Otto_,
//! l'immancabile «Hello, World!».
//!
//! ```
//! use hello_world_lib::greater;
//! let message = greater("World");
//! assert_eq!(message, "Hello, World!");
//! ```

pub fn greater(name: &str) -> String {
    format!("Hello, {}!", name)
}

$ cargo test --doc
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
   Doc-tests hello-world-lib

running 1 test
test greater_0 ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured

pub fn greater(name: &str) -> String {
    format!("Hello, {}!", name)
}

pub fn greater2(optional_name: Option<&str>) -> String {
    //! Restituisce un saluto di default se il nome è None
    //!
    //! ```
    //! use hello_world_lib::greater2;
    //! let message = greater2(None);
    //! assert_eq!(message, "Hello, World!");
    //!
    //! let message = greater2(Some("Matteo"));
    //! assert_eq!(message, "Hello, Matteo!");
    //! ```
    let name = match optional_name {
        Some(name) => name,
        None => "World",
    };
    format!("Hello, {}!", name)
}

var = some_optional_value()
if var is not None:
   res = do_something_with(var)
else:
   res = None

fn main() {
    let out = if let Some(value) = some_optional_value("some") {
        do_something_with(value)
    } else {
        None
    };
    println!("out: {:?}", out);
}

struct Circle {
    x: f64,
    y: f64,
    radius: f64,
}

impl Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * (self.radius * self.radius)
    }
}

struct Circle {
    x: f64,
    y: f64,
    radius: f64,
}

trait HasArea {
    fn area(&self) -> f64;
}

impl HasArea for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * (self.radius * self.radius)
    }
}

def print_area(shape) {
    print("This shape has an area of {}".format(shape.area()));
}

class Counter(abc.Iterator):
    def __init__(self):
        self.count = 0
    def __nxt__(self):
        self.count += 1
        return self.count  

>>> c = Counter()
Traceback (most recent call last):
  File "<ipython-input-29-f3cf168481b9>", line 1, in <module>
    c = Counter()
TypeError: Can't instantiate abstract class Counter with abstract
           methods __next__

         / a b \   / x \   / e \
f(x,y) = |     | · |   | + |   |
         \ c d /   \ y /   \ f /

use cpython::{PyResult, Python};
use barnsley_fern;

py_module_initializer!(_iterated_function_systems,
                       _inititerated_function_systems,
                       PyInit__iterated_function_systems,
                       |py, m| {
    try!(m.add(py, "__doc__", "Rust iterated function systems"));
    try!(m.add(py,
               "barnsley_fern",
               py_fn!(py,
                      py_barnsley_fern(iterations: usize,
                                       points_to_skip: usize,
                                       bending: f64))));
    Ok(())
});

fn py_barnsley_fern(py: Python,
                    iterations: usize,
                    points_to_skip: usize,
                    bending: f64)
                    -> PyResult<Vec<(f64, f64)>> {
    Ok(barnsley_fern(iterations, points_to_skip, bending))
}

[package]
name = "ifs"
version = "0.1.0"
authors = ["Matteo Bertini <matteo@naufraghi.net>"]

[lib]
name = "iterated_function_systems"
crate-type = ["cdylib"]

[dependencies]
nalgebra = "0.11.2"
rand = "0.3.15"
cpython = "0.1"

[tox]
envlist = py27, py35

[testenv]
commands =
    python setup.py install
    pip install example/
    py.test
deps =
    pytest