www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Nimrod language

reply bearophile <bearophileHUGS lycos.com> writes:
Through Reddit I have found a short discussion about the Nimrod language, it's
a garbage collected statically typed language fit for low level coding too,
despite it looks a lot like Python (with a bit of Pascal semantics added), it
has generics too, templates, and macros, its compiler is written in Nimrod
itself, and it compiles to C:
http://www.reddit.com/r/programming/comments/eub63/nimrod_programming_language/

I've seen that there's an older link to Nimrod in D newsgroups:
http://www.digitalmars.com/d/archives/digitalmars/D/Complete_off_topic_Nimrod_language_107212.html

The Nimrod site:
http://force7.de/nimrod/index.html

Two pages of tutorials (there is a manual too, elsewhere):
http://force7.de/nimrod/tut1.html
http://force7.de/nimrod/tut2.html
About AST macros:
http://force7.de/nimrod/macros.html

Here are some quotations and notes about the tutorials (version 0.8.10), the
Reddit thread (and the manual), I show some Nimrod features:

-------------------


Case is insignificant in Nimrod and even underscores are ignored:
This_is_an_identifier and ThisIsAnIdentifier are the same identifier. This
feature enables you to use other people's code without bothering about a naming
convention that conflicts with yours. It also frees you from remembering the
exact spelling of an identifier (was it parseURL or parseUrl or parse_URL?).<


So the "_" is not usable, and if you search for names in the code you need to
set it to ignore underscores.

-------------------


Comments are tokens; they are only allowed at certain places in the input file
as they belong to the syntax tree! This feature enables perfect
source-to-source transformations (such as pretty-printing) and superior
documentation generators.<


-------------------


Hexadecimal literals are prefixed with 0x, binary literals with 0b and octal
literals with 0o. A leading zero alone does not produce an octal.<


-------------------


To call a procedure that returns a value just for its side effects and ignoring
its return value, a discard statement has to be used. Nimrod does not allow to
silently throw away a return value:<


discard factorial(10)

-------------------

It has iterators with a syntax similar to Python:

iterator countup(a, b: int): int =
  var res = a
  while res <= b:
    yield res
    inc(res)

-------------------

There's a way to specify integer literals of the desired size, signed bytes too:

var




-------------------


Automatic type conversion in expressions with different kinds of floating point
types is performed: the smaller type is converted to the larger. Integer types
are not converted to floating point types automatically and vice versa. The
toInt and toFloat procs can be used for these conversions.<


-------------------

It has integral subranges (ranged types of Pascal, Ada):

type
  TSubrange = range[0..5]

-------------------

One of the compilation options is to turn on "hints" (there are warnings and
errors too):

hints	on|off 	Turns the hint messages of the compiler on or off.

-------------------

Overall it looks like a quite nice language. I have not tried to program with
it yet.

Bye,
bearophile
Jan 01 2011
next sibling parent Gour <gour atmarama.net> writes:
--MP_/wDlCE6JB7ToeZIdW3CJr7Od
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

On Sat, 01 Jan 2011 13:00:15 -0500

 "bearophile" =3D=3D bearophile <bearophileHUGS lycos.com> wrote:












bearophile> Through Reddit I have found a short discussion about the
bearophile> Nimrod language, it's a garbage collected statically typed
bearophile> language fit for low level coding too...

Happy New Year ;)

--=20

Gour  | Hlapicina, Croatia  | GPG key: CDBF17CA
----------------------------------------------------------------

--MP_/wDlCE6JB7ToeZIdW3CJr7Od
Content-Type: image/jpeg
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename=ohnoes.jpg
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--MP_/wDlCE6JB7ToeZIdW3CJr7Od--
Jan 01 2011
prev sibling next sibling parent reply =?UTF-8?B?IkrDqXLDtG1lIE0uIEJlcmdlciI=?= <jeberger free.fr> writes:
bearophile wrote:

 Overall it looks like a quite nice language. I have not tried to progra=


m with it yet.

=20


	I have (actually, I believe that I  discovered Nimrod following one
of your posts here ;)). You can find some performance benchmarks
here: https://bitbucket.org/jmb/shootout/wiki/Home

	IMO the concept is interesting (especially the Python-like syntax
for a compiled language), but there are a lot of rough edges and
development is very slow.

		Jerome
--=20
mailto:jeberger free.fr
http://jeberger.free.fr
Jabber: jeberger jabber.fr
Jan 01 2011
parent reply bearophile <bearophileHUGS lycos.com> writes:
J. M. Berger:


 You can find some performance benchmarks
 here: https://bitbucket.org/jmb/shootout/wiki/Home


Thank you for the link, I will carefully read your Nimrod implementations.



 	IMO the concept is interesting (especially the Python-like syntax
 for a compiled language),


There several other examples of the same thing (like the Python compiler I'm
helping the development, ShedSkin), Boo, etc.



 but there are a lot of rough edges and development is very slow.


Nimrod seems to contain no new ideas, and probably some large ideas of D2 are
missing, but the syntax and some smaller details are nice.

The authors of Nimrod seem kind of the opposite of this language designer that
was famous in the Amiga scene. This person keeps trying to invent something
sharply different from the languages we use today (and someday I think he will
produce something very good):
http://strlen.com/programming-languages
http://strlen.com/language-design-overview

