← Back to branch summary

~ubuntu-branches/ubuntu/karmic/pypy/karmic

« back to all changes in this revision

Viewing changes to pypy/objspace/std/setobject.py

  • Committer: Bazaar Package Importer
  • Author(s): Alexandre Fayolle
  • Date: 2007-04-13 09:33:09 UTC
  • Revision ID: james.westby@ubuntu.com-20070413093309-yoojh4jcoocu2krz
Tags: upstream-1.0.0
Import upstream version 1.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
pypy/objspace/std/setobject.py
 
1
from pypy.objspace.std.objspace import W_Object, OperationError
 
2
from pypy.objspace.std.objspace import registerimplementation, register_all
 
3
from pypy.rlib.objectmodel import r_dict
 
4
from pypy.rlib.rarithmetic import intmask, r_uint
 
5
from pypy.interpreter import gateway
 
6
 
 
7
class W_BaseSetObject(W_Object):
 
8
 
 
9
    def __init__(w_self, space, setdata=None):
 
10
        if setdata is None:
 
11
            w_self.setdata = r_dict(space.eq_w, space.hash_w)
 
12
        else:
 
13
            w_self.setdata = setdata.copy()
 
14
 
 
15
    def __repr__(w_self):
 
16
        """representation for debugging purposes"""
 
17
        reprlist = [repr(w_item) for w_item in w_self.setdata.keys()]
 
18
        return "<%s(%s)>" % (w_self.__class__.__name__, ', '.join(reprlist))
 
19
 
 
20
    def _newobj(w_self, space, rdict_w=None):
 
21
        #return space.call(space.type(w_self),W_SetIterObject(rdict_w))
 
22
        objtype = type(w_self)
 
23
        if objtype is W_SetObject:
 
24
            obj = W_SetObject(space, rdict_w)
 
25
        elif objtype is W_FrozensetObject:
 
26
            obj = W_FrozensetObject(space, rdict_w)
 
27
        else:
 
28
            itemiterator = space.iter(W_SetIterObject(rdict_w))
 
29
            obj = space.call_function(space.type(w_self),itemiterator)
 
30
        return obj
 
31
 
 
32
class W_SetObject(W_BaseSetObject):
 
33
    from pypy.objspace.std.settype import set_typedef as typedef
 
34
 
 
35
class W_FrozensetObject(W_BaseSetObject):
 
36
    from pypy.objspace.std.frozensettype import frozenset_typedef as typedef
 
37
 
 
38
    def __init__(w_self, space, setdata):
 
39
        W_BaseSetObject.__init__(w_self, space, setdata)
 
40
        w_self.hash = -1
 
41
 
 
42
registerimplementation(W_SetObject)
 
43
registerimplementation(W_FrozensetObject)
 
44
 
 
45
class W_SetIterObject(W_Object):
 
46
    from pypy.objspace.std.settype import setiter_typedef as typedef
 
47
 
 
48
    def __init__(w_self, setdata):
 
49
        w_self.content = content = setdata
 
50
        w_self.len = len(content)
 
51
        w_self.pos = 0
 
52
        w_self.iterator = w_self.content.iterkeys()
 
53
 
 
54
    def next_entry(w_self):
 
55
        for w_key in w_self.iterator:
 
56
            return w_key
 
57
        else:
 
58
            return None
 
59
 
 
60
registerimplementation(W_SetIterObject)
 
61
 
 
62
def iter__SetIterObject(space, w_setiter):
 
63
    return w_setiter
 
64
 
 
65
def next__SetIterObject(space, w_setiter):
 
66
    content = w_setiter.content
 
67
    if content is not None:
 
68
        if w_setiter.len != len(content):
 
69
            w_setiter.len = -1   # Make this error state sticky
 
70
            raise OperationError(space.w_RuntimeError,
 
71
                     space.wrap("dictionary changed size during iteration"))
 
72
        # look for the next entry
 
73
        w_result = w_setiter.next_entry()
 
74
        if w_result is not None:
 
