r2p2

// g++ main.cpp -std=gnu++0x
#include <vector>
#include <memory> // shared_ptr

template <class T>
class Base
{
public:
	Base(T value)
	:m_value(value)

r2p2

// g++ main2.cpp -std=gnu++0x
#include <vector>
#include <memory> // shared_ptr

template <class T>
class Base
{
public:
	Base(T value)
	:m_value(value)

r2p2

#include <vector>

template <class T>
class Foo
{
public:
	void bar()
	{
		typename std::vector<T>::const_iterator it;
	}

r2p2

#include <stdint.h>
#include <stdio.h>
#include <cstring>
#include <fstream>
#include <map>
#include <arpa/inet.h>

uint32_t* load_code(char *file, uint32_t &filesize)
{
  uint32_t *p_code = NULL;

r2p2

(defn kill-process [process-channel]
  (send process-channel (fn [a] "stop")))

(defn engine-loop [channel state process-list]
  (loop [my-state state
         my-process-list process-list]
    (await channel)
    (let [channel-value (deref channel)] 
          (do
            (send channel (fn [a] "idle"))

r2p2

(defn start-process-by-agent [process-agent]
  (send-off process-agent (fn [process-data] "running")))

(defn stop-process-by-agent [process-agent]
  (send-off process-agent (fn [process-data] "stopped")))

(defn init [wfe-id]
  (println "initiating wfe")
  (println "TODO: load unfinished processes")
  (agent (hash-map

r2p2

module Main where

import Char

type Tape = [Char]
type Machine = (Tape, Tape)
type Operation = Machine →  IO (Machine)
type Operations = [Operation]

raise =

r2p2

#include <iostream>
#include <vector>

struct CallbackNoArg
{
};

class CallbackBase
{
public:

r2p2

#include <utils/event/signal.h>

#include <iostream>

class MySlot
{
public:
        void slot()
        {
                std::cout << "foo" << std::endl;

r2p2

class AbstractSocket
{
public:
    AbstractSocket()
        :m_i(0)
    {
    }

    virtual void connect_to_host()
    {