Bye,
bearophile
Jan 01 2011
next sibling parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
On 1/1/11 5:07 PM, bearophile wrote:

 J. M. Berger:


 You can find some performance benchmarks
 here: https://bitbucket.org/jmb/shootout/wiki/Home


 Thank you for the link, I will carefully read your Nimrod implementations.



 	IMO the concept is interesting (especially the Python-like syntax
 for a compiled language),


 There several other examples of the same thing (like the Python compiler I'm
helping the development, ShedSkin), Boo, etc.



 but there are a lot of rough edges and development is very slow.


 Nimrod seems to contain no new ideas, and probably some large ideas of D2 are
missing, but the syntax and some smaller details are nice.


My fantasy: bearophile goes to the Nimrod forum and says "Hey, how about 
this D language, seems interesting..." :o)

Andrei
Jan 01 2011
parent reply bearophile <bearophileHUGS lycos.com> writes:
From that Reddit thread on Nimrod:

Andrei:


Our initial plan with D2 was to include AST macros, but we decided to see how
string mixins swim and defer macros to D3. The D forums are virtually silent on
the topic of macros now, and it's definitely not because the community is being
coy :o).<


You are right that lately no serious discussions have happened here about AST
macros. But the causes are not coyness or because string mixins are good
enough. I think the causes are:
- AST Macros a not a minor feature, they require some time and thinking to
design them well, some syntax support, some code in the front-end, some
documentation for users, and some time to learn to use them.
- D2 has many bugs and some unfinished parts. Most people here know that adding
more features now is not right. And generally Walter and you are (rightly)
adding major new features to D2 right now. Once D2 is more finished and
debugged some discussions about AST macros may start again.
- Lot of people here probably are not experienced with AST macros.
- I like the idea of AST macros, they are powerful, but they add a significant
amount of complexity to the language. So I am not pushing a lot for them,
despite I almost hate string mixings and creating code with string snippets.

--------------------

kapilash :


The forum I was referring to had too many useless discussions about the length
of the word "immutable", unnecessary arguments about D vs other languages and
far too much emphasis on reddit.<


I don't mark threads as this "Nimrod language" as OT because a new language
like D2 must keep eyes open on other new languages and some computer science.

Bye,
bearophile
Jan 02 2011
next sibling parent bearophile <bearophileHUGS lycos.com> writes:
 And generally Walter and you are (rightly) adding major new features to D2
right now.


Sorry, I meant:


 And generally Walter and you are (rightly) against adding major new features
to D2 right now.


Bye,
bearophile
Jan 02 2011
prev sibling parent spir <denis.spir gmail.com> writes:
On Sun, 02 Jan 2011 04:58:28 -0500
bearophile <bearophileHUGS lycos.com> wrote:


 - I like the idea of AST macros, they are powerful, but they add a signif=


icant amount of complexity to the language. So I am not pushing a lot for t=
hem, despite I almost hate string mixings and creating code with string sni=
ppets.

I feel exactly the same.

Denis
-- -- -- -- -- -- --
vit esse estrany =E2=98=A3

spir.wikidot.com
Jan 02 2011
prev sibling parent =?ISO-8859-1?Q?Anders_F_Bj=F6rklund?= <afb algonet.se> writes:
bearophile wrote:

 	IMO the concept is interesting (especially the Python-like syntax
 for a compiled language),


 There several other examples of the same thing (like the Python compiler I'm
helping the development, ShedSkin), Boo, etc.



 but there are a lot of rough edges and development is very slow.


 Nimrod seems to contain no new ideas, and probably some large ideas of D2 are
missing, but the syntax and some smaller details are nice.



There's also http://delight.sourceforge.net/

It's based on GDC, with a Python-like syntax.

--anders
Jan 02 2011
prev sibling next sibling parent reply spir <denis.spir gmail.com> writes:
This language looks *very* interesting and sensibly designed. The author se=
ems to have taken, in addition to much input from C-like languages and Pyth=
on, the best of the Pascal line tradition. Also, he obviously "dared" getti=
ng rid of some legacy garbage. Unfortunately, not all, and took dome more. =
(Even reproduced "elif" and kept the stupid ':' of Python ;-).

On Sat, 01 Jan 2011 13:00:15 -0500
bearophile <bearophileHUGS lycos.com> wrote:


 I show some Nimrod features [...]


=46rom the tutorial:
"Parameters are constant in the procedure body. Their value cannot be chang=
ed because this allows the compiler to implement parameter passing in the m=
ost efficient way. If the procedure needs to modify the argument for the ca=
ller, a var parameter can be used"

Bravo! For me, the primary effect is not allowing optimisation, but that no=
w "parameter" means parameter; so that one can reason about the code.


Denis
-- -- -- -- -- -- --
vit esse estrany =E2=98=A3

spir.wikidot.com
Jan 01 2011
parent reply bearophile <bearophileHUGS lycos.com> writes:
spir:


 (Even reproduced "elif"


Python doesn't have the switch statement, so to write a switch you sometimes
use a sequence of if statements, in this case "elif" helps keep the code more
tidy:

x = 3
if x == 0:
    pass
elif x = 1:
    pass
else:
    pass



 and kept the stupid ':' of Python ;-).


It comes from usability studies on the ABC language. If you are going to use a
Python-like syntax, then removing those ":" is stupid.



 "Parameters are constant in the procedure body. Their value cannot be changed
because this allows the compiler to implement parameter passing in the most
efficient way.


I have missed that part of the docs. What kind of "most efficient way"?

