grahamking

extern mod sqlite;

fn db() {

    let database =
        match sqlite::open("test.db") {
            Ok(db) => db,
            Err(e) => {
                println(fmt!("Error opening test.db: %?", e));
                return;

grahamking

extern mod std;

use std::{net_tcp,net_ip};
use std::uv;

fn fetch(code: ~str) -> ~[~str] {

    let ipaddr = net_ip::v4::parse_addr("205.156.51.232");
    let iotask = uv::global_loop::get();
    let connect_result = net_tcp::connect(ipaddr, 80, &iotask);

grahamking

fn load(filename: ~str) -> ~[~str] {

    // The simple way:
    // let read_result = io::file_reader(~path::Path(filename));

    let read_result: Result<@Reader, ~str>;
    read_result = io::file_reader(~path::Path(filename));

    match read_result {
        Ok(file) => return file.read_lines(),

grahamking

fn load(filename: ~str) -> ~[~str] {

    // The simple way:
    // let read_result = io::file_reader(~path::Path(filename));

    let read_result: Result<@Reader, ~str>;
    read_result = io::file_reader(~path::Path(filename));

    if read_result.is_ok() {
        let file = read_result.unwrap();

grahamking

fn main() {

    for 2.times {
        println("Basic loop sugar")
    }
    2.times(||{ println("Basic loop closure"); true });

    for [1,2,3].each |var| {
        println(fmt!("Sugary loop %d", *var));
    }

grahamking

/* Ask the user for their name */
fn ask_name(prompt: ~str) -> ~str {
    println(prompt);
    return io::stdin().read_line();
}

fn main() {
    let name = ask_name(~"What is your name?");
    println(fmt!("Hello %s", name));
}

grahamking

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

grahamking

struct Point {
    x: int,
    y: int
}

fn one() {
    let mut a = ~Point{x: 10, y: 20};
    a.x = 42;
    println(a.x.to_str());
}

grahamking

"""Task queue using redis.

Redis client:
    LPUSH work "say Hello world!"
    LPUSH work "log This goes into syslog"
"""

import redis
from multiprocessing import Pool