Data: Difference between revisions

From Adam Colton
Jump to navigation Jump to search
No edit summary
Line 2: Line 2:


== Large Uint ==
== Large Uint ==
We can treat any piece of data as a large unsigned int. The efficient encoding of a large unsigned int is to encode the length as a header:
A uint is a byte slice.
  [1]*0[10]*
  (data uint) LoadUint(l uint) (this uint, rest uint) {
The number of 1's (L) indicates the data length. The length is ((1<<(L-1))+1, with an exception that L==0 is 1. I think there's a better formula, but I haven't found it yet. This has several advantages.
    if l==0{
      b = data[0]
      if b < 129 {
        return b, data[1:]
      }
      if b < 252 {
        return data[1:b-250], data[b-250:]
      }
      return LoadUint(b-251)
    }
    return data[1:l+1], data[l+1:]
  }


== Fundamental Structures ==
== Fundamental Structures ==

Revision as of 15:20, 19 September 2019

Data; it's structure, formatting and storage.

Large Uint

A uint is a byte slice.

 (data uint) LoadUint(l uint) (this uint, rest uint) {
   if l==0{
     b = data[0]
     if b < 129 {
       return b, data[1:]
     }
     if b < 252 {
       return data[1:b-250], data[b-250:]
     }
     return LoadUint(b-251)
   }
   return data[1:l+1], data[l+1:]
 }

Fundamental Structures

Value

A type and bytes where the type indicates how to interpret the bytes.

Array

An ordered list, all of the same type.

Tagged Union

One of a set of types with a tag indicating the type.

Tuple

An ordered list where the tuple type defines the length and the type of each element.

Struct

An unordered list where each element has a tag and a type.

Associative Array

An unordered list where each element has key and value.