Bye,
bearophile
Jan 01 2011
parent reply spir <denis.spir gmail.com> writes:
On Sat, 01 Jan 2011 18:36:17 -0500
bearophile <bearophileHUGS lycos.com> wrote:


 spir:
=20

 (Even reproduced "elif"


=20
 Python doesn't have the switch statement, so to write a switch you someti=


mes use a sequence of if statements, in this case "elif" helps keep the cod=
e more tidy:

=20
 x =3D 3
 if x =3D=3D 0:
     pass
 elif x =3D 1:
     pass
 else:
     pass


Sorry, my words were too imprecise; and too strong for such a little issues=
. I aggre with you, but it's not my point (I wrote "elif" in quote: it's ab=
out the term). "elif" is nearly unguessable: should be "elseif" or "elsif" =
(--> Lua does it right).


 and kept the stupid ':' of Python ;-).




Sorry again, for "stupid".=20


 It comes from usability studies on the ABC language. If you are going to =


use a Python-like syntax, then removing those ":" is stupid.

IIRC, said usability studies were about indented code structure (as opposed=
 to token-delimited structure). I have never read anything in studies about=
 ':'. This non-token, that does not mean anything, should at best be option=
al, just like the ';' statement terminator (which is allowed in python, but=
 no one uses it outside multi-statement lines, probably because, precisely,=
 it does not mean anything).
When I used python everyday, I constantly repeted 2 syntax errors:
* forgetting ':' (just like forgetting ';' in D)
* using '=3D' instead of '=3D=3D' (obvious reason, same in D)
These are for me 2 grammatical design errors.


 "Parameters are constant in the procedure body. Their value cannot be c=




hanged because this allows the compiler to implement parameter passing in t=
he most efficient way.

=20
 I have missed that part of the docs. What kind of "most efficient way"?


nsure. I guess the author refers to the possibility to pass _any_ non-var p=
arameter by ref under the hood if more efficient, since it won't be changed=
. (arrays, which have copy semantics in Nimrod , its tuples ~ structs, and =
object types also are value types apparently)
I plan to do the same for my toy project one day. Pleased to see I'm not th=
e only fool ;-)


Denis
-- -- -- -- -- -- --
vit esse estrany =E2=98=A3

spir.wikidot.com
Jan 02 2011
parent reply bearophile <bearophileHUGS lycos.com> writes:
spir:


 "elif" is nearly unguessable: should be "elseif" or "elsif" (--> Lua does it
right).


"elif" is 4 chars long, as "else", this is not a random choice.



 IIRC, said usability studies were about indented code structure (as opposed to
token-delimited structure). I have never read anything in studies about ':'.


This is from Guido's blog:
http://python-history.blogspot.com/2009/02/early-language-design-and-development.html


However, ABC’s authors did invent the use of the colon that separates the
lead-in clause from the indented block. After early user testing without the
colon, it was discovered that the meaning of the indentation was unclear to
beginners being taught the first steps of programming. The addition of the
colon clarified it significantly: the colon somehow draws attention to what
follows and ties the phrases before and after it together in just the right
way.<


Bye,
bearophile
Jan 02 2011
parent reply Iain Buclaw <ibuclaw ubuntu.com> writes:
== Quote from bearophile (bearophileHUGS lycos.com)'s article

 spir:

 "elif" is nearly unguessable: should be "elseif" or "elsif" (--> Lua does it




right).

 "elif" is 4 chars long, as "else", this is not a random choice.


Less is not more in this case. I agree with elsif (Perl does it right too :)
Jan 02 2011
parent bearophile <bearophileHUGS lycos.com> writes:
Iain Buclaw:


 Less is not more in this case. I agree with elsif (Perl does it right too :)


I was talking about vertical alignments (4 with 4), not about saving one or two
chars :-)

Bye,
bearophile
Jan 02 2011
prev sibling next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Andrei:


 My fantasy: bearophile goes to the Nimrod forum and says "Hey, how about 
 this D language, seems interesting..." :o)


That fantasy of yours means that I am interested in using my time to explain to
Nimrod developers what's good in D, what may be modified or improved, to steal
some of the good ideas of the D language for the development and spreading of
Nimrod :-)

Bye,
bearophile
Jan 01 2011
next sibling parent spir <denis.spir gmail.com> writes:
On Sun, 02 Jan 2011 01:46:46 -0500
bearophile <bearophileHUGS lycos.com> wrote:


 My fantasy: bearophile goes to the Nimrod forum and says "Hey, how abou=




t=20

 this D language, seems interesting..." :o) =20


=20
 That fantasy of yours means that I am interested in using my time to expl=


ain to Nimrod developers what's good in D, what may be modified or improved=
, to steal some of the good ideas of the D language for the development and=
 spreading of Nimrod :-)

That's a Very Good Thing: imo, the programming community desperately needs =
Bearophile's (instead of each designer not even beeing aware of alternative=
s and/or believing in one only way and/or wearing blinders).

Denis
-- -- -- -- -- -- --
vit esse estrany =E2=98=A3

spir.wikidot.com
Jan 02 2011
prev sibling next sibling parent reply "Araq" <rumpf_a web.de> writes:
On Sunday, 2 January 2011 at 06:46:46 UTC, bearophile wrote:

 Andrei:


 My fantasy: bearophile goes to the Nimrod forum and says "Hey, 
 how about this D language, seems interesting..." :o)


 That fantasy of yours means that I am interested in using my 
 time to explain to Nimrod developers what's good in D, what may 
 be modified or improved, to steal some of the good ideas of the 
 D language for the development and spreading of Nimrod :-)

 Bye,
 bearophile


