Data Interchange Format

Source: Dev.to

Dynamically Typed Syntax

File Information

// Data Interchange Format
// File Extension: .data, .schema
// Schema Definition Header File: .schema
// Data Interchange Source File: .data
// .data Files May be Dynamically Typed
// .data Files May be Statically Typed
// .data Files are Required
// .schema Files Must be Statistically Typed
// .schema Files Cannot be Dynamically Typed
// .schema Files are Optional

Data Structure Initialization

// Syntax – Name = {fields}
DataStructure = {
    integer        = 1;    
    float          = 1.0;
    boolean_type   = true;
    character      = 'd';
    string         = "string";
    array          = [];
    hash_map       = [()];
    DataStructure  = {}; 
}

Primitive Initializations

Array Initialization

array = [
    1,
    2,
    3,
    4,
    5
]

Hash‑Map Initialization

hash_map = [
    (1|"string"),
    (2|"string"),
    (3|"string"),
    (4|"string"),
    (5|"string")
]

Re‑statement of File Information

// Data Interchange Format
// File Extension: .data, .schema
// Schema Definition Header File: .schema
// Data Interchange Source File: .data
// .data Files May be Dynamically Typed
// .data Files May be Statically Typed
// .data Files are Required
// .schema Files Must be Statistically Typed
// .schema Files Cannot be Dynamically Typed
// .schema Files are Optional

Option‑Type Syntax

// option name = value;

Data Structure Declaration

// May be Declared with Initialized Fields
// Syntax – type Name = {fields}
// Optional Field Syntax – optional name;
struct DataStructure = {
    option   unsigned_integer_8bit;
    uint16               unsigned_integer_16bit;
    uint32               unsigned_integer_32bit;
    uint64               unsigned_integer_64bit;
    optional    unsigned_integer_128bit;
    option    signed_integer_8bit;
    int16                signed_integer_16bit;
    int32                signed_integer_32bit;
    int64                signed_integer_64bit;
    optional     signed_integer_128bit;
    optionfloat_32bit;
    float64              float_64bit;
    optional   float_128bit;
    bool                 boolean_type;
    option   character_8bit;
    char16               character_16bit;
    optional    character_32bit;
    option    string_8bit;
    str16                string_16bit;
    optional      string_32bit;
    array(5)      one_dimensional_array;
    array(5:2)    two_dimensional_array;
    map      hash_map;
    DataStructure        data_structure;
    EnumatorType         enumerator_type;
}

Enumerator Declaration

// May be Declared with Initialized Fields
// Syntax – type Name = {fields}
enum EnumeratorType = {
    FIRST_VALUE,   // value = 0
    SECOND_VALUE,  // value = 1
    THIRD_VALUE,   // value = 2
    FOURTH_VALUE,  // value = 3
    FIFTH_VALUE    // value = 4
}

Data Structure Initialization

// Syntax – type name = {fields}
DataStructure data_structure = {
    uint8   unsigned_integer_8bit   = null;
    uint16  unsigned_integer_16bit  = 2;
    uint32  unsigned_integer_32bit  = 3;
    uint64  unsigned_integer_64bit  = 4;
    uint128 unsigned_integer_128bit = 5;
    int8    signed_integer_8bit     = null;
    int16   signed_integer_16bit    = -2;
    int32   signed_integer_32bit    = -3;
    int64   signed_integer_64bit    = -4;
    int128  signed_integer_128bit   = -5;
    float32 float_32bit             = null;
    float64 float_64bit             = 2.0;
    float128 float_128bit           = 3.0;
    bool    boolean_type           = true;
    char8   character_8bit         = null;
    char16  character_16bit        = 'c';
    char32  character_32bit        = 'd';
    str8    string_8bit            = null;
    str16   string_16bit           = "string";
    str32   string_32bit           = "string";
    array(5) one_dimensional_array = [];
    array(5:2) two_dimensional_array = [];
    map hash_map = [()];
    DataStructure data_structure = {};
    EnumratorType enumerator_type = FIRST_VALUE;
}

Enumerator Initialization

// Syntax – type name = value;
// OR Null Syntax – type name = null;
EnumeratorType enumerator_type = FIRST_VALUE;

Primitive Initializations (Typed)

bool    boolean_type      = true;
char8   character_8bit    = 's';
float32 float_32bit       = 1.0;
uint8   unsigned_integer_8bit = 1;
str8    string_8bit       = "string";

One‑Dimensional Array Initialization

// Syntax – type(length) name = [values]
// OR Unknown Size Syntax – type(?) name = [values]
// OR Null Syntax – type(length) name = [null]
array(5) one_dimensional_array = [
    1,
    2,
    3,
    4,
    5
]

Two‑Dimensional Array Initialization

// Syntax – type(length:width) name = [values]
// OR Unknown Size Syntax – type(?:?) name = [values]
// OR Null Syntax – type(length:width) name = [null]
array(3:2) two_dimensional_array = [
    1,
    2,
    3,
    4,
    5,
    6
]

Hash‑Map Initialization

// Syntax – type name = [(key|value)]
// OR Null Syntax – type name = [(null|null)]
map hash_map = [
    (1|"string"),
    (2|"string"),
    (3|"string"),
    (4|"string"),
    (5|"string")
]