Tenet language

Tenet is an intuitive language to share data between systems with consistent and reliable semantics.

Source

Examples

This is a tech demo at the moment, so these examples let you see how the compiler works step by step. When Tenet has a working compiler, the site will be refocused on the target audience.

CodeMirror didn't run; is Javascript enabled?

Types

Tenet lets you define complex types using tuples, unions, enums, lists, sets, maps, strings and integers. Read more.

type Category :=
    #raw_material          |  ;; | splits up parts of a union
    work_in_progress ~ Int |  ;; #enums and complex parts may be mixed.
    #finished_good         |
    #service_inventory     |
    #transportation        |
    future ~ Str;

type Inventory := (       ;; This is a record type.
    sku: Str,
    item_name: Str,
    alt_names: [Str],     ;; Represents a list of names
    category: Category,
    vendor: Str,
    inventory_count: Int,
    base_price: Int
);

;; This will be accepted as a member of Category.

let cat = #finished_good;

;; This will be accepted as a member of Inventory.

let inv = (
    sku: "AZAZ1234",
    item_name: "Box",
    alt_names: [],        ;; Empty lists have a well-defined implicit type.
    category: #raw_material,
    vendor: "Boxes, Inc.",
    inventory_count: 500,
    base_price: 12
);

;; Note the empty set. This works in Tenet, but can't be exported as some languages can't declare containers with an
;; empty type. Tenet prohibits exporting such a value to avoid requiring a type change to add a new language. We can
;; make it exportable by annotating the type.

let inv_exportable : Inventory := inv;

type Category := (
    #raw_material |
    work_in_progress~Int |
    #finished_good |
    #service_inventory |
    #transportation |
    future~Str
);

type Inventory := (
    sku: Str,
    item_name: Str,
    alt_names: [Str],
    category: Category,
    vendor: Str,
    inventory_count: Int,
    base_price: Int
);

cat := #finished_good;

inv := (
    sku: "AZAZ1234",
    item_name: "Box",
    alt_names: [],
    category: #raw_material,
    vendor: "Boxes, Inc.",
    inventory_count: 500,
    base_price: 12
);

inv_exportable := inv;

type Category := [!Union
  finished_good:[!Record]
  future:!Str
  raw_material:[!Record]
  service_inventory:[!Record]
  transportation:[!Record]
  work_in_progress:!Int
];
type Inventory := [!Record
  alt_names:[!List !Str]
  base_price:!Int
  category:Category
  inventory_count:!Int
  item_name:!Str
  sku:!Str
  vendor:!Str
];
def cat := #finished_good;
def inv := [.
  alt_names:[list]
  base_price:12
  category:#raw_material
  inventory_count:500
  item_name:"Box"
  sku:"AZAZ1234"
  vendor:"Boxes, Inc."
];
def inv_exportable := inv;

Functions

Unlike most serialization languages, Tenet is fully programmable, so you can define complex behavior along with types, but it has very predictable and simple semantics.

func inventory_summary(inventory: [Inventory]) {
    ;; Construct an empty map.
    summary := {:};
    for entry in inventory {
        ;; Extract the fields we're interested in.
        (category, vendor) := entry;
        ;; Tenet supports complex keys in maps.
        key := (category:, vendor:);
        ;; Count the items found, by defaulting to 0.
        if key not in summary {
            summary[key] := 0
        }
        summary[key] += 1
    }
    ;; Returns the combined map.
    return summary
}

func inventory_summary(inventory: [Inventory]) {
    summary := { : };
    for entry in inventory {
        (category, vendor) := entry;
        key := (category:, vendor:);
        if key not in summary {
            summary[key] := 0;
        }
        summary[key] += 1;
    }
    return summary;
}

func inventory_summary(inventory: [Inventory]) {
    summary := { : };
    func body_(
            iter__,
            accum__: (
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            )
        ) -> (
            cont~(
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            ) |
            stop~(
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            )
        ) {
        (category, key, summary, vendor) := accum__;
        entry := iter__;
        (category, vendor) := entry;
        key := (category:, vendor:);
        if key not in summary {
            summary[key] := 0;
        }
        summary[key] += 1;
        return cont ~ (category:, key:, summary:, vendor:);
    }
    (category, key, summary, vendor) := !!for_loop(
        body_, inventory, (category:, key:, summary:, vendor:)
    );
    return summary;
}

func inventory_summary(inventory: [Inventory]) {
    summary := { : };
    func body_(
            iter__,
            accum__: (
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            )
        ) -> (
            cont~(
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            ) |
            stop~(
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            )
        ) {
        (category, key, summary, vendor) := accum__;
        entry := iter__;
        (category, vendor) := entry;
        key := (category:, vendor:);
        if key not in summary {
            summary[key] := 0;
            summary[key] += 1;
            return cont ~ (category:, key:, summary:, vendor:);
        }
        else {
            summary[key] += 1;
            return cont ~ (category:, key:, summary:, vendor:);
        }
    }
    (category, key, summary, vendor) := !!for_loop(
        body_, inventory, (category:, key:, summary:, vendor:)
    );
    return summary;
}

