No, I don't have a new favorite language...

[jemfinch]

But, I have written an interpreter these past few days for a new language. Mostly, I just need something to integrate into my IRC bot, but it's not a bad language in and of itself, so I figure I'll let all y'all know about it.

It's a pretty simple language, a lot like Python (and growing more like it with every feature I add :)) It supports first-class functions, modules, dictionaries, lists, strings and numbers; I've written a pretty full-featured string library, a simple regular expression library (simple in the interface, not in the regular expressions it uses; it's based on Pcre, so it's all Perl/Python compatible,) and the various list and dictionary functions (which currently reside in the list and dictionary modules, respectively, since I haven't quite decided how to handle member functions of built-in types yet.) Before the language is really useful, I'll need to add interfaces/modules for reading files and command lines, but that shouldn't be too much trouble. It's coming along really nicely, if I may say so myself :)

I'm writing tons and tons and tons of little tests for the language, and they're helping me catch a lot of bugs and quirks that I wouldn't even have known about. I'm also using these tests as regression tests for when I add new features, or modify the lexer/parser, so I don't take a step backwards on accident. I can't, however, test everything, and I definitely have my own programming style that's probably going to miss some areas. That's where I could really use some help.

Anyway, like I said before, I can't test it all. And I'm sure there are going to be bugs and lacking features lying all over the place in the wake of what puny bit of testing I can do. That's where I need help: if anyone here wants to install O'Caml, install the libraries I need, compile my code and then use the programming language for a few small tasks, discovering its bugs, quirks, and missing features, they'd be doing me a huge favor, they'd be contributing to the betterment of the internet by making my IRC bot (already the standard resident bot in three irc channels for a major website :),) and they'd be able to get in on the ground floor of the new, improved, VERSION 2 of my bot, yet to be seen by eyes other than mine.

Not only that, but you'd have a decent little language, you might learn a little more about programming, and you'll be able to write plugins for one of the coolest IRC bots in existence. And, of course, you'd be very close to the top (or maybe even the top, I don't really have one yet :)) of the ACKS file in my IRC bot distribution :)

So, any takers? Who wants to go through all this work just to test a language that's definitely no better than Python or Lua, except that it integrates very easily with an amazingly powerful and useful high level language (O'Caml :))?

Jeremy

[Gnu/Vince]

Where can i get the source? Also, which special libraries did you use? I am guessing your pythonish string modules, but what else?

[ 01 January 2002: Message edited by: Gnu/Vince ]

[Gnu/Vince]

Also, I think you should take some time to write a beginner's tutorial to O'Caml. The ones on caml.indria.fr or ocaml.org are often hard to understand. A practical one (maybe based on your IRC bot or your new language) could maybe get some people interested in O'Caml here to help you extend your language.

Examples of what you could talk:
-conditions
-loops & recursion
-the syntax and how to deal with it
-the typing system and how to get used to it
-how to declare variables and ref variables
-how to use functions

[jemfinch]

Originally posted by Gnu/Vince:
Where can i get the source? Also, which special libraries did you use? I am guessing your pythonish string modules, but what else?



Other than my own libraries, I've used Markus Mottl's interface to Pcre, and his resizable array module.


Also, I think you should take some time to write a beginner's tutorial to O'Caml. The ones on caml.indria.fr or ocaml.org are often hard to understand. A practical one (maybe based on your IRC bot or your new language) could maybe get some people interested in O'Caml here to help you extend your language.


I've toyed with the idea, but it's not likely for several reasons. First, learning a language is oftentimes just a matter of trial and error -- trying stuff, having it not work, figuring out why, and doing things differently until you get it right. Having been past that stage myself (and not having documented my path through that stage, unfortunately :() I don't think I'd really be able to coach someone through that stage in writing -- I'd forget too many things and throw in too many useless facts.

Aside from that, the manual does a good job of explaining the right things in the language, but it doesn't show any of the "gotchas" that newcomers to the language always find. If someone had the manual in addition to a list of "gotchas" that beginners always seem to run into, I'm sure he could learn the language fairly easily. Unfortunately, I'm not very qualified to document the "gotchas" because they just don't happen to me anymore.

If someone did want to learn the language, I'd be happy to answer all his questions, and he or I can document what problems he runs into for posterity's sake.

But O'Caml isn't what I'm focused on right now -- my new language, Ast, is :) I really need a whole lot testing to go into it.

Jeremy

[Gnu/Vince]

Ast? What does that mean? A Stupid Test? Achronysous (sp please) Server Typhoid?

[Benny B]

I'd be happy to help out with the testing Jemfinch .... u've helped me out heaps in the past with my little coding problems, so anything I can contibute, I would be more then happy to...

[jemfinch]

Originally posted by Gnu/Vince:
Ast? What does that mean? A Stupid Test? Achronysous (sp please) Server Typhoid?

It doesn't really many anything. It's common used as an abbreviation for "Abstract syntax tree," though.

It does sound rather like "Asp" which is a snake, and it's modelled after Python a bit :)

Benny B: Do you have O'Caml installed?

Jeremy

[Benny B]

Originally posted by jemfinch:
<STRONG>Benny B: Do you have O'Caml installed?</STRONG>

Yeh I do.

[jemfinch]

Ok, head here (http://www.ai.univie.ac.at/~markus/home/ocaml_sources.html) and install the "PCRE-OCAML" and "RES" libraries.

Also note that in order for them to work correctly in my default installation, I had to copy all the files they put in /usr/local/lib/ocaml/contrib in /usr/local/lib/ocaml.

When you get those two installed, gimme a shout, I'll email you the tarball of my entire ocaml source tree (you'll need it all to compile the interpreter :))