There is no need though. I'm already aware of D. And copied 
nothing from it; features like CTFE or UCS have been in Nimrod's 
design before D got them. Please consider that most of Nimrod's 
design is from 2004, but development is slow enough that other 
people got the same ideas. Nimrod is still different from D, and 
includes many features that D does not have (distinct types, AST 
macros, sum types, iterators, realtime GC) as well as lacks some 
"anti-features" (like unchecked unions or undetectable integer 
overflows).
May 24 2012
next sibling parent reply "Froglegs" <lugtug yahoo.com> writes:
  Like the design, syntax is way better than D

  But half of what makes a language are the 
compilers/debuggers/tool
May 24 2012
parent reply Kevin Cox <kevincox.ca gmail.com> writes:
On May 24, 2012 6:53 PM, "Froglegs" <lugtug yahoo.com> wrote:

  Like the design, syntax is way better than D

  But half of what makes a language are the compilers/debuggers/tool


I like many ideas of the language but there are some show-stoppers for me.
For example the fact that you have to define things in order.  I shouldn't
have to deal with that in this day and age.
May 24 2012
parent reply "Araq" <rumpf_a web.de> writes:
On Thursday, 24 May 2012 at 22:56:52 UTC, Kevin Cox wrote:

 On May 24, 2012 6:53 PM, "Froglegs" <lugtug yahoo.com> wrote:

  Like the design, syntax is way better than D

  But half of what makes a language are the 
 compilers/debuggers/tool


 I like many ideas of the language but there are some 
 show-stoppers for me.
 For example the fact that you have to define things in order.  
 I shouldn't
 have to deal with that in this day and age.


Nimrod is full of constructs that have inlining semantics and as 
such declaration order matters quite a bit. The D compiler 
has/had bugs with this feature for a reason. ;-)
I'm considering to weaken the requirement but I don't mind this 
feature: Having the order reflect the call graph has its 
advantages too. Many consider the resulting order *backwards*, 
but at least there is *an* order.
May 24 2012
next sibling parent reply Jacob Carlborg <doob me.com> writes:
On 2012-05-25 01:21, Araq wrote:


 Nimrod is full of constructs that have inlining semantics and as such
 declaration order matters quite a bit. The D compiler has/had bugs with
 this feature for a reason. ;-)
 I'm considering to weaken the requirement but I don't mind this feature:
 Having the order reflect the call graph has its advantages too. Many
 consider the resulting order *backwards*, but at least there is *an* order.


I don't know about Nimrod but in Ruby and I assume in other languages 
like JavaScript, PHP and similar, the order of declarations only matters 
at top level. Example in Ruby:

def foo (args)
   bar(args)
end

foo(3)

def bar (args)
   p args
end

Results in:

NoMethodError: undefined method ‘bar’ for main:Object

But if I wrap everything in a class the order doesn't matter:

class Bar
   def foo (args)
     bar(args)
   end

   def initialize
     foo(3)
   end

   def bar (args)
     p args
   end
end

Bar.new

Prints '3' as excepted.

-- 
/Jacob Carlborg
May 25 2012
parent reply Russel Winder <russel winder.org.uk> writes:
On Fri, 2012-05-25 at 10:43 +0200, Jacob Carlborg wrote:
[...]

 I don't know about Nimrod but in Ruby and I assume in other languages=20
 like JavaScript, PHP and similar, the order of declarations only matters=


=20

 at top level. Example in Ruby:


Surely with dynamic languages like Python, Ruby, Groovy etc. declaration
order is irrelevant, it is execution order that matters.  Your example
holds but only by following what execution happens not what the compiler
does.

[...]

 Prints '3' as excepted.


No exception there ;-)

--=20
Russel.
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D
Dr Russel Winder      t: +44 20 7585 2200   voip: sip:russel.winder ekiga.n=
et
41 Buckmaster Road    m: +44 7770 465 077   xmpp: russel winder.org.uk
London SW11 1EN, UK   w: www.russel.org.uk  skype: russel_winder
May 25 2012
parent reply Jacob Carlborg <doob me.com> writes:
On 2012-05-25 10:53, Russel Winder wrote:

 On Fri, 2012-05-25 at 10:43 +0200, Jacob Carlborg wrote:
 [...]

 I don't know about Nimrod but in Ruby and I assume in other languages
 like JavaScript, PHP and similar, the order of declarations only matters
 at top level. Example in Ruby:


 Surely with dynamic languages like Python, Ruby, Groovy etc. declaration
 order is irrelevant, it is execution order that matters.  Your example
 holds but only by following what execution happens not what the compiler
 does.


I suspected that. Can't the compiler do something similar?


-- 
/Jacob Carlborg
May 25 2012
parent reply Russel Winder <russel winder.org.uk> writes:
On Fri, 2012-05-25 at 11:47 +0200, Jacob Carlborg wrote:

 On 2012-05-25 10:53, Russel Winder wrote:

 On Fri, 2012-05-25 at 10:43 +0200, Jacob Carlborg wrote:
 [...]

 I don't know about Nimrod but in Ruby and I assume in other languages
 like JavaScript, PHP and similar, the order of declarations only matte=






rs

 at top level. Example in Ruby:


 Surely with dynamic languages like Python, Ruby, Groovy etc. declaratio=




n

 order is irrelevant, it is execution order that matters.  Your example
 holds but only by following what execution happens not what the compile=