75
            w_setiter.pos += 1
 
76
            return w_result
 
77
        # no more entries
 
78
        w_setiter.content = None
 
79
    raise OperationError(space.w_StopIteration, space.w_None)
 
80
 
 
81
def len__SetIterObject(space, w_setiter):
 
82
    content = w_setiter.content
 
83
    if content is None or w_setiter.len == -1:
 
84
        return space.wrap(0)
 
85
    return space.wrap(w_setiter.len - w_setiter.pos)
 
86
 
 
87
# some helper functions
 
88
 
 
89
def make_setdata_from_w_iterable(space, w_iterable=None):
 
90
    data = r_dict(space.eq_w, space.hash_w)
 
91
    if w_iterable is not None:
 
92
        w_iterator = space.iter(w_iterable)
 
93
        while True:
 
94
            try: 
 
95
                w_item = space.next(w_iterator)
 
96
            except OperationError, e:
 
97
                if not e.match(space, space.w_StopIteration):
 
98
                    raise
 
99
                break
 
100
            data[w_item] = None
 
101
    return data
 
102
 
 
103
def _initialize_set(space, w_obj, w_iterable=None):
 
104
    w_obj.setdata.clear()
 
105
    if w_iterable is not None:
 
106
        w_obj.setdata.update(make_setdata_from_w_iterable(space, w_iterable))
 
107
 
 
108
# helper functions for set operation on dicts
 
109
 
 
110
def _is_frozenset_exact(w_obj):
 
111
    if (w_obj is not None) and (type(w_obj) is W_FrozensetObject):
 
112
        return True
 
113
    else:
 
114
        return False
 
115
 
 
116
def _is_eq(w_left, w_right):
 
117
    if len(w_left.setdata) != len(w_right.setdata):
 
118
        return False
 
119
    for w_key in w_left.setdata:
 
120
        if w_key not in w_right.setdata:
 
121
            return False
 
122
    return True
 
123
 
 
124
def _union_dict(ldict, rdict, isupdate):
 
125
    if isupdate:
 
126
        ld = ldict
 
127
    else:
 
128
        ld = ldict.copy()
 
129
    ld.update(rdict)
 
130
    return ld, rdict
 
131
 
 
132
def _difference_dict(ldict, rdict, isupdate):
 
133
    if isupdate:
 
134
        ld = ldict
 
135
    else:
 
136
        ld = ldict.copy()
 
137
    del_list_w = []
 
138
    for w_key in ld:
 
139
        if w_key in rdict:
 
140
            del_list_w.append(w_key)
 
141
    for w_key in del_list_w:
 
142
        del ld[w_key]
 
143
 
 
144
    return ld, rdict
 
145
 
 
146
def _intersection_dict(ldict, rdict, isupdate):
 
147
    if isupdate:
 
148
        ld = ldict
 
149
    else:
 
150
        ld = ldict.copy()
 
151
    del_list_w = []
 
152
    for w_key in ld:
 
153
        if w_key not in rdict:
 
154
            del_list_w.append(w_key)
 
155
 
 
156
    for w_key in del_list_w:
 
157
        del ld[w_key]
 
158
 
 
159
    return ld, rdict
 
160
 
 
161
 
 
162
def _symmetric_difference_dict(ldict, rdict, isupdate):
 
163
    if isupdate:
 
164
        ld = ldict
 
165
    else:
 
166
        ld = ldict.copy()
 
167
    del_list_w = []
 
168
    add_list_w = []
 
169
    for w_key in ld:
 
170
        if w_key in rdict:
 
171
            del_list_w.append(w_key)
 
172
 
 
173
    for w_key in rdict:
 
174
        if w_key not in ld:
 
175
            add_list_w.append(w_key)
 
176
 
 
177
    for w_key in del_list_w:
 
178
        del ld[w_key]
 
179
 
 
180
    for w_key in add_list_w:
 
181
        ld[w_key] = None
 
182
 
 
183
    return ld, rdict
 