func inventory_summary(inventory: [Inventory]) {
    summary := { : };
    func body_(
            iter__,
            accum__: (
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            )
        ) -> (
            cont~(
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            ) |
            stop~(
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            )
        ) {
        temp_a := accum__;
        category := temp_a.category;
        key := temp_a.key;
        summary := temp_a.summary;
        vendor := temp_a.vendor;
        entry := iter__;
        temp_ := entry;
        category := temp_.category;
        vendor := temp_.vendor;
        key := (category:, vendor:);
        if key not in summary {
            summary := !!set_index(key, summary, 0);
            summary := !!set_index(key, summary, summary[key] + 1);
            return cont ~ (category:, key:, summary:, vendor:);
        }
        else {
            summary := !!set_index(key, summary, summary[key] + 1);
            return cont ~ (category:, key:, summary:, vendor:);
        }
    }
    temp_n := !!for_loop(
        body_, inventory, (category:, key:, summary:, vendor:)
    );
    category := temp_n.category;
    key := temp_n.key;
    summary := temp_n.summary;
    vendor := temp_n.vendor;
    return summary;
}

func inventory_summary(inventory: [Inventory]) {
    summary := { : };
    func body_(
            iter__,
            accum__: (
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            )
        ) -> (
            cont~(
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            ) |
            stop~(
                category: !Unspec,
                key: !Unspec,
                summary: !Unspec,
                vendor: !Unspec
            )
        ) {
        temp_a := accum__;
        category := temp_a.category;
        key := temp_a.key;
        summary_0 := temp_a.summary;
        vendor := temp_a.vendor;
        entry := iter__;
        temp_ := entry;
        category_0 := temp_.category;
        vendor_0 := temp_.vendor;
        key_0 := (category: category_0, vendor: vendor_0);
        if key_0 not in summary_0 {
            summary_1 := !!set_index(key_0, summary_0, 0);
            summary_2 := !!set_index(key_0, summary_1, summary_1[key_0] + 1);
            return cont ~ (
                category: category_0,
                key: key_0,
                summary: summary_2,
                vendor: vendor_0
            );
        }
        else {
            summary_3 := !!set_index(key_0, summary_0, summary_0[key_0] + 1);
            return cont ~ (
                category: category_0,
                key: key_0,
                summary: summary_3,
                vendor: vendor_0
            );
        }
    }
    temp_n := !!for_loop(
        body_, inventory, (category:, key:, summary:, vendor:)
    );
    category := temp_n.category;
    key := temp_n.key;
    summary_4 := temp_n.summary;
    vendor := temp_n.vendor;
    return summary_4;
}

def inventory_summary := {def
  inventory:[!List Inventory]
  (let
    summary:[map]
    (let
      body_:{def
        accum__:[!Record
          category:!Unspec key:!Unspec summary:!Unspec vendor:!Unspec
        ]
        iter__::
        ::[!Union
          cont:[!Record
            category:!Unspec key:!Unspec summary:!Unspec vendor:!Unspec
          ]
          stop:[!Record
            category:!Unspec key:!Unspec summary:!Unspec vendor:!Unspec
          ]
        ]
        (let
          temp_a:accum__
          (let
            category:(!get_slot category temp_a)
            (let
              key:(!get_slot key temp_a)
              (let
                summary_0:(!get_slot summary temp_a)
                (let
                  vendor:(!get_slot vendor temp_a)
                  (let
                    entry:iter__
                    (let
                      temp_:entry
                      (let
                        category_0:(!get_slot category temp_)
                        (let
                          vendor_0:(!get_slot vendor temp_)
                          (let
                            key_0:[. category:category_0 vendor:vendor_0]
                            (case tags (!bin_not_in key_0 summary_0)
                              false:(let
                                summary_3:(!set_index
                                  key_0
                                  summary_0
                                  (!bin_plus (!get_index summary_0 key_0) 1)
                                )
                                cont~[.
                                  category:category_0
                                  key:key_0
                                  summary:summary_3
                                  vendor:vendor_0
                                ]
                              )
                              true:(let
                                summary_1:(!set_index key_0 summary_0 0)
                                (let
                                  summary_2:(!set_index
                                    key_0
                                    summary_1
                                    (!bin_plus (!get_index summary_1 key_0) 1)
                                  )
                                  cont~[.
                                    category:category_0
                                    key:key_0
                                    summary:summary_2
                                    vendor:vendor_0
                                  ]
                                )
                              )
                            )
                          )
                        )
                      )
                    )
                  )
                )
              )
            )
          )
        )
      }
      (let
        temp_n:(!for_loop
          body_
          inventory
          [. category:category key:key summary:summary vendor:vendor]
        )
        (let
          category:(!get_slot category temp_n)
          (let
            key:(!get_slot key temp_n)
            (let
              summary_4:(!get_slot summary temp_n)
              (let vendor:(!get_slot vendor temp_n) summary_4)
            )
          )
        )
      )
    )
  )
};