Jeremy

[Benny B]

done and done ....... email away..

However it is late here now and I've got to go to bed (work tommorow), so I wont get to play around with it till tommorow night...

[jemfinch]

I'll sneakernet the tarball down here on floppy sometime today...but at the moment, I have my regression tests for those that might be interested in what the syntax looks like...they definitely need to be "beefed up" to test more of the language, but they show pretty well what the language looks like:

They're long, but a lot of it is because there are so many blank lines. I needed a simple testing framework to start with, so I made it so it reads a test (finishing when it gets an empty line) then an expected result (finishing when it gets an empty line,) evaluates both, and makes sure they're equal.


###
# Tests of builtin functions.
###
type("")

"string"

type([])

"list"

type({})

"dict"

compare(1, 0)

1

compare(0, 1)

-1

compare(0, 0)

0

compare("foo", "bar")

1

compare("bar", "foo")

-1

compare("bar", "bar")

0

compare({1: 2}, {})

1

compare({}, {1: 2})

-1

compare({}, {})

0

compare({1: 2, 2 : 10}, {10: 2})

1

compare({}, {-1: 2})

-1

compare({1: 2}, {1: 2})

0

compare([], [])

0

compare([1,2], [])

1

compare([], [1,2])

-1

compare([1,2], [2,3])

-1

repr(1)

"1"

repr("foo")

"\"foo\""

range(5)

[0, 1, 2, 3, 4]

range(5, 10)

[5, 6, 7, 8, 9]

range(5, 10, 1)

[5, 6, 7, 8, 9]

range(10, 5, -1)

[10, 9, 8, 7, 6]

range(5, 7, .5)

[5, 5.5, 6, 6.5]

range(5, 10, 2)

[5, 7, 9]

range(10, 5, -2)

[10, 8, 6]

call(range, 5)

[0, 1, 2, 3, 4]

call(range, 5, 10)

[5, 6, 7, 8, 9]

call(range, 5, 10, 1.5)

[5, 6.5, 8, 9.5]

num("123")

123

num("a")

NaN

max(range(10))

9

l = [1, 7, 2, 6, 3, 4, 5, 9, 7, 5, 4, 10, 5, 3, 0, -1, 6];
max(l)

10

min(l)

-1

max(1, 2, 3)

3

min(2, 1, 3)

1

max(1, 5, 4, 2, "foo", 6)

"foo"

min(-1, 0, [], {}, "foo", 10, -1000)

-1000

slice("foobar", 2, 4)

"ob"

slice(range(10), 3, 6)

[3, 4, 5]

equal(Null, Null)

1

Null == Null

1

not(equal(1, 1))

0

not(1)

0

not(0)

1

not("")

1

not("foo")

0

!1

0

!0

1

1 == 1

1

0 == 0

1

1 == 0

0

1 != 0

1

0 != 0

0

1 &lt; 0

0

0 &lt; 1

1

1 &lt;= 1

1

1 &lt;= 10

1

10 &gt;= 11

0

"foo" + "bar"

"foobar"

[1, 2, 3] + [4, 5, 6]

[1, 2, 3, 4, 5, 6]

range(3) + range(3, 6) == range(6)

1

range(0)

[]

range(1)[0]

0

range(10)[5]

5

[1] * 5

[1, 1, 1, 1, 1]

"foo" * 3

"foofoofoo"

"foo" * 3 + "bar" * 2

"foofoofoobarbar"

[1, 2] * 3

[1, 2, 1, 2, 1, 2]

[1, 2, 3] * 2 ** 2