184
 
 
185
#end helper functions
 
186
 
 
187
def set_update__Set_Set(space, w_left, w_other):
 
188
    ld, rd = w_left.setdata, w_other.setdata
 
189
    new_ld, rd = _union_dict(ld, rd, True)
 
190
    return space.w_None
 
191
 
 
192
set_update__Set_Frozenset = set_update__Set_Set
 
193
 
 
194
def set_update__Set_ANY(space, w_left, w_other):
 
195
    """Update a set with the union of itself and another."""
 
196
    ld, rd = w_left.setdata, make_setdata_from_w_iterable(space, w_other)
 
197
    new_ld, rd = _union_dict(ld, rd, True)
 
198
    return space.w_None
 
199
 
 
200
def inplace_or__Set_Set(space, w_left, w_other):
 
201
    set_update__Set_Set(space, w_left, w_other)
 
202
    return w_left
 
203
 
 
204
inplace_or__Set_Frozenset = inplace_or__Set_Set
 
205
 
 
206
def set_add__Set_ANY(space, w_left, w_other):
 
207
    """Add an element to a set.
 
208
 
 
209
    This has no effect if the element is already present.
 
210
    """
 
211
    w_left.setdata[w_other] = None
 
212
    return space.w_None
 
213
 
 
214
def set_copy__Set(space, w_set):
 
215
    return w_set._newobj(space,w_set.setdata)
 
216
 
 
217
def frozenset_copy__Frozenset(space, w_left):
 
218
    if _is_frozenset_exact(w_left):
 
219
        return w_left
 
220
    else:
 
221
        return set_copy__Set(space,w_left)
 
222
 
 
223
def set_clear__Set(space, w_left):
 
224
    w_left.setdata.clear()
 
225
    return space.w_None
 
226
 
 
227
def set_difference__Set_Set(space, w_left, w_other):
 
228
    ld, rd = w_left.setdata, w_other.setdata
 
229
    new_ld, rd = _difference_dict(ld, rd, False)
 
230
    return w_left._newobj(space, new_ld)
 
231
 
 
232
set_difference__Set_Frozenset = set_difference__Set_Set
 
233
frozenset_difference__Frozenset_Set = set_difference__Set_Set
 
234
frozenset_difference__Frozenset_Frozenset = set_difference__Set_Set
 
235
sub__Set_Set = set_difference__Set_Set
 
236
sub__Set_Frozenset = set_difference__Set_Set
 
237
sub__Frozenset_Set = set_difference__Set_Set
 
238
sub__Frozenset_Frozenset = set_difference__Set_Set
 
239
 
 
240
def set_difference__Set_ANY(space, w_left, w_other):
 
241
    ld, rd = w_left.setdata, make_setdata_from_w_iterable(space, w_other)
 
242
    new_ld, rd = _difference_dict(ld, rd, False)
 
243
    return w_left._newobj(space, new_ld)
 
244
 
 
245
frozenset_difference__Frozenset_ANY = set_difference__Set_ANY
 
246
 
 
247
 
 
248
def set_difference_update__Set_Set(space, w_left, w_other):
 
249
    ld, rd = w_left.setdata, w_other.setdata
 
250
    new_ld, rd = _difference_dict(ld, rd, True)
 
251
    return space.w_None
 
252
 
 
253
set_difference_update__Set_Frozenset = set_difference_update__Set_Set
 
254
 
 
255
def set_difference_update__Set_ANY(space, w_left, w_other):
 
256
    ld, rd = w_left.setdata, make_setdata_from_w_iterable(space, w_other)
 
257
    new_ld, rd = _difference_dict(ld, rd, True)
 
258
    return space.w_None
 
259
 
 
260
def inplace_sub__Set_Set(space, w_left, w_other):
 
261
    set_difference_update__Set_Set(space, w_left, w_other)
 
262
    return w_left
 
263
 
 
264
inplace_sub__Set_Frozenset = inplace_sub__Set_Set
 