r

 does.


=20
 I suspected that. Can't the compiler do something similar?


No. Dynamic languages, well ones like Python, Ruby, Groovy, and Lisp
anyway,  all have a runtime MOP which means there is nothing that a
compiler can deduce or infer.

Show me a statically typed program where the compiler infers things and
I'll show how the same program can mean whatever you want it to mean in
a dynamic language :-)

This is at the core of why people working with dynamic languages obsess
about unit and system testing and effective test coverage.=20

--=20
Russel.
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D
Dr Russel Winder      t: +44 20 7585 2200   voip: sip:russel.winder ekiga.n=
et
41 Buckmaster Road    m: +44 7770 465 077   xmpp: russel winder.org.uk
London SW11 1EN, UK   w: www.russel.org.uk  skype: russel_winder
May 25 2012
parent reply Jacob Carlborg <doob me.com> writes:
On 2012-05-25 12:30, Russel Winder wrote:


 Show me a statically typed program where the compiler infers things and
 I'll show how the same program can mean whatever you want it to mean in
 a dynamic language :-)


auto a = 3; // a is inferred as int :)

-- 
/Jacob Carlborg
May 25 2012
parent reply Russel Winder <russel winder.org.uk> writes:
On Fri, 2012-05-25 at 13:26 +0200, Jacob Carlborg wrote:

 On 2012-05-25 12:30, Russel Winder wrote:
=20

 Show me a statically typed program where the compiler infers things and
 I'll show how the same program can mean whatever you want it to mean in
 a dynamic language :-)


=20
 auto a =3D 3; // a is inferred as int :)


What (keep it small :-) do you want this to do in, say, Groovy?

--=20
Russel.
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D
Dr Russel Winder      t: +44 20 7585 2200   voip: sip:russel.winder ekiga.n=
et
41 Buckmaster Road    m: +44 7770 465 077   xmpp: russel winder.org.uk
London SW11 1EN, UK   w: www.russel.org.uk  skype: russel_winder
May 25 2012
parent "Mehrdad" <wfunction hotmail.com> writes:
On Friday, 25 May 2012 at 13:38:38 UTC, Russel Winder wrote:

 What (keep it small :-) do you want this to do in, say, Groovy?


"Bring out nasal demons" :-)
May 25 2012
prev sibling parent reply Chad J <chadjoan __spam.is.bad__gmail.com> writes:
On 05/24/2012 07:21 PM, Araq wrote:

 On Thursday, 24 May 2012 at 22:56:52 UTC, Kevin Cox wrote:

 On May 24, 2012 6:53 PM, "Froglegs" <lugtug yahoo.com> wrote:

 Like the design, syntax is way better than D

 But half of what makes a language are the compilers/debuggers/tool


 I like many ideas of the language but there are some show-stoppers for
 me.
 For example the fact that you have to define things in order. I shouldn't
 have to deal with that in this day and age.


 Nimrod is full of constructs that have inlining semantics and as such
 declaration order matters quite a bit. The D compiler has/had bugs with
 this feature for a reason. ;-)


OK, now I'm curious.  Why?


 I'm considering to weaken the requirement but I don't mind this feature:
 Having the order reflect the call graph has its advantages too. Many
 consider the resulting order *backwards*, but at least there is *an* order.


Wouldn't it be good enough to define the order arbitrarily when building 
your symbol table?  What kind of information is this allowing the 
programmer to convey to the compiler?

I'm already skeptical because I have no intuition for how this allows me 
to better optimize my code ;)