[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

# This test will likely change when infinite precision arithmetic is added.
2 ** 2 ** 2 ** 2 ** 2

Inf

nan

NaN

NaN

nan

Inf

Inf

inf

Inf

infinity

Inf

abs(0)

0

abs(-1)

1

abs(1)

1

l = lambda (x) { x ** x };
[l(1), l(2), l(3), l(4), l(5)]

[1, 4, 27, 256, 3125]

l = lambda (x) { lambda (y) { x + y } };
[l(1)(1), l(2)(2), l(3)(3), l(4)(5)]

[2, 4, 6, 9]

def square(x) {
x ** 2
};
square(square(square(2)))

256

{1: 2, 2: 3, 3: 4}[2]

3

{"foo": "bar", "bar": "baz", "baz": 4}["baz"]

4

1 + 1

2

A = 1;
A += 5;
A

6

A /= 3;
A

2

A *= 10;
A

20

A %= 6;
A

2

A++;
A

3

A--;
A--;
A

1

range(10)[3:8]

[3, 4, 5, 6, 7]

range(10)[:8]

[0, 1, 2, 3, 4, 5, 6, 7]

range(10)[8:]

[8, 9]

range(10)[:]

range(10)

ord('\n')

10

ord('\x00')

0

chr(0)

"\000"

chr(10)

"\n"

sprintf("%s", "foobar")

"foobar"

sprintf("%s:%d", "foobar", 10)

"foobar:10"

sprintf("%x", 255)

"ff"

sprintf("%o", 255)

"377"

sprintf("%r", "foo")

"\"foo\""

sprintf("%%%s%sx", 0, 2)

"%02x"

sprintf("%c", ord('x'))

"x"

### End of builtin tests.


###
# Tests of list module functions.
###
range(10).length()

10

[].length()

0

[1].length()

1

[1,2,3].length()

3

range(10).append(10)

Null

l = range(10);
l.append(10);
l

range(11)

l = [];
l.append("foo");
l

["foo"]

l = [];
l.append([]);
l

[[]]

range(10).count(9)

1

range(10).count(10)

0

([1]*8).count(1)

8

([1,2]*3).count(2)

3

[].count(Null)

0

l = range(10);
l.extend(range(10, 20));
l

range(10) + range(10, 20)

l = [];
l.extend([]);
l

[]

### Test list.index later, when better exception mechanism is implemented.


l = [1,2,3];
l.insert(1, 1.5);
l

[1, 1.5, 2, 3]

l.reverse();
l

[3, 2, 1.5, 1]

while l {
l.pop(0)
};
l

[]

l = range(10);
i = 0;
while i &lt; 10 {
if i % 2 then
l.pop(i)
else
l.insert(i, i**3);
i++;
};
l

[0, 1, 8, 3, 64, 5, 216, 7, 512, 9]

l = range(3) * 3;
l.remove(2);
l

[0, 1, 0, 1, 2, 0, 1, 2]

l.remove(2);
l

[0, 1, 0, 1, 0, 1, 2]

l.remove(2);
l

[0, 1, 0, 1, 0, 1]

l.remove(1);
l

[0, 0, 1, 0, 1]

l.remove(0);
l

[0, 1, 0, 1]

l.filter(lambda(elt) { elt })

[1, 1]

range(10).map(lambda(elt) { elt ** elt })

[1, 1, 4, 27, 256, 3125, 46656, 823543, 16777216, 387420489]

l = [];
for (elt in range(10)) {
l.append(elt);
};
l

range(10)

l.copy()

l

### End list method tests.

###
# String module tests
###

"foobar"[1:-1]

"ooba"

"foobar"[2:]

"obar"

"foobar"[:2]

"fo"

"foobar"[:2] + "foobar"[2:]

"foobar"

string.digits

"0123456789"

string.hexdigits

"0123456789abcdefABCDEF"

string.octdigits

"01234567"

string.lowercase

"abcdefghijklmnopqrstuvwxyz"

string.uppercase

"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

string.letters

string.lowercase + string.uppercase

i = 0;
s = "";
while i &lt; 256 {
s += chr(i);
i++;
};
s

string.all

s = "The quick brown fox jumps over the lazy dog";
s.find("dog")

40

s.rfind('o')

41

s.find('o')

12

'foobar'.upper()

"FOOBAR"

'123\x00456\x00789\x00'.split('\x00')

["123", "456", "789", ""]

'123'.split('123')

["", ""]

s.replace('brown', 'tan')

"The quick tan fox jumps over the lazy dog"

'123123123'.replace('2', '4')

"143143143"

'127.0.0.1'.delete('.' + string.digits)

""

"123,123,123".count("123")

3

### End string method tests.


###
# Dictionary module tests.
###
d = {};
d.items()

[]

d[1] = "foo";
d[4] = "bar";
d["baz"] = 5;
d

{1: "foo", 4: "bar", "baz": 5}

l = d.items();
l.sort();
l

[[1, "foo"], [4, "bar"], ["baz", 5]]

l = d.keys();
l.sort();
l

[1, 4, "baz"]

l = d.values();
l.sort();
l

[5, "bar", "foo"]

{}.copy()

{}

for (l in d.items()) {
d[l[1]] = l[0];
};
d

{1: "foo", 4: "bar", "baz": 5, 5: "baz", "bar": 4, "foo": 1}

del d["foo"];
del d["bar"];
del d["baz"];
d

{1: "foo", 5: "baz", 4: "bar"}

{1: 2} + {2: 3} + {3: 4}

{1: 2, 2: 3, 3: 4}




Just for those curious :)

Jeremy