265
 
 
266
def eq__Set_Set(space, w_left, w_other):
 
267
    return space.wrap(_is_eq(w_left, w_other))
 
268
 
 
269
eq__Set_Frozenset = eq__Set_Set
 
270
eq__Frozenset_Frozenset = eq__Set_Set
 
271
eq__Frozenset_Set = eq__Set_Set
 
272
 
 
273
def eq__Set_ANY(space, w_left, w_other):
 
274
    return space.w_False
 
275
 
 
276
eq__Frozenset_ANY = eq__Set_ANY
 
277
 
 
278
def contains__Set_Set(space, w_left, w_other):
 
279
    w_f = space.newfrozenset(w_other.setdata)
 
280
    return space.newbool(w_f in w_left.setdata)
 
281
 
 
282
contains__Frozenset_Set = contains__Set_Set
 
283
 
 
284
def contains__Set_ANY(space, w_left, w_other):
 
285
    return space.newbool(w_other in w_left.setdata)
 
286
 
 
287
contains__Frozenset_ANY = contains__Set_ANY
 
288
 
 
289
def set_issubset__Set_Set(space, w_left, w_other):
 
290
    if space.is_w(w_left, w_other):
 
291
        return space.w_True
 
292
    ld, rd = w_left.setdata, w_other.setdata
 
293
    if len(ld) > len(rd):
 
294
        return space.w_False
 
295
 
 
296
    for w_key in ld:
 
297
        if w_key not in rd:
 
298
            return space.w_False
 
299
    return space.w_True
 
300
 
 
301
set_issubset__Set_Frozenset = set_issubset__Set_Set
 
302
frozenset_issubset__Frozenset_Set = set_issubset__Set_Set
 
303
frozenset_issubset__Frozenset_Frozenset = set_issubset__Set_Set
 
304
 
 
305
def set_issubset__Set_ANY(space, w_left, w_other):
 
306
    if space.is_w(w_left, w_other):
 
307
        return space.w_True
 
308
 
 
309
    ld, rd = w_left.setdata, make_setdata_from_w_iterable(space, w_other)
 
310
    if len(ld) > len(rd):
 
311
        return space.w_False
 
312
 
 
313
    for w_key in ld:
 
314
        if w_key not in rd:
 
315
            return space.w_False
 
316
    return space.w_True
 
317
 
 
318
frozenset_issubset__Frozenset_ANY = set_issubset__Set_ANY
 
319
 
 
320
le__Set_Set = set_issubset__Set_Set
 
321
le__Set_Frozenset = set_issubset__Set_Set
 
322
le__Frozenset_Frozenset = set_issubset__Set_Set
 
323
 
 
324
def set_issuperset__Set_Set(space, w_left, w_other):
 
325
    if space.is_w(w_left, w_other):
 
326
        return space.w_True
 
327
 
 
328
    ld, rd = w_left.setdata, w_other.setdata
 
329
    if len(ld) < len(rd):
 
330
        return space.w_False
 
331
 
 
332
    for w_key in rd:
 
333
        if w_key not in ld:
 
334
            return space.w_False
 
335
    return space.w_True
 
336
 
 
337
set_issuperset__Set_Frozenset = set_issuperset__Set_Set
 
338
set_issuperset__Frozenset_Set = set_issuperset__Set_Set
 
339
set_issuperset__Frozenset_Frozenset = set_issuperset__Set_Set
 
340
 
 
341
def set_issuperset__Set_ANY(space, w_left, w_other):
 
342
    if space.is_w(w_left, w_other):
 
343
        return space.w_True
 
344
 
 
345
    ld, rd = w_left.setdata, make_setdata_from_w_iterable(space, w_other)
 
346
    if len(ld) < len(rd):
 
347
        return space.w_False
 
348
 
 
349
    for w_key in rd:
 
350
        if w_key not in ld:
 
351
            return space.w_False
 
352
    return space.w_True
 
353
 
 
354
frozenset_issuperset__Frozenset_ANY = set_issuperset__Set_ANY
 
