November 30, 2006
Daniel Keep wrote:
>  > def sr = System.IO.StreamReader ("SomeFile.txt");
> 
> Immutable run-time variables.  You can assign anything to them, and then it can't change.  AFAIK, D's const doesn't let you do that.
> 

What's the difference from C# and Java's 'final'? Is the variable transitively unchangeable, or just the immediate value?

-- 
Bruno Medeiros - MSc in CS/E student
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
November 30, 2006
Bruno Medeiros wrote:
> Daniel Keep wrote:
> 
>>  > def sr = System.IO.StreamReader ("SomeFile.txt");
>>
>> Immutable run-time variables.  You can assign anything to them, and then it can't change.  AFAIK, D's const doesn't let you do that.
>>
> 
> What's the difference from C# and Java's 'final'? Is the variable transitively unchangeable, or just the immediate value?
> 

I'm not really sure what 'transitively unchangeable' means... >_<

Firstly, isn't 'final' just used for class members?  This is used for local variables (or members, if I remember correctly).  As for the second sentence, it's immutable storage.  So you can't change what's stored in the variable, but if you've stored a reference, then you can mutate what's being referenced.

	-- Daniel
November 30, 2006
Daniel Keep wrote:
> Don Clugston wrote:
>> When I looked at the Nemerle website, I didn't see much that couldn't be done easily with D templates. It would be interesting to find something it can do, that D can't.
>
>  > def sr = System.IO.StreamReader ("SomeFile.txt");
> 
> Immutable run-time variables.  You can assign anything to them, and then it can't change.  AFAIK, D's const doesn't let you do that.

It does, but only for class member variables. There are two 'const's in D, one for literal constants, and the other which is once-only assign, and should probably be called 'final' instead.

class SomeClass {
	const StreamReader sr;
	this(char [] filename) { sr = System.IO.StreamReader(filename);}
};

[snip]

>  > macro while_macro (cond, body)
>  > syntax ("while", "(", cond, ")", body) {
>  >   <[
>  >     def loop () {
>  >       when ($cond) {
>  >         $body;
>  >         loop ()
>  >       }
>  >     }
>  >     loop ()
>  >   ]>
>  > }
> 
> Do THAT with templates :3

void While(lazy bool cond, void delegate() body) {
   for (; cond; ) body();
}

<g>
Or if I can't have for() as a primitive:

void While(lazy bool cond, void delegate() body) {
loopstart: if(cond) goto done;
    body();
    goto loopstart;
done:
}
> It would be foolish to think that Nemerle isn't an amazingly powerful language.  D is good, and its' templates are very powerful, but they're not THAT powerful.
> 
> There is always more to learn :)

