munro

// Class sugar
var Class = (function () {
    'use strict';

    // Base class
    function Class() {
        throw new Error('Cannot instantiate `Class`.');
    }

munro

class FooA {
public:
    int a;
}

class FooB : public FooA {
public:
    int b;
}

munro

#include <iostream>
#include <functional>
#include <memory>
using namespace std;

std::function<void()> createCounter() {
    std::shared_ptr<int> count(new int(0));
    return [count](){
        (*count) += 1;
        cout << "count = " << (*count) << "\n";

munro

var sample_set = (function () {
    'use strict';

    var sample_set = [];

    function generateSample(not_recursive) {
        var overhead_usage = Math.random() * 2 + 5,
            game_usage = Math.random() * 2 + 3,
            idle_usage = Math.random(),
            games = Math.floor(Math.random() * 30) + 10,

munro

fnMaker = (name) => (args...) => [name, args]

what = fnMaker 'what'
the = fnMaker 'the'
fuck = 'fuck'
_is = fnMaker 'is'
going = fnMaker 'going'
to = 'to'
happen = 'happen'

munro

#ifndef __signals_h__
#define __signals_h__

#include <list>
#include <memory>
#include <iostream>
#include <functional>

namespace signals {
    template<typename... Values> class Signal {

munro

# named functions
def HelloWorld(str, fn, str2):
    pass

# single statement anonymous function
helloWorld('foo', lambda x, y: foo(x, y), 'bar')

# multi statement anonymous functions
helloWorld('foo', (lambda x, y:
    arbitraryMulti(x)

munro

import timeit

print 'Lambda:         %f' % timeit.Timer('fn = lambda x: x * x\n'
                                          'map(fn, xrange(10))', 'gc.enable()').timeit()
print 'Named function: %f' % timeit.Timer('def fn(x): return x * x;\n'
                                          'map(fn, xrange(10))', 'gc.enable()').timeit()

munro

/*
!.*
.gitignore

munro

#include <iostream>
using namespace std;

class Foo {
public:
    int a;
    Foo(int a) : a(a) {
    }
    virtual void print() {
        cout << "  I am Foo: " << a << "\n";