Yet Another Language to Check Out

[wtd]

http://www.opendylan.org/learning.phtml

[Hikaru79]

Am I doing something wrong with the compiler here? I took the d2c compiler that Ubuntu has in its repos. I wrote a simple Hello, world:

code:

module: hello format-out("Hello, World!\n");

And then I ran:

code:

hikaru79@ubuntu:~/Programming/Dylan$ d2c hello.dylan

And from what I can tell, it automatically generated a hello.c file, which it then simply compiled as a C program. Now, here's the kicker: the hello.c file it generated is 51,235 lines long, at 2.0 megabytes! The executable is 444kb. Now, I'm no ricer, but this seems a bit excessive. Is this normal? Have you tried the other compiler, OpenDylan?

[wtd]

Try writing a less trivial program.

code:

module: hello define class <greeter> (<object>)    slot name :: <string>, required-init-keyword: name:; end; define method greet(g :: <greeter>, other-name :: <string>) => ()    format-out("Hi %s!  I'm %s\n", other-name, g.name); end method; let me = make(<greeter>, name: "Bob"); greet(me, "John");

Nearly the same generated executable size.

We can fairly safely surmise that the bulk of the Hello world program was boilerplate that ends up in any program. More complex programs may not be expected to grow linearly.

[Hikaru79]

Ah, yes, I see. I guess the first 2 megs are just overhead that Dylan creates.

[wtd]

Keep in mind that the Dylan language does a lot of things that C and even C++ do not.

[rizzix]

ah a prototyping language... like Self.. oh well.. they did pick the worst name ever though.. sheesh "dylan".

[wtd]

If I may ask... where do you get that it's a prototype-based language?

[rizzix]

oh... i blindly assumed that.. hmm considering the "slots" and stuff.. correct me if i'm wrong.. hmm

[wtd]

The language is essentially Lisp in a vaguely Wirth-ish syntax. The terminology is taken from CLOS.

[wtd]

A TYS for Dylan.

I have the following code:

code:

module: name-test define class <name> (<object>)    slot first-name :: <string>,       required-init-keyword: first:;    slot last-name :: <string>,       required-init-keyword: last:; end class <name>; define method full-name(name :: <name>) => output :: <string>;    concatenate(name.first-name, " ", name.last-name); end method full-name; define method print-name(name :: <name>) => ();    format-out("%s\n", full-name(name)); end method print-name; define variable *a-name* = make(<name>, first: "Bob", last: "Smith"); print-name(*a-name*);

Now that works quite logically, the way you'd expect.

What if I insert the following?

code:

*a-name*.first-name := "";

Now the output looks weird. So, how do I still allow that assignment, but disregard any attempt to assign an empty string to either the first or last name?

[wtd]

I'm spoiled by Ruby code like:

code:

10.times do |i|    puts i end

Ruby's blocks make all kinds of clever looping schemes possible.

So I wanted to write something like this in Dylan. Dylan doesn't have the same mechanism as Ruby, though, and has no built-in loop of this type. I'm out of luck, right?

Not quite. I was able to compile this:

code:

times 10 with i    format-out("%d\n", i); end times;

So, how was this possible?

Well, I had to write a macro.

code:

module: macro-test define macro times    { times ?num:expression with ?var:variable ?:body end }    =>    {       let ?var = 0;       while (?var < ?num)          ?body;          ?var := ?var + 1;       end while;    } end macro times;

But, then I realized I might instead want a simpler loop, without the variable.

code:

times 10    format-out("Hello\n"); end times;

So I created another syntax rule for the macro.

code:

module: macro-test define macro times    { times ?num:expression with ?var:variable ?:body end }    =>    {       let ?var = 0;       while (?var < ?num)          ?body;          ?var := ?var + 1;       end while;    }    { times ?num:expression ?:body end }    =>    {       let var = 0;       while (var < ?num)          ?body;          var := var + 1;       end while;    } end macro times;

Then I created a bunch of other variants.

code:

module: macro-test define macro times    { times ?num:expression with ?var:variable ?:body end }    =>    {       let ?var = 0;       while (?var < ?num)          ?body;          ?var := ?var + 1;       end while;    }    { times ?num:expression ?:body end }    =>    {       let var = 0;       while (var < ?num)          ?body;          var := var + 1;       end while;    }    { times ?num:expression with ?var:variable from ?f:expression ?:body end }    =>    {       let ?var = ?f;       while (?var < ?num + ?f)          ?body;          ?var := ?var + 1;       end while;    }    { times ?num:expression with ?var:variable from ?f:expression by ?b:expression ?:body end }    =>    {       let ?var = ?f;       while (if (?b >= 0) ?var < ?num * ?b + ?f else ?var > ?num * ?b + ?f end)          ?body;          ?var := ?var + ?b;       end while;    }    { times ?num:expression with ?var:variable by ?b:expression ?:body end }    =>    {       let ?var = if (?b >= 0) 0 else -?b * (?num - 1) end;       while (if (?b >= 0) ?var < ?num * ?b else ?var >= 0 end)          ?body;          ?var := ?var + ?b;       end while;    } end macro times;

Dylan's macros rock.

[rizzix]

seems kinda pointless.. to write all that code for something so simple.

[wtd]

It makes the code more expressive.

http://www.gwydiondylan.org/books/dpg/db_334.html