Btw, I've looked at Nimrod a while ago (year+) and found it very 
elegant.  I love good metaprogramming.  I think my only complaints were 
the bus-factor and the apparent lack of array slices (the kind that 
doesn't cause copying).  Still, very promising.
May 26 2012
next sibling parent reply "F i L" <witte2008 gmail.com> writes:
Chad J wrote:

 I think my only complaints were the bus-factor and the apparent 
 lack of array slices (the kind that doesn't cause copying).  
 Still, very promising.


It actually does have slices as a construct in the system lib 
(included by default).




but I'm not sure how they stack up against D's in practice.
May 26 2012
parent reply "Araq" <rumpf_a web.de> writes:
On Saturday, 26 May 2012 at 17:59:46 UTC, F i L wrote:

 Chad J wrote:

 I think my only complaints were the bus-factor and the 
 apparent lack of array slices (the kind that doesn't cause 
 copying).  Still, very promising.


 It actually does have slices as a construct in the system lib 
 (included by default).




 but I'm not sure how they stack up against D's in practice.


Nimrod's builtin slices copy. It's possible to implement more 
D-like slices in Nimrod, but a bit tricky. However, if you don't 
copy slicing a large string (or array) keeps the whole string in 
memory so it's questionable whether it's a good idea.

D implements slices as (ptr, length) pairs which causes issues 
for a GC as that invites lots of interior pointers and GCs tend 
to have problems with those, causing at least some overhead in 
the GC/memory system.
May 28 2012
next sibling parent "jerro" <a a.com> writes:
 Nimrod's builtin slices copy. It's possible to implement more 
 D-like slices in Nimrod, but a bit tricky. However, if you 
 don't copy slicing a large string (or array) keeps the whole 
 string in memory so it's questionable whether it's a good idea.


In that case you can still explicitly copy a slice in D.
May 28 2012
prev sibling parent reply sclytrack <sclytrack iq87.fr> writes:
 D implements slices as (ptr, length) pairs which causes issues for a GC
 as that invites lots of interior pointers and GCs tend to have problems
 with those, causing at least some overhead in the GC/memory system.


The site says Nimrod allows for soft-realtime. Could you talk more about 
the GC.
May 28 2012
parent "Araq" <rumpf_a web.de> writes:
 The site says Nimrod allows for soft-realtime. Could you talk 
 more about the GC.


It didn't make it into 0.8.14 and afaik hasn't been used within a 
game engine yet. But it has been tested with the compiler itself 
with very good results: A 2ms max pause time was met in all cases 
(on modern hardware).

Documentation is here: 
https://github.com/Araq/Nimrod/blob/master/doc/gc.txt
May 28 2012
prev sibling parent reply "Araq" <rumpf_a web.de> writes:
On Saturday, 26 May 2012 at 11:49:47 UTC, Chad J wrote:

 On 05/24/2012 07:21 PM, Araq wrote:

 On Thursday, 24 May 2012 at 22:56:52 UTC, Kevin Cox wrote:

 On May 24, 2012 6:53 PM, "Froglegs" <lugtug yahoo.com> wrote:


 Nimrod is full of constructs that have inlining semantics and 
 as such
 declaration order matters quite a bit. The D compiler has/had 
 bugs with
 this feature for a reason. ;-)


 OK, now I'm curious.  Why?


Because it's hard to implement? ;-)





   template t() = ...


And Nimrod supports symbol table inspection:

   when not defined(p):
     proc p = echo "a"
   else:
     proc p = echo "b"


These things can be solved, but it's lots of work and I have no 
idea how the result would affect compile times (probably 
negligible).



 I'm considering to weaken the requirement but I don't mind 
 this feature:
 Having the order reflect the call graph has its advantages 
 too. Many
 consider the resulting order *backwards*, but at least there 
 is *an* order.


 Wouldn't it be good enough to define the order arbitrarily when 
 building your symbol table?  What kind of information is this 
 allowing the programmer to convey to the compiler?


I was talking about readability here. You can read an ordinary 
(smallish) Nimrod program from *bottom to top*. (And a forward 
declaration often screams "warning: mutually recursive procs 
ahead").
Granted, from *top to bottom* would be nicer, but I have never 

order); but admittedly that's a very weak point.


 I'm already skeptical because I have no intuition for how this 
 allows me to better optimize my code ;)



 Btw, I've looked at Nimrod a while ago (year+) and found it 
 very elegant.  I love good metaprogramming.  I think my only 
 complaints were the bus-factor and the apparent lack of array 
 slices (the kind that doesn't cause copying).  Still, very 
 promising.


See my other answer about the slicing. The bus factor got better 
as there are now 3 core developers. :-)
May 28 2012
next sibling parent reply Chad J <chadjoan __spam.is.bad__gmail.com> writes:
On 05/28/2012 04:21 AM, Araq wrote:

 On Saturday, 26 May 2012 at 11:49:47 UTC, Chad J wrote:

 On 05/24/2012 07:21 PM, Araq wrote:

 On Thursday, 24 May 2012 at 22:56:52 UTC, Kevin Cox wrote:

 On May 24, 2012 6:53 PM, "Froglegs" <lugtug yahoo.com> wrote:


 Nimrod is full of constructs that have inlining semantics and as such
 declaration order matters quite a bit. The D compiler has/had bugs with
 this feature for a reason. ;-)


 OK, now I'm curious. Why?


 Because it's hard to implement? ;-)





 template t() = ...


I'm reading this to mean that t might contain other definitions, so 
building a symbol table to completion would involve leapfrogging 
template/macro expansion with symbol table invalidation/insertions.  At 
some level though, I expect the compiler to do this for me.


 And Nimrod supports symbol table inspection:

 when not defined(p):
 proc p = echo "a"
 else:
 proc p = echo "b"


 These things can be solved, but it's lots of work and I have no idea how
 the result would affect compile times (probably negligible).


p() should print "a": p wasn't defined to begin with.  It wouldn't be 
intuitive to me if the when statement is evaluated more than once, not 
unless it's found within a macro or something that iterates.


 I'm considering to weaken the requirement but I don't mind this feature:
 Having the order reflect the call graph has its advantages too. Many
 consider the resulting order *backwards*, but at least there is *an*
 order.


 Wouldn't it be good enough to define the order arbitrarily when
 building your symbol table? What kind of information is this allowing
 the programmer to convey to the compiler?


 I was talking about readability here. You can read an ordinary
 (smallish) Nimrod program from *bottom to top*. (And a forward
 declaration often screams "warning: mutually recursive procs ahead").
 Granted, from *top to bottom* would be nicer, but I have never seen that

 admittedly that's a very weak point.


But... I like my arbitrary ordering.  I don't necessarily define 
functions according to their call graph, but instead with functionality 
groupings and mnemonics.


 I'm already skeptical because I have no intuition for how this allows
 me to better optimize my code ;)



 Btw, I've looked at Nimrod a while ago (year+) and found it very
 elegant. I love good metaprogramming. I think my only complaints were
 the bus-factor and the apparent lack of array slices (the kind that
 doesn't cause copying). Still, very promising.


 See my other answer about the slicing. The bus factor got better as
 there are now 3 core developers. :-)


Congrats!
May 28 2012
parent reply "Froglegs" <lugtug yahoo.com> writes:
* Can you do metaprogramming with nimrod templates? Are they as 
powerful as C++/D in this regard? Docs for templates is very 
short, making me think you can't do much, but perhaps it just 
isn't covered?