Very true.
It does seem, though, that Nemerle and D are exploring a quite similar 'paradigm space' (so there's probably quite a bit each can learn from the other). Yet neither has really caught up with Lisp. Yet.
November 30, 2006
Don Clugston wrote:
> Daniel Keep wrote:
>>  > def sr = System.IO.StreamReader ("SomeFile.txt");
>>
>> Immutable run-time variables.  You can assign anything to them, and then it can't change.  AFAIK, D's const doesn't let you do that.
> 
> 
> It does, but only for class member variables. There are two 'const's in D, one for literal constants, and the other which is once-only assign, and should probably be called 'final' instead.
> 
> class SomeClass {
>     const StreamReader sr;
>     this(char [] filename) { sr = System.IO.StreamReader(filename);}
> };
> 

The thing that *really* struck me was that when I wrote some stuff in Nemerle, it was amazing how often I didn't actually need mutable variables.  I wonder what affect having immutables in D would have optimisation-wise...

> [snip]
> 
>>  > macro while_macro (cond, body)
>>  > syntax ("while", "(", cond, ")", body) {
>>  >   <[
>>  >     def loop () {
>>  >       when ($cond) {
>>  >         $body;
>>  >         loop ()
>>  >       }
>>  >     }
>>  >     loop ()
>>  >   ]>
>>  > }
>>
>> Do THAT with templates :3
> 
> 
> void While(lazy bool cond, void delegate() body) {
>    for (; cond; ) body();
> }
> 
> <g>
> Or if I can't have for() as a primitive:
> 
> void While(lazy bool cond, void delegate() body) {
> loopstart: if(cond) goto done;
>     body();
>     goto loopstart;
> done:
> }

True, but it's not quite the same.  The D version has that outlying closing paren which is, frankly, really ugly.  Also, the D version is doing a function call, whereas the Nemerle version is actually expanding an AST.

Of course, these things could probably be solved with a little more work from the compiler: allowing trailing delegate literals, and inlining delegate literals.  *drool*

>> It would be foolish to think that Nemerle isn't an amazingly powerful language.  D is good, and its' templates are very powerful, but they're not THAT powerful.
>>
>> There is always more to learn :)
> 
> 
> Very true.
> It does seem, though, that Nemerle and D are exploring a quite similar 'paradigm space' (so there's probably quite a bit each can learn from the other). Yet neither has really caught up with Lisp. Yet.

No language will ever catch up to LISP: the only way to do that would be to become LISP, and then you have to deal with all those bloody parentheses :3

	-- Daniel
November 30, 2006
Daniel Keep wrote:
> Don Clugston wrote:
>> Daniel Keep wrote:
>>>  > def sr = System.IO.StreamReader ("SomeFile.txt");
>>>
>>> Immutable run-time variables.  You can assign anything to them, and then it can't change.  AFAIK, D's const doesn't let you do that.
>>
>>
>> It does, but only for class member variables. There are two 'const's in D, one for literal constants, and the other which is once-only assign, and should probably be called 'final' instead.
>>
>> class SomeClass {
>>     const StreamReader sr;
>>     this(char [] filename) { sr = System.IO.StreamReader(filename);}
>> };
>>
> 
> The thing that *really* struck me was that when I wrote some stuff in Nemerle, it was amazing how often I didn't actually need mutable variables.  I wonder what affect having immutables in D would have optimisation-wise...

Not sure, but it would also help get closer to the Erlang model of concurrent programming via message passing.  Erlang is all immutables, iirc.  CL-MUPROC, a Lisp attempt at this Erlang model, treats immutability as a 'guideline' and let's the developer be grown-up.  But it uses OS threads instead of Erlang's lightweight processes. :(

> 
>> [snip]
>>
>>>  > macro while_macro (cond, body)
>>>  > syntax ("while", "(", cond, ")", body) {
>>>  >   <[
>>>  >     def loop () {
>>>  >       when ($cond) {
>>>  >         $body;
>>>  >         loop ()
>>>  >       }
>>>  >     }
>>>  >     loop ()
>>>  >   ]>
>>>  > }
>>>
>>> Do THAT with templates :3
>>
>>
>> void While(lazy bool cond, void delegate() body) {
>>    for (; cond; ) body();
>> }
>>
>> <g>
>> Or if I can't have for() as a primitive:
>>
>> void While(lazy bool cond, void delegate() body) {
>> loopstart: if(cond) goto done;
>>     body();
>>     goto loopstart;
>> done:
>> }
> 
> True, but it's not quite the same.  The D version has that outlying closing paren which is, frankly, really ugly.  Also, the D version is doing a function call, whereas the Nemerle version is actually expanding an AST.
> 
> Of course, these things could probably be solved with a little more work from the compiler: allowing trailing delegate literals, and inlining delegate literals.  *drool*
> 
>>> It would be foolish to think that Nemerle isn't an amazingly powerful language.  D is good, and its' templates are very powerful, but they're not THAT powerful.
>>>
>>> There is always more to learn :)
>>
>>
>> Very true.
>> It does seem, though, that Nemerle and D are exploring a quite similar
>> 'paradigm space' (so there's probably quite a bit each can learn from
>> the other). Yet neither has really caught up with Lisp. Yet.
> 
> No language will ever catch up to LISP: the only way to do that would be to become LISP, and then you have to deal with all those bloody parentheses :3

;)