355
 
 
356
ge__Set_Set = set_issuperset__Set_Set
 
357
ge__Set_Frozenset = set_issuperset__Set_Set
 
358
ge__Frozenset_Frozenset = set_issuperset__Set_Set
 
359
 
 
360
def set_discard__Set_Set(space, w_left, w_item):
 
361
    w_f = space.newfrozenset(w_item.setdata)
 
362
    if w_f in w_left.setdata:
 
363
        del w_left.setdata[w_f]
 
364
 
 
365
def set_discard__Set_ANY(space, w_left, w_item):
 
366
    if w_item in w_left.setdata:
 
367
        del w_left.setdata[w_item]
 
368
 
 
369
def set_remove__Set_Set(space, w_left, w_item):
 
370
    w_f = space.newfrozenset(w_item.setdata)
 
371
    try:
 
372
        del w_left.setdata[w_f]
 
373
    except KeyError:
 
374
        raise OperationError(space.w_KeyError,
 
375
                space.call_method(w_item,'__repr__'))
 
376
 
 
377
def set_remove__Set_ANY(space, w_left, w_item):
 
378
    try:
 
379
        del w_left.setdata[w_item]
 
380
    except KeyError:
 
381
        raise OperationError(space.w_KeyError,
 
382
                space.call_method(w_item,'__repr__'))
 
383
 
 
384
def hash__Frozenset(space, w_set):
 
385
    multi = r_uint(1822399083) + r_uint(1822399083) + 1
 
386
    if w_set.hash != -1:
 
387
        return space.wrap(w_set.hash)
 
388
    hash = 1927868237
 
389
    hash *= (len(w_set.setdata) + 1)
 
390
    for w_item in w_set.setdata:
 
391
        h = space.hash_w(w_item)
 
392
        value = ((h ^ (h << 16) ^ 89869747)  * multi)
 
393
        hash = intmask(hash ^ value)
 
394
    hash = hash * 69069 + 907133923
 
395
    if hash == -1:
 
396
        hash = 590923713
 
397
    hash = intmask(hash)
 
398
    w_set.hash = hash
 
399
 
 
400
    return space.wrap(hash)
 
401
 
 
402
def set_pop__Set(space, w_left):
 
403
    if len(w_left.setdata) == 0:
 
404
        raise OperationError(space.w_KeyError,
 
405
                                space.wrap('pop from an empty set'))
 
406
    w_keys = w_left.setdata.keys()
 
407
    w_value = w_keys[0]
 
408
    del w_left.setdata[w_value]
 
409
 
 
410
    return w_value
 
411
 
 
412
def set_intersection__Set_Set(space, w_left, w_other):
 
413
    ld, rd = w_left.setdata, w_other.setdata
 
414
    new_ld, rd = _intersection_dict(ld, rd, False)
 
415
    return w_left._newobj(space,new_ld)
 
416
 
 
417
set_intersection__Set_Frozenset = set_intersection__Set_Set
 
418
set_intersection__Frozenset_Frozenset = set_intersection__Set_Set
 
419
set_intersection__Frozenset_Set = set_intersection__Set_Set
 
420
 
 
421
def set_intersection__Set_ANY(space, w_left, w_other):
 
422
    ld, rd = w_left.setdata, make_setdata_from_w_iterable(space, w_other)
 
423
    new_ld, rd = _intersection_dict(ld, rd, False)
 
424
    return w_left._newobj(space,new_ld)
 
425
 
 
426
frozenset_intersection__Frozenset_ANY = set_intersection__Set_ANY
 
427
 
 
428
and__Set_Set = set_intersection__Set_Set
 
429
and__Set_Frozenset = set_intersection__Set_Set
 
430
and__Frozenset_Set = set_intersection__Set_Set
 
431
and__Frozenset_Frozenset = set_intersection__Set_Set
 
432
 
 
433
def set_intersection_update__Set_Set(space, w_left, w_other):
 
