the compiler uses what it knows and figures stuff out. You see I wasn’t going to

actually have constants, just variables that act like constants. For example you have

type A and you declare B:

A B; //B is a variable of type A and/or a subtype of A

WHich is it? Subtype or variable? Depends on perspective. So then if you wanted to

treat B as a type you could do this:

B b1; B b2; B b3

You can assign bx to by because they are all on the same level. You can assign any of

the b’s to B, and it would slice off anything extra. You would be unable to assign B to

the b’s, because the b’s might have extra members that you would be unable to fill.

So that would lead to some crazy stuff. Remember type/variable A? Well what if you

assign C to A? Now B has changed type/supertype!

How would this be implemented? I’m thinking that every object would have a pointer to a

parent and a hashtable for its local members. There would be an add_member function.

Object Person;
Person.add_member(string name);
Person Joe;
Joe.name=”Joe”;
Person Teacher;
Teacher.add_member(int grade_level);
Teacher.add_member(string subject_taught);
Teacher Bob;
Bob const_bob;

So now you can see that you can assign const_bob to Bob, but not vice-versa. You could

assign Teacher to Joe and vice-versa but that would be bad, very bad. Something like

this would be interesting but is not at all the direction that I wanted to go.

So anyway my language is designed to be a lot like C++ but with simpler syntax and some new features: tuples, first class functions, and multiple dispatch.

so I came up with my syntax first (it used to be with the identifier first, but that was

harder to parse)

int i; //int
int@ ip; //int pointer
int->int f; //function taking an int and returning an int
(int,int)->(int,int) g; //function taking a tuple of ints and returing two ints

I am still not sure how I want to do templates or macros but I know that I will add them

soon and that I want them to be tuple friendly. Thus I needed a way to package a tuple

into a singular thing (object, type, etc…). So if you make an array (array will be a container in the library, not a built in metatype) of int:

array(int) a;

you need to be able to do something like this:

array(int,float,int) a;

but then you aren’t providing the same number of elements to the template. That made me

introduce boxing:

