def f(n):
     d = r_dict(myeq, myhash)
     for i in range(10):
         d[i] = i*i
     try:
         return d[n]
     except FooError:
         return 99

 def f():
     d1 = r_dict(eq, raising_hash)
     d1['xxx'] = 1
     try:
         d1["blabla"] = 2
     except TypeError:
         return 42
     return 0

def make_setdata_from_w_iterable(space, w_iterable=None):
    data = r_dict(space.eq_w, space.hash_w)
    if w_iterable is not None:
        w_iterator = space.iter(w_iterable)
        while True:
            try: 
                w_item = space.next(w_iterator)
            except OperationError, e:
                if not e.match(space, space.w_StopIteration):
                    raise
                break
            data[w_item] = None

    def test_customdict_circular(self):
        from pypy.rlib.objectmodel import r_dict
        def key_eq(a, b):
            return a.x[0] == b.x[0]
        def key_hash(a):
            return ord(a.x[0])

        class A:
            def __init__(self, x):
                self.x = x
        a = A('foo')
        a.dict = r_dict(key_eq, key_hash)
        a.dict[a] = 42
        def fn(b):
            if b:
                s = A('foo')
            else:
                s = A('bar')
            return a.dict[s]
        assert self.interpret(fn, [True]) == 42

    def test_constant_r_dict(self):
        def strange_key_eq(key1, key2):
            return key1[0] == key2[0]   # only the 1st character is relevant
        def strange_key_hash(key):
            return ord(key[0])

        d = r_dict(strange_key_eq, strange_key_hash)
        d['hello'] = 42
        d['world'] = 43
        for x in range(65, 91):
            d[chr(x)] = x*x
        def func(i):
            return d[chr(i)]
        res = self.interpret(func, [ord('h')])
        assert res == 42
        res = self.interpret(func, [ord('w')])
        assert res == 43
        for x in range(65, 91):
            res = self.interpret(func, [x])
            assert res == x*x

 def __init__(self, transitions=None):
     if transitions is None:
         transitions = []
     self.transitions = transitions
     self._states_cache = r_dict(state_eq, state_hash)

 def new_ref_dict_2(self):
     return r_dict(rd_eq, rd_hash)

 def oof():
     d = r_dict(strange_key_eq, strange_key_hash)
     d['x'] = 42
     return d['x']

 def __init__(w_self, space, setdata=None):
     if setdata is None:
         w_self.setdata = r_dict(space.eq_w, space.hash_w)
     else:
         w_self.setdata = setdata.copy()

def make_setdata_from_w_iterable(space, w_iterable=None):
    data = r_dict(space.eq_w, space.hash_w)
    if w_iterable is not None:
        for w_item in space.viewiterable(w_iterable):
            data[w_item] = None
    return data

 def initialize_as_rdict(self):
     assert self.r_dict_content is None
     self.r_dict_content = r_dict(self.space.eq_w, self.space.hash_w)
     return self.r_dict_content

    def get_printable_location(shapelen, sig):
        return 'numpy ' + sig.debug_repr() + ' [%d dims,%s]' % (shapelen, driver_name)
    return get_printable_location

def sigeq(one, two):
    return one.eq(two)

def sigeq_no_numbering(one, two):
    """ Cache for iterator numbering should not compare array numbers
    """
    return one.eq(two, compare_array_no=False)

def sighash(sig):
    return sig.hash()

known_sigs = r_dict(sigeq, sighash)

def find_sig(sig, arr):
    sig.invent_array_numbering(arr)
    try:
        return known_sigs[sig]
    except KeyError:
        sig.invent_numbering()
        known_sigs[sig] = sig
        return sig

def _add_ptr_to_cache(ptr, cache):
    i = 0
    for p in cache:
        if ptr == p:
            return i

def dict_equal_consts():
    "NOT_RPYTHON"
    # Returns a dict in which Consts that compare as equal
    # are identified when used as keys.
    return r_dict(dc_eq, dc_hash)

 def ll_set_functions(self, sm_eq, sm_hash):
     "NOT_RPYTHON"
     key_eq = sm_eq._callable
     key_hash = sm_hash._callable
     self._dict = objectmodel.r_dict(key_eq, key_hash)

def new_cache():
    return r_dict(sigeq_no_numbering, sighash)

 def __init__(w_self, space, w_otherdict=None):
     if w_otherdict is None:
         w_self.content = r_dict(space.eq_w, space.hash_w)
     else:
         w_self.content = w_otherdict.content.copy()

 def __init__(self, space):
     self.space = space
     self.content = r_dict(space.eq_w, space.hash_w)
     self.info = DictInfo()
     self.thing_with_del = OnTheWayOut(self.info)