434
    ld, rd = w_left.setdata, w_other.setdata
 
435
    new_ld, rd = _intersection_dict(ld, rd, True)
 
436
    return space.w_None
 
437
 
 
438
set_intersection_update__Set_Frozenset = set_intersection_update__Set_Set
 
439
 
 
440
def set_intersection_update__Set_ANY(space, w_left, w_other):
 
441
    ld, rd = w_left.setdata, make_setdata_from_w_iterable(space, w_other)
 
442
    new_ld, rd = _intersection_dict(ld, rd, True)
 
443
    return space.w_None
 
444
 
 
445
def inplace_and__Set_Set(space, w_left, w_other):
 
446
    set_intersection_update__Set_Set(space, w_left, w_other)
 
447
    return w_left
 
448
 
 
449
inplace_and__Set_Frozenset = inplace_and__Set_Set
 
450
 
 
451
def set_symmetric_difference__Set_Set(space, w_left, w_other):
 
452
    ld, rd = w_left.setdata, w_other.setdata
 
453
    new_ld, rd = _symmetric_difference_dict(ld, rd, False)
 
454
    return w_left._newobj(space, new_ld)
 
455
 
 
456
set_symmetric_difference__Set_Frozenset = set_symmetric_difference__Set_Set
 
457
set_symmetric_difference__Frozenset_Set = set_symmetric_difference__Set_Set
 
458
set_symmetric_difference__Frozenset_Frozenset = \
 
459
                                        set_symmetric_difference__Set_Set
 
460
 
 
461
xor__Set_Set = set_symmetric_difference__Set_Set
 
462
xor__Set_Frozenset = set_symmetric_difference__Set_Set
 
463
xor__Frozenset_Set = set_symmetric_difference__Set_Set
 
464
xor__Frozenset_Frozenset = set_symmetric_difference__Set_Set
 
465
 
 
466
 
 
467
def set_symmetric_difference__Set_ANY(space, w_left, w_other):
 
468
    ld, rd = w_left.setdata, make_setdata_from_w_iterable(space, w_other)
 
469
    new_ld, rd = _symmetric_difference_dict(ld, rd, False)
 
470
    return w_left._newobj(space, new_ld)
 
471
 
 
472
frozenset_symmetric_difference__Frozenset_ANY = \
 
473
        set_symmetric_difference__Set_ANY
 
474
 
 
475
def set_symmetric_difference_update__Set_Set(space, w_left, w_other):
 
476
    ld, rd = w_left.setdata, w_other.setdata
 
477
    new_ld, rd = _symmetric_difference_dict(ld, rd, True)
 
478
    return space.w_None
 
479
 
 
480
set_symmetric_difference_update__Set_Frozenset = \
 
481
                                    set_symmetric_difference_update__Set_Set
 
482
 
 
483
def set_symmetric_difference_update__Set_ANY(space, w_left, w_other):
 
484
    ld, rd = w_left.setdata, make_setdata_from_w_iterable(space, w_other)
 
485
    new_ld, rd = _symmetric_difference_dict(ld, rd, True)
 
486
    return space.w_None
 
487
 
 
488
def inplace_xor__Set_Set(space, w_left, w_other):
 
489
    set_symmetric_difference_update__Set_Set(space, w_left, w_other)
 
490
    return w_left
 
491
 
 
492
inplace_xor__Set_Frozenset = inplace_xor__Set_Set
 
493
 
 
494
def set_union__Set_Set(space, w_left, w_other):
 
495
    ld, rd = w_left.setdata, w_other.setdata
 
496
    new_ld, rd = _union_dict(ld, rd, False)
 
497
    return w_left._newobj(space, new_ld)
 
498
 
 
499
set_union__Set_Frozenset = set_union__Set_Set
 
500
set_union__Frozenset_Set = set_union__Set_Set
 
501
set_union__Frozenset_Frozenset = set_union__Set_Set
 
502
or__Set_Set = set_union__Set_Set
 
503
or__Set_Frozenset = set_union__Set_Set
 
