def __init__(self, ns, sym, root=UKNOWN):
self.ns = ns
self.sym = sym
self.threadBound = False
if root == UKNOWN:
self.root = AtomicReference(Unbound(self))
else:
self.root = AtomicReference(root)
self._meta = EMPTY
self.rev = 0
self.dynamic = False
self.public = True
if isinstance(self.root.get(), Unbound):
self.rev += 1
def __init__(self, *args):
"""Var initializer
Valid calls:
- Var(namespace, symbol, root)
- Var(namespace, symbol) -- unbound Var
- Var(root) -- anonymous Var
- Var() -- anonymous, unbound Var
"""
self.ns = args[0] if len(args) >= 2 else None
self.sym = args[1] if len(args) >= 2 else None
root = args[-1] if len(args) % 2 else UNKNOWN
self.root = AtomicReference(root if root != UNKNOWN else Unbound(self))
self.threadBound = False
self._meta = EMPTY
self.dynamic = False
self.public = True
class Keyword(IFn, Named, IPrintable):
interned = AtomicReference(EMPTY_MAP)
def __new__(cls, *args):
"""Keyword constructor.
Argument(s) will be passed to Symbol() first. If the keyword was
already interned, it will be returned.
"""
sym = Symbol(*args).withMeta(None)
if sym in Keyword.interned.get():
return Keyword.interned.get()[sym]
obj = super(Keyword, cls).__new__(cls)
Keyword.interned.mutate(
lambda old: old if sym in old else old.assoc(sym, obj))
obj.sym = sym
obj.hash = hash(sym) + 0x9e3779b9
return obj
def __hash__(self):
return self.hash
def __call__(self, obj, notFound=None):
if obj is None:
return None
if self not in obj:
return notFound
return obj[self]
def __repr__(self):
return ":{0}".format(self.sym)
def getNamespace(self):
return self.sym.getNamespace()
def getName(self):
return self.sym.getName()
def writeAsString(self, writer):
writer.write(repr(self))
def writeAsReplString(self, writer):
writer.write(repr(self))
def createNode(*args):
if len(args) == 7:
edit, shift, key1, val1, key2hash, key2, val2 = args
elif len(args) == 6:
shift, key1, val1, key2hash, key2, val2 = args
edit = AtomicReference()
else:
raise ArityException()
if shift > 64:
raise Exception("Shift max reached")
key1hash = hash(key1)
if key1hash == key2hash:
return HashCollisionNode(None, key1hash, 2, [key1, val1, key2, val2])
nbox = Box(None)
nd1 = EMPTY_BITMAP_NODE \
.assocEd(edit, shift, key1hash, key1, val1, nbox)
nd2 = nd1.assocEd(edit, shift, key2hash, key2, val2, nbox)
return nd2
s = RT.seq(seq)
v = EMPTY
while s is not None:
v = v.cons(RT.first(s))
s = RT.next(s)
return v
def create(*args):
"""Return a PersistentVector.
args -- zero or more objects
The returned vector will contain all objects found in args."""
x = EMPTY
for z in args:
x = x.cons(z)
return x
# ======================================================================
# Pseudo-Singletons
# ======================================================================
# currently unused (for Clojure's transient data structures)
NOEDIT = AtomicReference()
# A Node holding no children or vector values
EMPTY_NODE = Node(NOEDIT)
# A PersistentVector containing 0 items
EMPTY = PersistentVector(0, 5, EMPTY_NODE, [])
if self.s is not None:
return createNodeSeq(self.array, self.i, self.s.next())
return createNodeSeq(self.array, self.i + 2, None)
def createNodeSeq(*args):
if len(args) == 1:
if len(args[0]) == 0:
return None
return createNodeSeq(args[0], 0, None)
if len(args) != 3:
raise ArityException()
array, i, s = args
if s is not None:
return NodeSeq(None, array, i, s)
for j in range(i, len(array), 2):
if array[j] is not None:
return NodeSeq(None, array, j, None)
node = array[j+1]
if node is not None:
nodeSeq = node.nodeSeq()
if nodeSeq is not None:
return NodeSeq(None, array, j + 2, nodeSeq)
return None
EMPTY = PersistentHashMap(0, None, False, None)
EMPTY_BITMAP_NODE = BitmapIndexedNode(-1, 0, [])
NOT_FOUND = AtomicReference()
from clojure.lang.symbol import Symbol, symbol
from clojure.lang.persistenthashmap import EMPTY as EMPTY_MAP
from clojure.lang.atomicreference import AtomicReference
from clojure.lang.cljexceptions import InvalidArgumentException, ArityException
from clojure.lang.iprintable import IPrintable
import weakref
from clojure.lang.ifn import IFn
from clojure.lang.named import Named
interned = AtomicReference(EMPTY_MAP)
class Keyword(IFn, Named, IPrintable):
def getNamespace(self):
return self.sym.getNamespace()
def getName(self):
return self.sym.getName()
def writeAsString(self, writer):
writer.write(repr(self))
def writeAsReplString(self, writer):
writer.write(repr(self))
def __init__(self, sym):
self.sym = sym
self.hash = hash(sym) + 0x9e3779b9
def __hash__(self):
return self.hash
from clojure.lang.areference import AReference
from clojure.lang.atomicreference import AtomicReference
from clojure.lang.persistenthashmap import EMPTY as EMPTY_MAP
from clojure.lang.cljexceptions import (InvalidArgumentException,
IllegalStateException, ArityException,
IllegalArgumentException)
import clojure.lang.rt as RT
from clojure.lang.symbol import Symbol, symbol
import sys, types
namespaces = AtomicReference(EMPTY_MAP)
def areDifferentInstancesOfSameClassName(o1, o2):
return o1.__class__ is o2.__class__
def addDefaultImports(mod):
import clojure.lang.rt as RT
import clojure.standardimports as stdimps
for i in dir(stdimps):
if i.startswith("_"):
continue
setattr(mod, i, getattr(stdimps, i))
if "clojure.core" in sys.modules:
core = sys.modules["clojure.core"]
for i in dir(core):
if i.startswith("_"):
continue
setattr(mod, i, getattr(core, i))
return mod
