Text-based language

[emil14]

Proc and cons. How this could be views as?

[emil14]

Print (vv ...any) (s str, n int, err error)
Trigger<T> (sigs ...any, v T) (v T)

IExample<T {}>(x T) (y T)

DoStuff<T {}>(x T) (y T) {
	nodes {
		print Print()
		trigger Trigger<T>()
	}
	net {
		in.x -> print.in.v
		print.out.s -> trigger.in.sigs
		trigger.out.v -> out.y
	}
}

[emil14]

// main.heba

/*
	directory is a package, files are "modules"  containing entities
	one file contain only one component and related types, constants and interfaces
	shared.heba is only one exception for that rule - it can contain several components
	one file cannot see content from another file except that content is located in shared.heba
	shared.heba can't see anything that is defined in another components in the same package
	all 5 types of entities could go in any possible order but formatter will enforce its own:
	1) import 2) types 3) interfaces 4) constants 5) component(s)
	same goes for shared.heba file(s)
*/

import { // imports comes first
	math std/math // local alias -> absolute path
	std/json // same as `json std/json`, useless aliases will be removed by the formatter
	// there's no need to explicitly import entities from shared.heba

	// grouping imports into 3 secins: std, 3rd party and local will be enforced by formatter
	github.com/hebalang/x/net // but only if there's >= 2 imports in each section
	// each section will be alphabetically sorted

	localUtils @/utils // @ means "root of the project"
}

types { // then types
	MyInt int // uppercase first letter for the type name will be enforced by the formatter
	pub MyStr int // `pub` means "exported entity"
}

types { // there could be multiple `types` blocks 
	MyInt2 myInt // but formatter will enforce grouping if there's more than 2
	User { // record (structure)
		age int // all {} blocks expects new lines as delimeter
		name str // there's never `,`, `;` or `=`
	}
	Users []Users // vector (dynamic array)
	Class [30]User // array (fixed-size)
	NameAndAge (int, str) // tuple, sugar for record {0 int 1 str}
}

interfaces { // then interfaces
	IWriter (bb []u8) (err error) // all entities defined in a file must be used by component and also could be exported
	pub IReader<T>(sig T) (bb []byte) // exported entities not used by components must live in shared.heba
}

interface IReadWriter { // same for interface
	IWriter // interfaces could be composed
	IReader // this is a syntactic sugar for manually creating a composition
} // "I" prefix will be enforced by formatter

const { // then constants and them components. order is enforced by formatter
	ONE int 1 // when it's too much shared or exported entities you can split it into several *.shared.heba files 
	pub TWO int 2 // linter will enforce you to do so at some point
} // UPPERCASE_NAMING will be enforced by linter

// takes numbers, sums them and returns value increased by one (this comment used for documentation purposes)
// first capital letter for component's name will be enforced by linter
pub Increment<T num | SubStream<num>>(nn ...T) (v num) { // component consist of name, type params, io, nodes and net
	nodes {
		// abstract nodes (dependency injection)
		w writer // writer and (btw this comment is used as a documentation)
		r reader // reader are not used so this is invalid component (this too)
		// regular nodes
		sum, plusOne math.Sum<T>()
		plusOne = math.Sum<T>()
		withDep = withDepComp<i8>( // 
			math.Sum<T>()
			math.Sum<T>()
		)
	}
	net { // list of connections (this is also a doc comment)
		in.nn -> sum.in.v
		sum.out.v -> plusOne.in.v
		plusOne.v -> out.v
		// one to many connections could be written as
		in.nn -> { // this block is just an example
			sum.in.v
			plusOne.in.v
		}
	}
}

[emil14]

without comments

import { 
	math std/math
	std/json
	github.com/hebalang/x/net
	localUtils @/utils
}

types {
	MyInt int
	pub MyStr int
}

types {
	MyInt2 myInt
	User {
		age int
		name str
	}
	Users []Users
	Class [30]User
}

interfaces {
	IWriter (bb []u8) (err error)
	pub IReader<T>(sig T) (bb []byte)
}

interface IReadWriter {
	IWriter
	IReader
}

const {
	ONE int 1
	pub TWO int 2
}

pub Increment<T num | SubStream<num>>(nn ...T) (v num) {
	nodes {
		w writer
		r reader
		sum, plusOne math.Sum<T>()
		plusOne = math.Sum<T>()
		withDep = withDepComp<i8>(
			math.Sum<T>()
			math.Sum<T>()
		)
	}
	net {
		in.nn -> sum.in.v
		sum.out.v -> plusOne.in.v
		plusOne.v -> out.v
		in.nn -> {
			sum.in.v
			plusOne.in.v
		}
	}
}

[emil14]

One component per file maybe not right constraint

Maybe one PUB component per file? Othersie we gonna have to move some internal components that are needed only as part of the one pub component to shared file which is not the irght thing I think

[emil14]

nodes {
		w writer
		r reader

                // maybe enforce newline here
		sum = math.Sum<T>()
		plusOne = math.Sum<T>()
		withDep = withDepComp<i8>(
			math.Sum<T>()
			math.Sum<T>()
		)
	}

[emil14]

	nodes {
		w writer
		r reader

		sum, plusOne math.Sum<T>()
		plusOne = math.Sum<T>()
		withDep = withDepComp<i8>(
			math.Sum<T>()
			math.Sum<T>()
		)
	}
	
	// newline here too
	net {
		in.nn -> sum.in.v
		sum.out.v -> plusOne.in.v
		plusOne.v -> out.v
		in.nn -> {
			sum.in.v
			plusOne.in.v
		}
	}

[emil14]

Maybe use use (like Rust does) instead of "import"

use { 
	math std/math
	std/json
	github.com/hebalang/x/net
	localUtils @/utils
}

[emil14]

use {
	std/io
	std/json
	math std/math
	
	github.com/nevalang/x/net
	github.com/nevalang/x/json

	@/utils
	local_root @/root
}

type {
	MyArr [3]int
}

const {
	ARR MyArr = [1, 2, 3]
}

component {
	Stringer<T>(v T) (v str) {
		node {
			sprintfer = io.Sprintfer<T>()
		}
		net {
			in.v -> {
				sprintfer.in.v
				out.v
			}
			sprintfer.out.v -> out.v
		}
	}

	pub Stringer2<T>(v T) (v str) {
		node {
			sprintfer = io.Sprintfer<T>()
		}
		net {
			in.v -> {
				sprintfer.in.v
				out.v
			}
			sprintfer.out.v -> out.v
		}
	}
}

[emil14]

We have ANTLR grammar for this