504
or__Frozenset_Set = set_union__Set_Set
 
505
or__Frozenset_Frozenset = set_union__Set_Set
 
506
 
 
507
 
 
508
def set_union__Set_ANY(space, w_left, w_other):
 
509
    ld, rd = w_left.setdata, make_setdata_from_w_iterable(space, w_other)
 
510
    new_ld, rd = _union_dict(ld, rd, False)
 
511
    return w_left._newobj(space, new_ld)
 
512
 
 
513
frozenset_union__Frozenset_ANY = set_union__Set_ANY
 
514
 
 
515
def len__Set(space, w_left):
 
516
    return space.newint(len(w_left.setdata))
 
517
 
 
518
len__Frozenset = len__Set
 
519
 
 
520
def iter__Set(space, w_left):
 
521
    return W_SetIterObject(w_left.setdata)
 
522
 
 
523
iter__Frozenset = iter__Set
 
524
 
 
525
def cmp__Set_Set(space, w_left, w_other):
 
526
    raise OperationError(space.w_TypeError,
 
527
            space.wrap('cannot compare sets using cmp()'))
 
528
 
 
529
cmp__Set_Frozenset = cmp__Set_Set
 
530
cmp__Frozenset_Frozenset = cmp__Set_Set
 
531
cmp__Frozenset_Set = cmp__Set_Set
 
532
 
 
533
def init__Set(space, w_set, __args__):
 
534
    w_iterable, = __args__.parse('set',
 
535
                            (['some_iterable'], None, None),
 
536
                            [space.newtuple([])])
 
537
    _initialize_set(space, w_set, w_iterable)
 
538
 
 
539
def init__Frozenset(space, w_set, __args__):
 
540
    w_iterable, = __args__.parse('set',
 
541
                            (['some_iterable'], None, None),
 
542
                            [space.newtuple([])])
 
543
    if w_set.hash == -1:
 
544
        _initialize_set(space, w_set, w_iterable)
 
545
        hash__Frozenset(space, w_set)
 
546
 
 
547
app = gateway.applevel("""
 
548
    def ne__Set_ANY(s, o):
 
549
        return not s == o
 
550
 
 
551
    def gt__Set_Set(s, o):
 
552
        return s != o and s.issuperset(o)
 
553
 
 
554
    def lt__Set_Set(s, o):
 
555
        return s != o and s.issubset(o)
 
556
 
 
557
    def repr__Set(s):
 
558
        return '%s(%s)' % (s.__class__.__name__, [x for x in s])
 
559
 
 
560
    def reduce__Set(s):
 
561
        dict = getattr(s,'__dict__', None)
 
562
        return (s.__class__, (tuple(s),), dict)
 
563
 
 
564
""", filename=__file__)
 
565
 
 
566
ne__Set_ANY = app.interphook("ne__Set_ANY")
 
567
ne__Frozenset_ANY = ne__Set_ANY
 
568
 
 
569
gt__Set_Set = app.interphook("gt__Set_Set")
 
570
gt__Set_Frozenset = gt__Set_Set
 
571
gt__Frozenset_Set = gt__Set_Set
 
572
gt__Frozenset_Frozenset = gt__Set_Set
 
573
 
 
574
lt__Set_Set = app.interphook("lt__Set_Set")
 
575
lt__Set_Frozenset = lt__Set_Set
 
576
lt__Frozenset_Set = lt__Set_Set
 
577
lt__Frozenset_Frozenset = lt__Set_Set
 
578
 
 
579
repr__Set = app.interphook('repr__Set')
 
580
repr__Frozenset = app.interphook('repr__Set')
 
581
 
 
582
set_reduce__Set = app.interphook('reduce__Set')
 
583
frozenset_reduce__Frozenset = app.interphook('reduce__Set')
 
584
 
 
585
from pypy.objspace.std import frozensettype
 
586
from pypy.objspace.std import settype
 
587
 
 
588
register_all(vars(), settype, frozensettype)