thosakwe

property transitive {
  let r(a) : Relation on a.
  let x, y, z : in r.
  assume (x, y) in r.
  assume (y, z) in r.
  declare (x, z) in r.
}

thosakwe

// Simultaneously fetch three pages
fn main(url) {
  // Asynchronously visit Github, and find all repos...
  // Do this in the background.
  //
  // Returns a Task.
  let myTask = fork {
    let rq = fetch(url, {accept: 'text/html'})
    let dom = response.dom()
    let links = dom.querySelectorAll('a.repo-link')

thosakwe

val Ascii = (
  A: 0x12,
  // ...
  z: 0x13
)

type Number = Uint8 | Uint16 // Etc.

fn (Number n) toString() : String {
  var chars = Array(Uint16).new()

thosakwe

from users where {distinct username} select { username }

thosakwe

class Snake {
  var name: String
  
  get title: String {
    return '%name the Legendary Snake'
  }
  
  set age (value: Num) {
    
  }

thosakwe

import file

def main |argc, argv|
  if (>= (argc 2))
    argv
    | first
    | file.read
    | stdout
  else
    stdin | stdout

thosakwe

DNB

This is a prototype of a CMake-based build tool for Dart native extensions. Combined with scripts, this would be comparable to node-gyp, but with actual Windows support, and no Python dependency.

DNB is designed to ensure portability across various platforms where Dart runs.

Examples explained

Note: In real projects, filenames would be dnb.yaml, dnb.macos.yaml, etc.

thosakwe

models {
  // Define models (functions)
  line(x: Num) -> Num

  // Struct?
  nlp(text: String, len: Num) -> (category: String, confidence: Num)
    opts { cache }
}

train {

thosakwe

import 'package:dig/delegate.dart';
import 'package:path/path.dart' as p;

main(_, SendPort sendPort) {
  return Dig.run(sendPort, (Dig dig) async {
      var dig = await Dig.create(sendPort);
 
      // Wait for these tasks to finish, or run them if they have not been completed.
      await dig.depend(['string_scanner', 'source_span:some_task']);

thosakwe

What?

An ASM-inspired language that uses some familiar constructs to make building ASM easier.

It's basically ASM, but labels are given a function syntax. There also exists the concept of pointers, which are converted into address literals.

Declaring external functions is also supported, which makes it possible to verify the syntax of calls at compile time.

All in all, the compiler will be written in C++, and should in theory be quite fast, because in reality it is just a simple transpiler.