def inventory_summary := {def
  inventory:[!List Inventory]
  (let
    body_:{def
      accum__:[!Record
        category:!Unspec key:!Unspec summary:!Unspec vendor:!Unspec
      ]
      iter__::
      ::[!Union
        cont:[!Record
          category:!Unspec key:!Unspec summary:!Unspec vendor:!Unspec
        ]
        stop:[!Record
          category:!Unspec key:!Unspec summary:!Unspec vendor:!Unspec
        ]
      ]
      (let
        temp_a:accum__
        (let
          category:(!get_slot category temp_a)
          entry:iter__
          key:(!get_slot key temp_a)
          summary_0:(!get_slot summary temp_a)
          vendor:(!get_slot vendor temp_a)
          (let
            temp_:entry
            (let
              category_0:(!get_slot category temp_)
              vendor_0:(!get_slot vendor temp_)
              (let
                key_0:[. category:category_0 vendor:vendor_0]
                (case tags (!bin_not_in key_0 summary_0)
                  false:(let
                    summary_3:(!set_index
                      key_0 summary_0 (!bin_plus (!get_index summary_0 key_0) 1)
                    )
                    cont~[.
                      category:category_0
                      key:key_0
                      summary:summary_3
                      vendor:vendor_0
                    ]
                  )
                  true:(let
                    summary_1:(!set_index key_0 summary_0 0)
                    (let
                      summary_2:(!set_index
                        key_0
                        summary_1
                        (!bin_plus (!get_index summary_1 key_0) 1)
                      )
                      cont~[.
                        category:category_0
                        key:key_0
                        summary:summary_2
                        vendor:vendor_0
                      ]
                    )
                  )
                )
              )
            )
          )
        )
      )
    }
    summary:[map]
    (let
      temp_n:(!for_loop
        body_
        inventory
        [. category:category key:key summary:summary vendor:vendor]
      )
      (let
        category:(!get_slot category temp_n)
        key:(!get_slot key temp_n)
        summary_4:(!get_slot summary temp_n)
        vendor:(!get_slot vendor temp_n)
        summary_4
      )
    )
  )
};

def body_ := {def
  accum__:[!Record
    category:!Unspec key:!Unspec summary:!Unspec vendor:!Unspec
  ]
  iter__::
  ::[!Union
    cont:[!Record category:!Unspec key:!Unspec summary:!Unspec vendor:!Unspec]
    stop:[!Record category:!Unspec key:!Unspec summary:!Unspec vendor:!Unspec]
  ]
  (let
    temp_a:accum__
    (let
      category:(!get_slot category temp_a)
      entry:iter__
      key:(!get_slot key temp_a)
      summary_0:(!get_slot summary temp_a)
      vendor:(!get_slot vendor temp_a)
      (let
        temp_:entry
        (let
          category_0:(!get_slot category temp_)
          vendor_0:(!get_slot vendor temp_)
          (let
            key_0:[. category:category_0 vendor:vendor_0]
            (case tags (!bin_not_in key_0 summary_0)
              false:(let
                summary_3:(!set_index
                  key_0 summary_0 (!bin_plus (!get_index summary_0 key_0) 1)
                )
                cont~[.
                  category:category_0
                  key:key_0
                  summary:summary_3
                  vendor:vendor_0
                ]
              )
              true:(let
                summary_1:(!set_index key_0 summary_0 0)
                (let
                  summary_2:(!set_index
                    key_0 summary_1 (!bin_plus (!get_index summary_1 key_0) 1)
                  )
                  cont~[.
                    category:category_0
                    key:key_0
                    summary:summary_2
                    vendor:vendor_0
                  ]
                )
              )
            )
          )
        )
      )
    )
  )
};
def inventory_summary := {def
  inventory:[!List Inventory]
  (let
    body_:{body_} summary:[map]
    (let
      temp_n:(!for_loop
        body_
        inventory
        [. category:category key:key summary:summary vendor:vendor]
      )
      (let
        category:(!get_slot category temp_n)
        key:(!get_slot key temp_n)
        summary_4:(!get_slot summary temp_n)
        vendor:(!get_slot vendor temp_n)
        summary_4
      )
    )
  )
};

More examples

There are some more examples.

Features

A faux-mutable type system.
It’s an immutable type system that prevents global side-effects.
But using an imperative language accessible to subject matter experts and amateurs.
Static types that are as easy as JSON.
If you want to return ok ~ ( data: "my data", count: 6 ) you can just do that.
Type inference figures out the actual type.
And then Tenet can document it correctly for you.
User-defined functions in a serialization language.
Build smart API clients with functions that further analyze data.
Evolve your API by writing functions to cast between versions.

How does it work?

To compile to different languages, you first need to simplify everything down to a common micro-language, and then rewrite that into the target languages.

Different languages only have a few things in common we can largely depend on, such as user-defined functions, local variables, etc. Even things like for-loops aren’t available in all languages.

The underlying principle used here is the same as any compiler: take a tree and repeatedly modify it.

As you perform those modifications, you simplify the problem slightly. For instance, Tenet is faux-mutable, so one step is “delensing” which means converting a.b := c into a := !!set_slot(a, "b", c).

The last tree will be the target language’s syntax, and then that can be written out as text.

Keys	Action
`?`	Open this help
`n`	Next page
`p`	Previous page
`s`	Search