dbro

# Lua routines for use inside the Redis datastore
# Hyperloglog cardinality estimation
# ported from http://stackoverflow.com/questions/5990713/loglog-algorithm-for-counting-of-large-cardinalities
#
# Dan Brown, 2012. https://github.com/dbro
#
# note that lua needs to have the bitlib and murmur3 modules built in, and loaded by redis
#
# suitable for counting unique items from 0 to billions
# choose a k value to balance storage and precision objectives

seanjensengrey

t = {}
t[0,0] = lambda x: x
t[1,0] = lambda x: "Fizz"
t[0,1] = lambda x: "Buzz"
t[1,1] = lambda x: "FizzBuzz"

def tests(x):
    return (x % 3 == 0, x % 5 == 0)

for x in range(1,101):

syllog1sm

"""A simple implementation of a greedy transition-based parser. Released under BSD license."""
from os import path
import os
import sys
from collections import defaultdict
import random
import time
import pickle

SHIFT = 0; RIGHT = 1; LEFT = 2;

JeffBelgum

#![feature(macro_rules)]

/// MIT license etc. etc.
///
/// Experimenting with Python-like list comprehensions.
///
/// An attempt to explore the possibility space for ergonomic improvements
/// in Rust that can come post v1.0. Notice that there are not type declerations. 
/// Aside from the "c!" macro invocation, Rust allows for an exact copy of the
/// Python comprehension syntax.

joshmarinacci

use std::num;


struct Vector {
    x:f32,
    y:f32,
    z:f32
}

impl Vector {

nrc

Rust developer tools - status and strategy

Availability and quality of developer tools are an important factor in the success of a programming language. C/C++ has remained dominant in the systems space in part because of the huge number of tools tailored to these lanaguages. Succesful modern languages have had excellent tool support (Java in particular, Scala, Javascript, etc.). Finally, LLVM has been successful in part because it is much easier to extend than GCC. So far, Rust has done pretty well with developer tools, we have a compiler which produces good quality code in reasonable time, good support for debug symbols which lets us leverage C++/lanaguge agnostic tools such as debuggers, profilers, etc., there are also syntax highlighting, cross-reference, code completion, and documentation tools.

In this document I want to layout what Rust tools exist and where to find them, highlight opportunities for tool developement in the short and long term, and start a discussion about where to focus our time an

mstaflex

import tornado.ioloop
import tornado.web
import gen
import time
import os
import tornado

file_list = os.listdir("img")
counter = 0

oakes

Contents

• Why care about Rust?
• The Toolchain
• Creating a New Project
• Modules
• Crates
• Types
• References
• Mutability

aisamanra

#![feature(unboxed_closures)]
#![feature(core)]
#![feature(io)]

use std::old_io::stdio::{stdin};
use std::collections::HashMap;

// This is our toy state example.
#[derive(Debug)]
struct State {

seanjensengrey

This is a small demo of how to create a library in Rust and call it from Python (both CPython and PyPy) using the CFFI instead of ctypes.

Based on http://harkablog.com/calling-rust-from-c-and-python.html (dead) which used ctypes

CFFI is nice because:

• Reads C declarations (parses headers)
• Works in both CPython and PyPy (included with PyPy)
• Lower call overhead than ctypes