array([int,float,int) b;

oh and the parenthesis are uneccessary, because they only affect precedence. They have

no other meaning. So if all templates assume boxed arguments you would write:

array[int] a;
array[int,float,int] b;

You see when you call functions like this:

f(x)

it is no different than:

f x

because there is an implied adjacency operator. If two things are next to each other

there is assumed to be an invisible operator between them. So in the syntax tree there

would be an adj node with f as its left node and x as its right.

You see everything is an expression. There are no statements like in C++. The

semicolon is used as an operator. Unlike most operators which can evaluate their

arguments in either order, it always evaluates its left and then its right, and then it

returns its right argument.

So this is legal (but ill-advised code):

sin(DoSomething();pi)

first it does something, then it passes pi to the sine function. The semicolon is kind

of a complement to the comma (tuple) operator. The comma evaluates its arguments in

either order and then returns both as a tuple. So you could write code like this:

f(); g(); h()

so call them in order, or like this:

f(), g(), h()

and allow the compiler to call them in any order. I may introduce the ,, operator to

allow for simulataneous execution:

f(),, g(),, h()

but that is in the future if ever. By combining , ; and ( ) to control grouping you can

create a lot of different execution graphs. The notion of which statement comes before

another gets tricky. For any given statement there will be some which come before it,

some which come after, and some which don’t come before or after. I figured out some

rules for it to work. So you can’t use a value unless it comes before, but you can make a pointer or declare a variable.

The main reason that ( ) is used only for precedence is that every operator has one meaning. You don’t need anywhere near as much context to figure things out as you would in C++. This also meant that I had to give up prefix operators. Only infix, outfix (the () [] and {} operators) and postfix.

Making functions first class objects has a lot of implications. For example you decide to make a global variable as follows:

(int numerator, int denominator) -> (int quotient, int remainder) DivMod
{
quotient=numerator/denomination,
remainder=numerator%denominator
}

Ok so far so good, you have a function of type (int,int)->(int,int)
Now what if you want a member of a class C to have a member of type (int,int)->(int,int), what then?
Maybe you want that member to be a method, with access to a “this” pointer. Maybe you don’t, maybe you want to be able to assign your DivMod function to it. What if you want the function to be a method, and then you want to be able to assign it to a global variable. Should it be able to access its object? Should it be able to reseat itself into another object of the same type? Too many issues. I probably could have solved them well enough, but I just decided to eliminate the “this” pointer and so no more methods. If a class has functions as members those members have no special status. Afterall, if you have a Person type and he has four Legs, those Legs don’t automatically know about the Person that they are a part of. They might have a reference or a pointer, but only if the programmer provides it. So I got rid of the “this” pointer. With multiple dispatch you aren’t even treating the “this” special anyway.

Now I wanted to be able to return functions, have them access local variables, etc… As I’m sure that you are aware this causes problems when your variables are on the stack. I didn’t want to throw everything on the heap and go with a garbage collected language either. That was departing from C++ too much. So all variables are on the stack, but scopes are on the heap. Whenever a function is called a secret scope node is created. It has three members: a parent pointer, a frame pointer, and a reference count. Like so:

()->() A
{
int x;
x=4;

()->( (int)->(int) c ) B
{
c=(int y)->(int z){z=y*x};

};

int->int b;
C = B();

print C(5); //prints 20
x=6;
print C(5); //prints 30
}

if X is an function object, and X’ is a call to X, and X” is the node created by the prologue of X’

when A is called it has a node object A”. A” contains a frame pointer to the locals of A. B is a local variable accessable by an offset from that pointer. B has two private members: a pointer to some x86 code and a pointer to A”. When B is called the invocation is B’. It creates a node B”. B” gets its parent pointer from object B. Thus B’ can use A’ variables. B’ creates variable C, a function object. One of the members of C is the pointer to B”. When B’ returns and assigns c to b, the stack for B’ is cleaned up but B’ remains because C has a reference to it. When C is called it too has a node, and it can access x by following the chain of nodes. It does not capture the x, it can get to it. This is kind of like static chains but not on the stack.

Oh and you can leave the type off of functions, at least if they take no arguments. For example: {5} is a function of type: ()->(int) that always returns 5. {doThis();thenThat()} is of type ()->(), assuming that thenThat returns void. A block with no return type specified returns the value of the internal expression. I am thinking of adding in arguments too, like this: {$1(int)+$2(int)} which would be the same as: (int x, int y)->(int z){z=x+y}. However that is a lot of work so it is likely to be in a later release.

Lately I have been thinking about making boxes of variable declarations into class literals, so you could do this:

[int x, int y] p;
p.x=5;

So [int,int] would be a type literal but not a class literal, and there would be some sort of implicit conversion

so:

p=[6,7] would work, but you couldn’t do this:

[int,int] q;
q=p; // [int x, int y] is not converatble to [int,int]

But you could throw the unboxing operator in there, and then rebox it:

q=[p`];

As for progress, first I wrote the tokenizer, then the parser. The parser was only 650 lines of C++. I found a great program called graphviz so I can see the parse trees too. Then I wrote something to order things by when they are temporarlly (remember the ; and , operators). Then I started writting x86 so that I would know what code I had to generate but I had some trouble. I was getting frustrated so I am taking a year off. This will give me time to think over how I want to do templates, Also that class literal idea was in my head but I hadn’t thought of it yet so it was bothering me. So right now I am making a video game with C++. I will start back on my language next father’s day (since that is when I decided to take a year off).

Have a great time in graduate school and keep teaching the cat to meow!

You didn’t find that the approach made your type system more powerful? In general it should enable certain kinds of metaprogramming. The programmer can use constant values as compile time flags.

Tell me more about your language. I am always interested in new language designs.

Person p;
Student s;

p=s; //legal
s=p; //not legal

int i;
42 n;
42 m;
i=n; //legal
n=1; //not legal
n=m; //legal

However while the idea is cool it didn’t really do much for my language so I cut quickly.

Also take a look at: http://cat-language.googlecode.com/svn/trunk/standard.cat to see the current state of the standard library will full annotations.

Do I understand correctly that the format of the meta data is based on either detecting certain keywords like “desc” and “semantics”, which makes future extensions very hard, or on the whitespace (line ending), which makes it impossible to format longer descriptions?

In general I would like to get rid of tokenisation, and discussions on code indentation etc., see also http://www.umbrialogic.com/hirsch-strings-beta.pdf , but that needs some better tools than we have today…

…after all, why can’t everybody’s editor present the source as it is configured, rather than how the source was saved?

Back to the subject, another meta data that I could imagine useful to add to at least some functions is their runtime complexity. Imagine a compiler switch that allows you to choose between “best average case time complexity” or “best guaranteed worst case time complexity” for equivalent algorithms…

Enough ;-)

Ciao, Colin