Skip to content

Representations of Values

TODO

Annotated(item)

Bases: object

TODO

TODO

Source code in preserves/values.py
287
288
289
290
def __init__(self, item):
    """TODO"""
    self.annotations = []
    self.item = item

peel()

TODO

Source code in preserves/values.py
311
312
313
def peel(self):
    """TODO"""
    return strip_annotations(self, 1)

strip(depth=inf)

TODO

Source code in preserves/values.py
307
308
309
def strip(self, depth=inf):
    """TODO"""
    return strip_annotations(self, depth)

Embedded(value)

TODO

TODO

Source code in preserves/values.py
374
375
376
def __init__(self, value):
    """TODO"""
    self.embeddedValue = value

Float(value)

Bases: object

TODO

TODO

Source code in preserves/values.py
29
30
31
def __init__(self, value):
    """TODO"""
    self.value = value

from_bytes(bs) staticmethod

TODO

Source code in preserves/values.py
73
74
75
76
77
78
79
80
81
82
83
84
@staticmethod
def from_bytes(bs):
    """TODO"""
    vf = struct.unpack('>I', bs)[0]
    if (vf & 0x7f800000) == 0x7f800000:
        # NaN or inf. Preserve quiet/signalling bit by manually expanding to double-precision.
        sign = vf >> 31
        payload = vf & 0x007fffff
        dbs = struct.pack('>Q', (sign << 63) | 0x7ff0000000000000 | (payload << 29))
        return Float(struct.unpack('>d', dbs)[0])
    else:
        return Float(struct.unpack('>f', bs)[0])

ImmutableDict(*args, **kwargs)

Bases: dict

TODO

TODO

Source code in preserves/values.py
237
238
239
240
241
def __init__(self, *args, **kwargs):
    """TODO"""
    if hasattr(self, '__hash'): raise TypeError('Immutable')
    super(ImmutableDict, self).__init__(*args, **kwargs)
    self.__hash = None

from_kvs(kvs) staticmethod

TODO

Source code in preserves/values.py
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
@staticmethod
def from_kvs(kvs):
    """TODO"""
    i = iter(kvs)
    result = ImmutableDict()
    result_proxy = super(ImmutableDict, result)
    try:
        while True:
            k = next(i)
            try:
                v = next(i)
            except StopIteration:
                raise DecodeError("Missing dictionary value")
            result_proxy.__setitem__(k, v)
    except StopIteration:
        pass
    return result

Record(key, fields)

Bases: object

TODO

TODO

Source code in preserves/values.py
138
139
140
141
142
def __init__(self, key, fields):
    """TODO"""
    self.key = key
    self.fields = tuple(fields)
    self.__hash = None

makeBasicConstructor(label, fieldNames) staticmethod

TODO

Source code in preserves/values.py
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
@staticmethod
def makeBasicConstructor(label, fieldNames):
    """TODO"""
    if type(fieldNames) == str:
        fieldNames = fieldNames.split()
    arity = len(fieldNames)
    def ctor(*fields):
        if len(fields) != arity:
            raise Exception("Record: cannot instantiate %r expecting %d fields with %d fields"%(
                label,
                arity,
                len(fields)))
        return Record(label, fields)
    ctor.constructorInfo = RecordConstructorInfo(label, arity)
    ctor.isClassOf = lambda v: \
                     isinstance(v, Record) and v.key == label and len(v.fields) == arity
    def ensureClassOf(v):
        if not ctor.isClassOf(v):
            raise TypeError("Record: expected %r/%d, got %r" % (label, arity, v))
        return v
    ctor.ensureClassOf = ensureClassOf
    for fieldIndex in range(len(fieldNames)):
        fieldName = fieldNames[fieldIndex]
        # Stupid python scoping bites again
        def getter(fieldIndex):
            return lambda v: ensureClassOf(v)[fieldIndex]
        setattr(ctor, '_' + fieldName, getter(fieldIndex))
    return ctor

makeConstructor(labelSymbolText, fieldNames) staticmethod

TODO

Source code in preserves/values.py
177
178
179
180
@staticmethod
def makeConstructor(labelSymbolText, fieldNames):
    """TODO"""
    return Record.makeBasicConstructor(Symbol(labelSymbolText), fieldNames)

RecordConstructorInfo(key, arity)

Bases: object

TODO

TODO

Source code in preserves/values.py
213
214
215
216
def __init__(self, key, arity):
    """TODO"""
    self.key = key
    self.arity = arity

Symbol(name)

Bases: object

TODO

TODO

Source code in preserves/values.py
91
92
93
def __init__(self, name):
    """TODO"""
    self.name = name.name if isinstance(name, Symbol) else name

annotate(v, *anns)

TODO

Source code in preserves/values.py
358
359
360
361
362
363
364
def annotate(v, *anns):
    """TODO"""
    if not is_annotated(v):
        v = Annotated(v)
    for a in anns:
        v.annotations.append(a)
    return v

cmp_floats(a, b)

TODO

Source code in preserves/values.py
19
20
21
22
23
24
25
def cmp_floats(a, b):
    """TODO"""
    a = float_to_int(a)
    b = float_to_int(b)
    if a & 0x8000000000000000: a = a ^ 0x7fffffffffffffff
    if b & 0x8000000000000000: b = b ^ 0x7fffffffffffffff
    return a - b

dict_kvs(d)

TODO

Source code in preserves/values.py
277
278
279
280
281
def dict_kvs(d):
    """TODO"""
    for k in d:
        yield k
        yield d[k]

is_annotated(v)

TODO

Source code in preserves/values.py
327
328
329
def is_annotated(v):
    """TODO"""
    return isinstance(v, Annotated)

preserve(v)

TODO

Source code in preserves/values.py
10
11
12
13
14
def preserve(v):
    """TODO"""
    while hasattr(v, '__preserve__'):
        v = v.__preserve__()
    return v

strip_annotations(v, depth=inf)

TODO

Source code in preserves/values.py
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
def strip_annotations(v, depth=inf):
    """TODO"""
    if depth == 0: return v
    if not is_annotated(v): return v

    next_depth = depth - 1
    def walk(v):
        return strip_annotations(v, next_depth)

    v = v.item
    if isinstance(v, Record):
        return Record(strip_annotations(v.key, depth), tuple(walk(f) for f in v.fields))
    elif isinstance(v, list):
        return tuple(walk(f) for f in v)
    elif isinstance(v, tuple):
        return tuple(walk(f) for f in v)
    elif isinstance(v, set):
        return frozenset(walk(f) for f in v)
    elif isinstance(v, frozenset):
        return frozenset(walk(f) for f in v)
    elif isinstance(v, dict):
        return ImmutableDict.from_kvs(walk(f) for f in dict_kvs(v))
    elif is_annotated(v):
        raise ValueError('Improper annotation structure')
    else:
        return v