Exa: notes for a new programming language

introduction

The goal of the Exa language is to provide support for tightly controlled metaprogramming. It will likely take shape as an interpreted programming language, related to LISP and perhaps distantly to MODULA-1. 

The most fundamental distinction in the Exa language is between names and values. A value can be any valid Exa expression which resolves to a valid data type (i.e., a pure, a numeric, a user-created object — even a name, a program, etc.) A name represents an alias to a value; multiple names can point to the same value/object.

data types

pure — by default carries no value, but can be assigned any value whatsoever (even a function, program, etc.) 

numeric — a flexible int/float class; by default has int precision but will smoothly rearrange itself to accept float values

literal — a string class, consisting of a list of valid characters terminated by the null character “~”

—

lexeme — a lexical element for inline language construction

syntagm — a syntactical element for generational grammars

language — a multipurpose object for for formal language specification and procedural generation

–

name– the first meta-type; carries an alias or name of a variable in memory 

datatype– another kind of metatype: a type objects carries a data type. (all variables have a type() method which returns their type as a type object)

expression — a formula expressed mathematically. all valid lines of Exa code are expressions. within a constructed expression, variables  can be embedded using square brackets, e.g: “[a]^2 + [b]^2 > [c]^2” ; “[e] = [m][c]^2”; etc. 

method — a sequence of valid Exa expressions 

–

object – a user-created data structure, consisting of an arbitrary collection of any data types

program – a collection of Exa objects and/or methods 

package– a collection of related valid Exa programs

structure

– An expression-statement is any valid Exa expression. A variable declaration is the simplest Exa code-expression, e.g: “numeric numValue”. However, a valid Exa expression is any expression which when evaluated matches any valid data type.

– An assignment is a special form of expression-statement always written in the form “(define/let) (<type-expression>) <name-expression> (=/as/is/be) <value-expression>” where <name-expression> is any valid expression which evaluates to a name and <value-expression> is a valid expression which evaluates to a value (even a data type, a program, etc.) A data type may also be explicitly included in an assignment; otherwise the appropriate cast or conversion is made (all variables are pure by default.) Objects and methods can created using an assignment as well, using the form “(let/define) <data-type> <method-name>(<parameter-expression>) (=/as/is/be) {<method>}” for methods and “(let/define) <object-name> (as/is/be) {<object>}” for objects. 

– A name assignment is a special form of assignment expression where an alias to another value, object, program, etc. is created using the form “(let) <name-expression> name(s) <name-expression>”. (The name of a variable or object, like the type, can be accessed using methods name() or type())

– An expression template is a special expression form suitable to metaprogramming.

– A conditional-expression can be written in the standard form “if (<condition-expression) {<code-block>} (else if (<condition-expression>) {<code-block>} else {<code-block>}”. 

– A loop-expression can be expressed in the  form “ while/for<loop-expression> {<code-block>}” 

libraries

Exa should run with only a tiny core capable of string processing, file and device i/o, etc. (Additional libraries for sound, 2d/3d graphics should also be provided.)

syntax notes

Commas serve for line breaks both in code blocks and expressions.

There are no semi-colons in Exa. Also, in unambiguous cases, brackets may be omitted.

examples

Hello World

Method One

helloworld1.ea

out “Hello”

Method Two

helloworld2a.ea

pure print(literal x) { out(x) }

print “Hello”

helloworld2b.ea

let print name out, print “Hello”

Method Three

voice.ea

define object Voice {

pure express (literal x) {

out(x)

}}

helloworld3.ea

invite voice

Voice v, 

v: express “Hello”

Input/Output

Math

math_io.ea

numeric factorial(numeric val) {

if (val<=2) val 

else factorial(val-1)*val}

read “n!” as “factorial(n)”

out “Please enter a number: “

numeric x = in

out “The square root of [x] is [x ^ 0.5].\n”,

    “The area of a circle with radius [x] is [pi * x ^ 2].\n”,

    “The factorial of [x] is [x!].\n”

I have recently undertaken the creation of a 3-d graphics extension to the Processing core. I intend it to be general purpose, but for now it will likely be tailored to the presentation of a new game I’m working on based loosely on Galaxy Wars.

It is called Worlds, and you can follow its development here.

Coming soon!

More soon..

If you’d like to play, you can download the Windows executable (hosted at MediaFire.)

(Built in Java with Processing.)

Midway through a fierce interstellar battle:

An early version:

(Click for larger screenshots)

The basic idea here is to procedurally generate an RPG universe complete with locations, stories and characters. Every time you play it produces a completely new “cosmos” with new stars, planets, cities, neighborhoods, buildings and people.

Below are several random level one characters and a few examples of the UI (with procedurally-generated flavor text describing the location.)

User Interface

Sample Character

Name: Joe
Class: Rogue (lvl 1)

Alignment: Modern Lawful Evil

Current Weapon: Rose Bow
Current Armor: Light Armor

Intelligence: 5 Strength: 2 Constitution: 4
Dexterity: 3 Wisdom: 4 Charisma: 4

Savvy: 5 Charm: 2 Intimidation: 5
Intuition: 2 Instincts: 4
Kindness: 3 Cruelty: 4

Hair: Dark Red Eyes: Dark Brown Complexion: Dark Brown
Height: 5 ft., 7 in. Weight: 213 lbs

Wealth: 4 (3200)

How about this character (y/n)

——————————————-

Name: Joe
Class: Fighter (lvl 1)

Alignment: Modern True Evil

Current Weapon: Long Sword
Current Armor: Heavy Armor

Intelligence: 3 Strength: 4 Constitution: 3
Dexterity: 3 Wisdom: 3 Charisma: 2

Savvy: 4 Charm: 3 Intimidation: 3
Intuition: 4 Instincts: 2
Kindness: 3 Cruelty: 4

Hair: Dark Red Eyes: Light Blue Complexion: Medium Brown
Height: 5 ft., 9 in. Weight: 194 lbs

Wealth: 5 (5000)

————–

Name: Joe
Class: Sorcerer (lvl 1)

Alignment: Romantic True Good

Current Weapon: Light Staff
Current Armor: None

Intelligence: 4 Strength: 4 Constitution: 5
Dexterity: 4 Wisdom: 5 Charisma: 2

Savvy: 4 Charm: 5 Intimidation: 5
Intuition: 3 Instincts: 5
Kindness: 5 Cruelty: 4

Hair: Dark Red Eyes: Light Blue Complexion: Medium Brown
Height: 6 ft., 8 in. Weight: 213 lbs

Wealth: 5 (5000)

Text-Based Storytelling

The next step on this project involves integrating the “implicit” storytelling elements directly into the game as events. It strikes me that the formal ontology I’ve been using in other areas (elements, attributtes, relationships) applies well to each of the areas we need serious artificial creativity in — stories, worlds and characters. Making the engine more fluent, narrative, and interactive is where I intend to go with this.