*also what is up with lack of unsigned integer types?

*not a big fan of forward declaring things, just seems very 
primitive, something the compiler should do

*can you create unnamed procs?


+see closures is upcoming, that should be nice
May 29 2012
parent "Araq" <rumpf_a web.de> writes:
On Tuesday, 29 May 2012 at 08:00:11 UTC, Froglegs wrote:

 * Can you do metaprogramming with nimrod templates? Are they as 
 powerful as C++/D in this regard? Docs for templates is very 
 short, making me think you can't do much, but perhaps it just 
 isn't covered?


Yes docs are sparse for now. It is (or will be) as powerful as 
C++/D in this regard.


 *also what is up with lack of unsigned integer types?


They will be added, don't worry. In fact, they can already be 
implemented in a pure library form. I wanted to prevent 
programmers from using them (as "unsigned" is *not* the same as 
"natural" and is bug prone), so leaving them out seemed a good 
means to accomplish that. ;-)


 *not a big fan of forward declaring things, just seems very 
 primitive, something the compiler should do


As I said, its priority is low.


 *can you create unnamed procs?


Yes.
May 30 2012
prev sibling parent "Kagamin" <spam here.lot> writes:
On Monday, 28 May 2012 at 08:21:36 UTC, Araq wrote:

 Granted, from *top to bottom* would be nicer, but I have never 

 order); but admittedly that's a very weak point.



either thematically grouped or top to bottom (e.g. Main comes 
first). "Extract method" refactoring also places extracted method 
after the method it was extracted from.
May 29 2012
prev sibling next sibling parent reply Walter Bright <newshound2 digitalmars.com> writes:
On 5/24/2012 12:58 PM, Araq wrote:

 There is no need though. I'm already aware of D. And copied nothing from it;
 features like CTFE or UCS have been in Nimrod's design before D got them.
Please
 consider that most of Nimrod's design is from 2004, but development is slow
 enough that other people got the same ideas. Nimrod is still different from D,
 and includes many features that D does not have (distinct types, AST macros,
sum
 types, iterators, realtime GC) as well as lacks some "anti-features" (like
 unchecked unions or undetectable integer overflows).


Nice to see you here! Welcome!
May 24 2012
parent "Araq" <rumpf_a web.de> writes:
On Friday, 25 May 2012 at 00:46:34 UTC, Walter Bright wrote:

 Nice to see you here! Welcome!


Thank you. Let's see how long I will stay. ;-)
May 25 2012
prev sibling parent reply =?UTF-8?B?IkrDqXLDtG1lIE0uIEJlcmdlciI=?= <jeberger free.fr> writes:
Araq wrote:

 On Sunday, 2 January 2011 at 06:46:46 UTC, bearophile wrote:

 Andrei:


 My fantasy: bearophile goes to the Nimrod forum and says "Hey, how
 about this D language, seems interesting..." :o)


 That fantasy of yours means that I am interested in using my time to
 explain to Nimrod developers what's good in D, what may be modified or=





 improved, to steal some of the good ideas of the D language for the
 development and spreading of Nimrod :-)

 Bye,
 bearophile


=20
 There is no need though. I'm already aware of D. And copied nothing fro=


m

 it; features like CTFE or UCS have been in Nimrod's design before D got=



 them. Please consider that most of Nimrod's design is from 2004, but
 development is slow enough that other people got the same ideas. Nimrod=



 is still different from D, and includes many features that D does not
 have (distinct types, AST macros, sum types, iterators, realtime GC) as=



 well as lacks some "anti-features" (like unchecked unions or
 undetectable integer overflows).
=20


	One D feature I'm really missing in Nimrod is the
scope(exit/success/failure) statement. Other than that, I tend to
prefer Nimrod (easier syntax, better choice of names...)

		Jerome
--=20
mailto:jeberger free.fr
http://jeberger.free.fr
Jabber: jeberger jabber.fr
May 24 2012
parent "Araq" <rumpf_a web.de> writes:
On Friday, 25 May 2012 at 05:18:09 UTC, Jérôme M. Berger wrote:

 Araq wrote:
 	One D feature I'm really missing in Nimrod is the
 scope(exit/success/failure) statement. Other than that, I tend 
 to
 prefer Nimrod (easier syntax, better choice of names...)

 		Jerome



Indeed this is a nice feature to copy. It is, however, possible 
to implement as a macro.
May 25 2012
prev sibling next sibling parent reply Jacob Carlborg <doob me.com> writes:
On 2011-01-02 07:46, bearophile wrote:

 Andrei:


 My fantasy: bearophile goes to the Nimrod forum and says "Hey, how about
 this D language, seems interesting..." :o)


 That fantasy of yours means that I am interested in using my time to explain
to Nimrod developers what's good in D, what may be modified or improved, to
steal some of the good ideas of the D language for the development and
spreading of Nimrod :-)

 Bye,
 bearophile


 From http://force7.de/nimrod/index.html

"Whole program dead code elimination: Only used functions are included 
in the executable."

So if my application doesn't have any output I won't get an executable 
when I compile it :)

