tkhoa2711

import threading

# A thread-safe implementation of Singleton pattern
# To be used as mixin or base class
class Singleton(object):
    
    # use special name mangling for private class-level lock
    # we don't want a global lock for all the classes that use Singleton
    # each class should have its own lock to reduce locking contention
    __lock = threading.Lock()

tkhoa2711

(defun print-list (list)
  (format t "~{~A ~}~%" list))

tkhoa2711

(defun flatten (lst)
  "flatten nested list"
  (labels ((flatten-rec (lst acc)
             (cond ((null lst) acc)
                   ((atom lst) (cons lst acc))
                   (t (flatten-rec
                       (car lst)
                       (flatten-rec (cdr lst) acc))))))
    (flatten-rec lst nil)))

tkhoa2711

"""
An utility module for timing code execution in various ways.
"""

import time
import platform

from functools import wraps
from contextlib import contextmanager

tkhoa2711

(defun read-line-into-list ()
  (with-input-from-string (in (read-line))
    (loop for x = (read in nil nil) while x collect x)))

tkhoa2711

(defun reverse-nested-list (list)
  "reverse nested list"
  (mapcar #'(lambda (l)
              (if (not (consp l))
                  l
                  (reverse-deep l)))
          (reverse list)))

tkhoa2711

(coerce (read-line) 'list)

tkhoa2711

; http://www.ai.sri.com/pkarp/loop.html

tkhoa2711

import time, platform
from collections import defaultdict
from functools import wraps

get_time = time.clock if platform.system() == 'Windows' else time.time

__nop = lambda: None
__throttle_last_time = defaultdict(__nop)

def throttle(duration=1, **kw):

tkhoa2711

def valuedispatch(func):
    """ 
    A simple decorator for multiple dispatch based on values, not types.
    Transform a function into generic function, which can have different behaviours
    depending upon the values of its keyword arguments.
    """
    registry = {}
    
    def register(**kwargs):
        """