Ceasar

import os
from pprint import pprint

MAP = {}

CHILDREN_KEY = 'children'


for path, _, filenames in os.walk('./templates'):
    path = path.split("/")[2:]

Ceasar

class RingBuffer(object):
    def __init__(self, items=None):
        self._left = 0
        self._right = 0
        self._length = 0
        self._items = []
        if items is not None:
            for item in items:
                self.append(item)

Ceasar

#!/usr/bin/env python
#-*- mode: python -*-
import sh

sh.make()
sh.nosetests()

Ceasar

/*
 * Example of higher order functions in C.
 */
#include <stdio.h>


void func ( void (*f)(int, int) ) {
    int ctr = 0; 
    for (ctr; ctr < 5; ctr++) {
        (*f)(ctr, ctr);

Ceasar

import Data.List


-- Evaluate a postfix expression
evalPostfix :: (Num a, Read a) => String -> a
evalPostfix = head . foldl comb [] . words
  where
    comb (x:y:ys) "*" = (x * y) : ys
    comb (x:y:ys) "+" = (x + y) : ys
    comb (x:y:ys) "-" = (y - x) : ys

Ceasar

'''Crudely joins multiple tables together.'''
import sys
import itertools

import table

def join(tables, name=None):
  if name is None:
    name = "_".join([table.filename for table in tables])
  joined = Table(name, [fieldname for table in tables

Ceasar

-- In Divide and Conquer, we solve a problem recursively, applying three steps at each level of recursion.



dnc :: (a -> [a]) -> (a -> b) -> ([b] -> b) -> a -> b
dnc divide con comb x = case divide x of
                        [] -> con x
                        xs -> comb $ map (dnc divide con comb) xs

Ceasar

> import Data.Set as S
> import Data.Map as M
> import Data.Maybe
> import Control.Monad (liftM, liftM2)

> import Test.QuickCheck

A statement is a sentence that is determinately true of determinately false independently of the circumstances in which it is used.

> data Proposition = Implies Proposition Proposition

Ceasar

def partition(pred, items):
    """
    Take a predicate and a list and return a pair of lists: those elements
    that do and do not satisfy the predicate, respectively.

    >>> partition(str.isalpha, "ab1c")
    (['a', 'b', 'c'], ['1'])

    >>> partition(str.isalpha, [])
    ([], [])

Ceasar

$(document).ready(function () {
  setTimeout(function(){while(1){};},10000);
});