-- 
/Jacob Carlborg
May 25 2012
parent reply "dom96" <morfeusz8 gmail.com> writes:
On Friday, 25 May 2012 at 11:31:13 UTC, Jacob Carlborg wrote:

 On 2011-01-02 07:46, bearophile wrote:

 Andrei:


 My fantasy: bearophile goes to the Nimrod forum and says 
 "Hey, how about
 this D language, seems interesting..." :o)


 That fantasy of yours means that I am interested in using my 
 time to explain to Nimrod developers what's good in D, what 
 may be modified or improved, to steal some of the good ideas 
 of the D language for the development and spreading of Nimrod 
 :-)

 Bye,
 bearophile


 From http://force7.de/nimrod/index.html

 "Whole program dead code elimination: Only used functions are 
 included in the executable."

 So if my application doesn't have any output I won't get an 
 executable when I compile it :)


You will, you can compile an empty .nim file and you still get an 
executable.

BTW http://nimrod-code.org/ is the new Nimrod website, the one 
you linked to is long outdated.
May 25 2012
next sibling parent Marco Leise <Marco.Leise gmx.de> writes:
Am Fri, 25 May 2012 14:04:58 +0200
schrieb "dom96" <morfeusz8 gmail.com>:


 BTW http://nimrod-code.org/ is the new Nimrod website, the one 
 you linked to is long outdated.


So you have that problem, too? :) I was wondering already since the forum
looked a bit abandoned. You should redirect or place a prominent link on the
old page.

-- 
Marco
May 25 2012
prev sibling next sibling parent reply Marco Leise <Marco.Leise gmx.de> writes:
Andrei:

 My fantasy: bearophile goes to the Nimrod forum and says 
 "Hey, how about
 this D language, seems interesting..." :o)


"dom96" <morfeusz8 gmail.com>:

 
 BTW http://nimrod-code.org/ is the new Nimrod website, the one 
 you linked to is long outdated.


It looks like "ventor3000" mentioned D there just yesterday on those forums.
Here is an excerpt:

"[...] i'm in the CAD/CAM industry. [...] The last few years many programming
languages have popped up like mushroms, and I have investigated virtually every
one of them. Not many matches what I want, which includes:

* Fast compilation times
* Good performance
* Garbage collected
* Sourcecode without cluttered syntax
* Standalone executables
* Object oriented (I just cant stand functional languages)

The D language from digital mars is close to thoose specifications. The problem
with D is that it overcomplicates things since it tries to do everything c++
does. I really like D but i think its totally overkill for real world
applications. And I say this of long experience: Keep it simple. [...]"

The complete thread: http://forum.nimrod-code.org/t/15

-- 
Marco
May 25 2012
parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
On 5/26/12, Marco Leise <Marco.Leise gmx.de> wrote:

 It looks like "ventor3000" mentioned D there just yesterday on those forums.
 Here is an excerpt:
 "I really like D but i think its totally overkill for
 real world applications. And I say this of long experience: Keep it simple.
 [...]"


You can always keep the D code simple, it's totally up to the
programmer. I really don't understand what is "overkill" about D,
nobody is forced to use every single feature in the language. And on
the plus side, as you write more D code you come to realize its
various features come in really handy.
May 26 2012
prev sibling parent Jacob Carlborg <doob me.com> writes:
On 2012-05-25 14:04, dom96 wrote:


 You will, you can compile an empty .nim file and you still get an
 executable.

 BTW http://nimrod-code.org/ is the new Nimrod website, the one you
 linked to is long outdated.


Ah, thanks. I though that the address didn't look quite right.

-- 
/Jacob Carlborg
May 26 2012
prev sibling next sibling parent reply Jacob Carlborg <doob me.com> writes:
On 2011-01-02 07:46, bearophile wrote:

 Andrei:


 My fantasy: bearophile goes to the Nimrod forum and says "Hey, how about
 this D language, seems interesting..." :o)


 That fantasy of yours means that I am interested in using my time to explain
to Nimrod developers what's good in D, what may be modified or improved, to
steal some of the good ideas of the D language for the development and
spreading of Nimrod :-)

 Bye,
 bearophile


I had a look at the Nimrod language, the template and macro features 
look really cool. I would love to have those in D.

-- 
/Jacob Carlborg
May 26 2012
parent "John Belmonte" <john neggie.net> writes:
On Saturday, 26 May 2012 at 16:01:25 UTC, Jacob Carlborg wrote:

 I had a look at the Nimrod language, the template and macro 
 features look really cool. I would love to have those in D.


I would be great to see such a mechanism employed to increase the 
power-to-weight ratio of the D language (e.g. relegate a 
construct like "scope" to the standard library).
May 26 2012
prev sibling parent "Kagamin" <spam here.lot> writes:
On Sunday, 2 January 2011 at 06:46:46 UTC, bearophile wrote:

 That fantasy of yours means that I am interested in using my 
 time to explain to Nimrod developers what's good in D, what may 
 be modified or improved, to steal some of the good ideas of the 
 D language for the development and spreading of Nimrod :-)


Huh, system pl with python syntax, it's your dream, isn't it?
May 29 2012
prev sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
 - I like the idea of AST macros, they are powerful,


A nice example of macro usage:
http://lambda-the-ultimate.org/classic/message6437.html

Bye,
bearophile
Jan 03 2011
parent "Alex_Dovhal" <alex_dovhal yahoo.com> writes:
"bearophile" <bearophileHUGS lycos.com> wrote

 - I like the idea of AST macros, they are powerful,


 A nice example of macro usage:
 http://lambda-the-ultimate.org/classic/message6437.html

 Bye,
 bearophile


D can also do some 
https://github.com/AlexYD/DPP/blob/master/bin/Debug/test.d
Jan 03 2011