> 
>     -- Daniel
November 30, 2006
Steve Horne escribió:
> On Mon, 27 Nov 2006 15:23:33 -0300, Leandro Lucarella
> <llucarella@integratech.com.ar> wrote:
> 
>> The center of my thesis would be adding meta-classes[1] to D, and maybe some other meta-programming features D could lack of (maybe some kind of access to the AST like XLR[2]).
> 
> I can't really offer any useful support, but if I understand what you
> are saying, I can offer encouragement.

Thanks for your support. Any other thing to say about the original topic?

I've noticed a tendency of this list to get rather silly[1]... I mean, off-topic =)

[1] I should posted this to a Python mailing list ;)

-- 
Leandro Lucarella
Integratech S.A.
4571-5252
November 30, 2006
Don Clugston wrote:
> Daniel Keep wrote:
>> Do THAT with templates :3
> 
> void While(lazy bool cond, void delegate() body) {
>    for (; cond; ) body();
> }

Heh, incorrect answer. I don't see a template :P.
</nitpick>
November 30, 2006
Daniel Keep wrote:
> Bruno Medeiros wrote:
>> Daniel Keep wrote:
>>
>>>  > def sr = System.IO.StreamReader ("SomeFile.txt");
>>>
>>> Immutable run-time variables.  You can assign anything to them, and then it can't change.  AFAIK, D's const doesn't let you do that.
>>>
>>
>> What's the difference from C# and Java's 'final'? Is the variable transitively unchangeable, or just the immediate value?
>>
> 
> I'm not really sure what 'transitively unchangeable' means... >_<
> 
'transitively unchangeable' or transitively const, means that in the case of references or pointers you can't change what is being referenced (and recursively so on). It's a transitive (recursive) read-only.

> Firstly, isn't 'final' just used for class members?  This is used for local variables (or members, if I remember correctly).  As for the second sentence, it's immutable storage.  So you can't change what's stored in the variable, but if you've stored a reference, then you can mutate what's being referenced.
> 
>     -- Daniel

Then that is just like 'final'. But I've realize now that this 'final' construct is only called 'final' in Java. The C# equivalent is actually called 'readonly' (http://msdn2.microsoft.com/en-us/library/acdd6hb7.aspx), whereas I thought it was 'final' too. Also, indeed the C# 'readonly' can only be used on fields, but the Java 'final' can be used on any variable, such as locals. And like Don said D has that feature too, but hideously hidden behind 'const'. -_-'

-- 
Bruno Medeiros - MSc in CS/E student
http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
December 01, 2006
On Fri, 01 Dec 2006 00:35:36 +0800, Daniel Keep <daniel.keep+lists@gmail.com> wrote:

>Don Clugston wrote:

>> It does seem, though, that Nemerle and D are exploring a quite similar 'paradigm space' (so there's probably quite a bit each can learn from the other). Yet neither has really caught up with Lisp. Yet.
>
>No language will ever catch up to LISP: the only way to do that would be to become LISP, and then you have to deal with all those bloody parentheses :3

Not sure I agree entirely.

In my view, the things that define the Lisp language are...

1.  The metaprogramming stuff, with a rather sparse core language
    being extended using library macros.

2.  The list based on pair (cons) objects.

3.  The explicit AST-structuring using parentheses.

Well, Nemerle has metaprogramming that is basically what Lisp does with some extra tweaks. Nemerle has pair-object based lists. And Nemerle has explicit AST-structuring using parentheses (it has a pre-parse stage to handle this).

Nemerle is heavily Lisp influenced. It just takes ideas from other places too. Personally, I think it may well have overtaken Lisp - just as powerful (within the limits of the .NET platform), yet more immediately usable.

-- 
Remove 'wants' and 'nospam' from e-mail.
Next ›   Last »
1 2
Top | Discussion index | About this forum | D home