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 x = 0 # x is of type ``int`` y = 0'i8 # y is of type ``int8`` z = 0'i64 # z is of type ``int64`` -------------------
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 /9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsK CwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRT/2wBDAQMEBAUEBQkFBQkUDQsNFBQUFBQU FBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBT/wAARCACbAMgDASIA AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3 ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3 uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD8yqcq cc0irk1JWp1i4pcYoByKcuM80DBc9qlRQTiiOPI44ruvhP8ACPW/iz4tttC0q1nkll5aSNAfLHqQ SBjp36dM0pSjBc0thHFbdvFSRq+RtUnPHAr9FvBX/BJi90/VIbrxp4ssI9IfbsS0DmRicZBJAA7j r3B7YP1b8OP2TvhR8JPDWnabdaFbeI762kBGoXsWcuG+R8Z4OOM/XsSK5nXv8K+/QD8avBnwq8X+ O7pLfQfD19qMrttHlQsQeM4z06c11fib9l74oeFNHtdU1PwdqcdpOCQ8cBk2Y7MFzj8a/ZqHxB4e 8K3FzZrZWmlxxPt8m2jVAOuDwPf9aZ/wuCztXYQNGsAUvtY5B/CsvrKT96SRfs6j6H4R3Og39pOs U9lcQSnoskTKSfoaivLeS0fy3KlgAWAOce1fsd43+NWl+L/PtL7T9PubfGCZraMgHsORzmvnv4h/ CT4SeMW8648Nx2l3Kx8y80e4Nu3PfbyhOfVa5pZlCEveV13R1xwVaS6XPzp2470piAHOK+ovib+w 7qmkaVJq/gfXLXxXEkTTyaLvVdTjjHJZYgf3ygZJKgHAPy8V8ttMY8qQc5wRivSpVYV4qcHoziqQ lBuMlqhU/ctuBOfWvU/Af7QOr+D7VbVoo7qAcAPwR+leTmfHaozLntWtjlqUY1VaaufWWj/tNeHd WTy9a0sRKep+8P5VxXxP1rwF4gtml022jW6PIZBgfjXgYmP0rb0vXLa1tnjmgEjEYDelKVzz/qEa bU4N/eZk8MG5tp47VWNsCflYVPIY5JWdThSfyqFmAPervY9OKdgS2OOtRtavk0G6IHSnfb29OPpR uX7wwWzZxQf3YxikN8SeBULSlqNil5kkZ6iio0bOKKQxAMUoGRSUo5GKAFBzVqytJLyZYoY3llbg Iikk/lTLS1e8uI4II3llkYKqIMsxPAAA61+rH7A/7G1r4D8MW/jjx1pVrFrcx820iuoN8tmASAct wG9gOM4yTwMKtZUl5mkYuR8//sl/8E9Nc+JrweI/H8b+GPChP7q2u4nW7vB3KJlWRf8AbP4A1+if ws8JfDn4DWC6R4M0j7M0Q+a7unLynPXJPI/QVBq/iCDStW1S4m1C982Tm3try88qNVIA+QFxk8ZO 7ueAK8T8V6xJ9oaa2SV53fMrSyoAn0G/Jz7ED+vkVa8rXl/X9fedKoqTsfR2tfGHTVv0hN3BcZDO zsGdEUAZJKggdcc4615x8Q/jHEkk1mklu9pIpDtLKIti4756f0ryLQvEEZ1SOOS9tnt4pFeVZkAZ wrbip5A6DrzjJ6VzniSWfxXrE15F4htTFJnzZYpI1ZT1xwDhjyeOeOK5HjJzWrsdKw0aeqRb8TeJ bdEN1e63JC5UhWUtIGA54JADYAB715rB47n8XatJa6LevcrHhHdMgKT688A9eap+LNM8GaejS3kl 1qlxICrNfXMkgDZ5Cx9Dk5PPtitr4SW1tpMzXtlp8EGlYYoiRgCVj6Hn0rG0JLS51e9FN2N1/CMr xtDdSAqwzI5cdxnOMZ9awvFeitpdhBDYM8MnCqysQNx59eeh/wAK2bvxWVnvlmkV5gwWO3AOVPfp xxkfTNWdceHUrdbu123Ucajzt642N1PH8j0rjk4Rujopuo3dnzL8WPGeq+HZNAvGvrm31OxuC9rd xzGKZGXBzkcjB6GvGfHF5L4qvz4llghgl1GRzOIFCK0y7S77RwN28E4AGScAdK98+P8A8Hb/AFvQ J/EenXcV3aWcfmPZoh8wR8AyKc4IAGeg4zXp/hj4VNb/ALMfhfTTAseu2ha7WZFVWcTlnaNtytnb 8o6Z5xz0r3qGKp0cPC2rbt+p5WIpSnVnL5nwbFFvcAKWJ6AUs1qQTlTn3617f4sttQ026az1DU0i LkgW01iiA/8AAgEL/wDAVNcxIdFCGOYaQ0y8MM3UZ/JgMV6ca91ex5Mm49DzFk2jPJ/CoJAetdV4 gn02NtltbWa9/MtpZXJ9juOPyFcyZRIx4xXUm5LUcXdEGDSpIdvr9ae3KGo6CgCZNBTBpTJlajZ8 0ANERP0p3l44pN+5qbvI4oAmihJziiltZykikjIBziis5bgR44qSGF5W2opZj0A5q3quiX+i3Bgv 7SazmH8EqFTX1T/wT5+AcPxK+IFx4p1lJP7E8O7Zo0QkG4uT9xMDkgcEjocgHIJonNRjzDiubY9K /Yw+B+l/DYWPjLxhokl5rV389na3EYC2UecbiGU/Oe3HcAd8fef/AAmF/rOjXOoWE9jZxRnyoI9Q jlkAJ6nyxsbIHPTHoT28w8UNDbTXetxIuo2kU7sfmZQ0gJBjGFYkA8MwPGQoOd5r5D8Y+PNN8ZeP 3v8AQGHhrUVfyb0wOBDKw4KiHczSYIPzNjp17V83KUqk25ansRpxtZaH2F4n8U6Zf3kVq2vS3xUB riLS4FjRT0ycAFPoz5Gc84NeI/Ef4ieDfhTatd6oklxfuMwadYzeaqjPBbPqOpGQT1POag8Uyjw9 4AXVW1JL688spBc22EQu2MMFBwAvXueOor5K8Ua9bWF3LJDLLqEt6R5rM5kZ3GMHr6jPuc1rCMpz 5ZR/r122Lo0VUg53sl/XqfTnhH9p/wAEeOLhLJ9IutC1Q5EL3EKMjYzlVbOAevynGfrWL4za01jU /tGkTQ6lNNJ5TG2UwyEsAFLYchhk5PAOOhBNfO2qaz/bN8mmyKJGYiRp0HCgHJJHqcc10Fv4purP To4Q63lpHIu64ZszhNxLIxznDZ+9kHnNOdLZpW/rv/TOpUeR3TvY9NtfCt1rt7Gt2ywWq5INy+H2 K235iOM5ByOvGMnFet2saW4t7HS23OieWWAG3Hqc9v514T4F8baVeyLYPbyWt15ZMabSCAMjcWPD EKeOcjLE16/DrUdvYOI447CExh4XWQKX3ZOAT078n1781xtckrSVjCpeetyTxDbWQ0ZbRjFO8km+ 3ikAEcjZGXZRgnlTx0BxxnNcrpEayvLb2hgtpoLjb5VjA0YUkhtvmsMN1YkD7xbbwRzR11pdBniv bS4t4596q5EgCnJ+Y5I+bjIGe5rOk8cWY1yzubU/2pHNhSTKWLDgEKucL7fStGoSi7ohRm5Xiz1X RdAF3o07GNBGI2geBPu/MNvl7Typxj5T17ZyDWlaXcz6Q9peR27ySswKXETNGgAIXKgg9fw45rQ8 MWj31otwQ6pJhjIn3gOfldcfMOxBBwOmRwOU8W+BvEt3qxuY722sgcrDf2BJeI8jOxztIwFBjbgg ZG0gYmhhJykpQWhz4nG04RcaktTgvHlppssDQ6/p0VpHMGaMSn7VYXTcDdHMWUJ7Y2secdCa+evF Xw50iW01BrG6it54/ngH2tjBGnUB1mRJYeOBuLAk5zjmvqKTwL4mube6S6msbW4uBh5NPLLa3Py4 JlgYnk9SQR0xjGQfIvEn7MHjKCdpdHvNMu9Ncl/7MuSrRwk/eCAgbQeuVCnnGBgV79GjOG6aPElj KE38aPk4sYjjjg44OaN5znivTfGfwP8AGOgzSXE3hvyIB2sWMqD3GSWrzaaJ4ZGjlRo5FOCrDBFd pcKkKivB3GGMk8kUySM59/anuwq3pGqHStTt7wRRztCwYRzLuVvYiqaSLe2hatfBGvXcIkh0e9lQ jIZIGII/Ksq80+50+UxXMEtvIOqyoVP619E6P+2FNp2nxWs/hazdI1CKYpNvH/fNcD8VfjWnxLgS JfD9ppu1smZDukPtnAxQ7W0ZxQq13O0oWXe55WBQRmpCox6UzmpO4Ih83tRT4l5wKKiW4H2doviF fi08lqZ/DVzP5ZaQCJ5GVPU5I4r6AtbrRvA3hibwHFpmp6faSbJNQfT7WQS3OVzsEa4bbyQSxxkn 5Txjxz9kTxb4Omim1A6dJ4cvYOJrnTIjhTzjY5G5nxk4HC8Ek9K918d6rb3OrxX/AIUv9MuI3G0D 7a32l+ADmVgq5PU5B/WvHxlR6ovA0XTfMkcH4u+IGs674b1XRbPVHtfMH2DTlt7doDYKMKVaNjhW wThlx9SSK+Up/BniL4TWEWq32o20lrOBEbNW8uVs5PAUEZGCSG79jxXtXjfSPiHqnikpp4s9URpN 15a6dIBsQ7cs05GwHjoD26d682vdBbXorJdfFvDduXjaISEMCJSACCcEgYPY8ZxXHRm6S30/r7j2 /ZOpKx3Xxa8UkeCNCuYJJLi3a2/dK03mOQVwNzA/M3PPavnPTbPUJUmVHZRGRII+M8+/XP0r6Tm8 B6bcfDrQtXvryaz0W3V444rdQXmKsQdoxz05P1ryDxd4xguZGs7PT0s7e2BjiEKHK9eTyc4x19SK 6cFVaTja7b3fa+hvV5Eoxh0/M4+2nl0mS4ljP7yRCuGIYnJ6n9K7z4Aw2viLxRqOiapGGj1K0kCG Q42sAcY9fz7Vzei6SNfu4YYXSbcQVR+uMHHPv6f4V9BeAPg3a6Nr2i6oqljHKGLDOAxwAMenp9eh 6V2VpR5XF7v9Nji5pQa1/pnkVjplxo0N+sVws2m2szJPbsh++pwrrx3wT1xg9653xb8Ytc1HVJlS 5eKIHHGAf0r2bWfCq2Wv6488f2Npbh94LEjG7KkjtyevI57c1438UvAMuk+IFuI49trMyhyo+VGO B+prKjOlOo1NanRUjNQSp7nO6r4h1fWLS2e4vJWLt5aJuPIr2b4H+Fi+rR38p4giIKueM44rzG90 OSy17Rd8Xl2YuEgI9CSMN+P9K9ln1q38H2lw1s4SWSPC4Gcn0x1P5Gliqq5Y04Lf/M39m6bmpb6L 8Nz6R+HvigPGEtpg4+6UJyG+vr0rrJrfSb797HK9sxOGhbkL9D3H+ea+fvgl4qXWJAYbRhDCiwyX WCtujnDM3mNgcEYxnq3fFd1+1h8O/EXhfR7Lx58PtSne3W3Q6na253RrtjGH2HPXHOO+fXjvwlRw XvLb8v6+Z8Tj8M5StF79+/l2PQjo1s/3LgMPQcVRvNDeMFomDAV8VaT+2d4p0u18jUdJtL+ZePMY tG34jmq91+2p4ukDCPT7KJSeBljgfnXvqtRt1PDeXYh6W/E+xZo3VikqArjneMivLPiz4d8CRWjX PiPR8xkc3MUBO36lRxXgaftj+L2cCSy0+Rf7pDj/ANmrrvDH7UPiDx5v0RfBVrrMkyFTGlwVyPfI 6Vz1KlOSt+auEcBXpvn6etjhf+EL+EWq3T+X4jlsIifl3FuPzU123hv9lDwV40tPO0jxm23HDNtI /KvM/H/wM8WWct1q3/COJpNkx3i1iuN/livNbbUNU0dz9nuLm0b/AKZuy/yrjjaL95fmj1FSnUj+ 5rP8GfUzfsIWjj9340g9iyD/ABrFuv2Gr9Jtlt4rsph7x8/+hV873PinW7mTdNq185/2rh/8afD4 08Q2wxDrmoxr6LdOP61o3Sf2X9//AADT2OKW1X8D6m8P/sDPdBDe6+uQRuEagAjPPrXQXn7E/hTR QguZL64wTuZHOCPw718j2vxS8Y6ecw+J9VT/ALe3P8zWza/tDfES0UKniq+ZR2kIb+YrVSw6+w/v /wCGMJ4fGy2q/ofR9z+yd4HRxsW+X/tqaK8Ag/aY+IY4bXy3+/Ep/pRUOVFv4f6+8hYfGr/l5+L/ AMj6/wD2cNJhbS4rDS9F/tPURZ/vLLTnUQxkttVPNOfmZgcnH9/JyQR0Wq/CHxtq/iWLTbCxtNWv obnzFk1bUnNpp8XQxgIFdmJJ4DEnj5cZrmPh38TotK8PeJbPRr1NJj0mGB5Li3hVHnkuM+RAN3DE KVVVAJyzk53fJf0D4FwfFrULvVdNsPEng+UXKpda1faooFw4By8dvEodj3BA6ntg4+ZlFN3kfYQf Jexf+Ims2Hwz8RWGk6re+GdR1CwXzH02226Ou8gcxvIrFsY6mRD+ea4Wfxj8NPEssVnZeBWHiDWX MizX9nIsVw6t92JlZwwxn5stnnpXpvjH9n6TQ9LhPiPxZa+KGRxJBcePrjykWMHOxIi4lfJA++QO n0rjfEHxP8Y3V1ey6jY6Fc6FZMlvHqNupgkU88JuzhV2jOSAAc84xWFWMVe17vzsbU3J2svzMf42 +MtF+HGh2fh2FIbm+sLWSWS0AAgUqQzR4z13NtwMnDZxivmnQfBuoeJr+a5tWgnWFG8+NSFMbgcx 4bGcHOTjHTJAOa9S8T+Dm8ealO1zbz2tzqiJEkjD5bWzXgXJLEAGURoo3Y3ADAJDY6X4NeINe13Q H8N6Do8FvZWEhhh1CO3THlAjBG4jMjsOZCDg5KjIFdtFKnHQx529CH4M/AZpfEvhz+z7ddYWYu+q SCR47SHaVwgl/j+YEEDqGJAIGa+sPBXgW38QWN6NOQxRW0u99q4VN5+VRk9OwxzwfSsfQdFu/Bel M41aG2ht4Nlrax7PLEnmJF5IP8TIX3HG1evy5yR7t4JkitNN0vTYbdPLtr4xzSQnZGCqnzGAPLHd uBbHqBWns+d67nBVqXtY+OPjD4RvtD8Q6nJPLGJ5nZyhyd69OVwCBg14Z4z+1eKbfUNPOEke2ULu HRx0xx7Cvoz9qrxr4f0/4oT2NlZiOVyRNdzZdpSSVYDJ7HGcDPv2rwvxxokkNrY6hpMrMkybVypI PGR15/OvDu4VN9tn0PqcMlKC51q1+n+RzXwq+MfhSfRYtN8Vacx1m3OBMYBIkhBwp2cDcMng98nr 043xz44vviF4ouEs4yDI+1Y7eMLtjGAMDOBwB39eaXxN4X1C2spNWtbfbIj/AL29hh3sGI5yeoPv XNaHvuY1tndoEVt6NFCI9/8Aey/U/wCQBXt0qdOTdWP+djnr1KllSnK7XXyPZPhja6hqGp2GnpD9 i0+zKxxW08+3c33mZzg9CzEn6cV9/fD/AFXS47VvDcs9rrEd1G0MtzLMXhA24crxyBuZSR3OOMYr 86/BcM8GqoUtLqQkBDHEshPXI+RUYkfUqD7819UfDHUdS1bUc3do6Wlmi5Ew8uWT5g20R8sfur9f atYz5JaHg4uld+h83/tc/s9y/Daa38RWpaTT9QmkC5IOAGbLccAZ2qAK+YyOxB/Cv1i/aO+Ds/xU +A+nafZbmvbK+E7wxKHYKVYiJOeeoBJ4BPtX5o+LfhN4m8KX08WoaLfWKIfvTW7qgGcDkj/9degm o2VzgoyurPdHGjYTg5qa1uZrC4We0nlt5l5WSNirD6EV2Gn/AAQ8b6nBb3EXhy/W2uJBFDNLAyJI e+0n7wHcjOKfdfA3xraXKQHw/qEkxOCEtXwM9OSME/Tp9eA3OPVm+jMS88b+I9Sg8m617UbmL+5L cOw/U1jHzXPzFifc10kvgLxHplv59xoWpwwbtnnS2cipu9MkYzWfJZXUTOkls+FyGJjPy49alyTM 1yrZGRJA2MblIHYGoVgctwuT7Vq+Ug/hKn/YNCeY0nlxRyM7dAFyTRzWKUu5ktYzFv8AVt+VB064 AyYmx9K0prl4v4h7grTrSDU9SlWKzs5bmQ/dEMRZj+VTdlNpbmQluy87SD7iity68N6+khS50q/j K8kSWzqR+lFO9txcyfU+zPDvhdtL1DxO1hFp95aal4r0pYJoJNzNDtac7VJxu27WJxnkjqAR7PrX wMl8e+KPE1rNrOr6B9hvYbCGW0vpbeNok0wFScEAnzgueOjEdxXxJ8CfH8mk3d1o1y66laC4guLM tMUaK4iY7JIyxGPl3AqeSOB2r6v13416HoN1ealDFdX41KVpbvT5TL5k07DJIiwM55GeyqOeK8St zQfKlqenGV/eZ12qaB8P4NdluPB8tkf7PY21vcXbPLcWpAKyud7gh2JIDEjAAAyc5+evGHxNuvE/ xC1bSLSztLu4guDbwW+o3G23iEcJLzzrj5sMV4bIJ7ZrlPEOv6/4R0m7F5qgm8M3cZEEA1BGdlYA iJvLiD5UcHLKCQecGvPIfHkWm6RFa3NvHMJQ013aXDErI7HJMgVi8h56O6j/AGTjh06GvM9WOVS6 3PWG8TWd1dahq7sdSlI2Q7LqS6l1TUVUqj46+Ug2r+7VR1GMDFdXP441vwf4LsNJjmmtdZlnjg+3 KyylJJQHeTZuCqAqsR/cQjIG4rXzHF42vLG2CWt4YJL4hrtoJNji3U5EQK42LgH5Fx1BPbHY/D7x bqHj3VLzTLJIhqJLyQTvAXjhXfncEXgtgIAWIC7F9Bjs9nbUwbufQ/hLxJdeIfi0dIs9Qj0zTNJV dI0y4SN5iZCu+4kjBIDEbeZGyRwduTivoTRfiHY6HYeRpBmleOMN5r9WjDkZP+0SWPtk+lfK/wAP /FGg+Dtf0rTLDVtM1HV4Mi9vp5l3RRsDvSM/Mu8tt3BOwBIr6c8P+GdN07T2vLx7W3t44oks7SOY NI0aqGZpEGdgYgABsnAckktScJPSO5y1Kmqujyb4heE9J8ZauL2bbNebijEAkqwJ+VvfP45qq3hJ bK02PpzzxxrkDzTtwPbmjR9FvtWj8SapYIrtps8c8lzcAmFZSH5wP4ii55zyO3brdO8WXfiKOFdJ 8ZRagBmJ41tLYRg4B27VAbKjr8x6mvCrYZau7X5f1c96liZQio20PMfFt00emrZRaNCq3rGJVEhV t2Mk5Rc9xyAe1ea6F8DPEbalDcaRYzNPJI2Vt7dpJIznhmc7RjPI4ye9fY/hrQ5JUuHuYFW9QfIb GVxG2T1dmBKDJwApJ46E16fcz+G/CfhryIreI3zorSRAmNWPHLksPl7kE5bp3rrwsJQX5mNauk7p HydbfAzxB4O8JC+8R6zJZ6e0pL2unxbpZT/E0gUOXUdSWdQM4OScV614S8EaBottDK3iWxWIRq6y S3sEWFI+6VL5A6dP73vXSX1lPrl6upX974g1y4UD7NaabcTRWyc8AeUAigY77zzzmrBnv7a7iS20 nTPDVy24tK2m3NwG7AsxEK5zjPyc/wB412xu3eRwVJpqzL+vfEWHRrOVdG1Gy1G7t49xs9Pkid8E DGCZFHrjbu5rzGf40eLWu9Hskik+za5FLEg1Ke3lmgljKBw0TxK4Zd4bJduPmAIFegX2ieK9TtEi fSvD2uSSJiS3a1Kxz8gEiXJTGNxKumQeO+a5W++Ac99o0k1x4KuNJsnmS6is7e+lVYJ0GBJHsgKx nHB2cMCcjPNdt5S3v+JwpxitrnnOlfFPXDplu1raalLHa3M1nqlnZSG4lMgkYhysxyoZSDgLjJA4 4rYtPFMl7e6csF3e6QSgIt9VjuESUbj93lU3AnbtJ4xjGa7qL4DeFXtrjxRrMEeleSpee5uxJKzH ruUoY5WcHvjJPOM5NY1p4gvtVe80nRzfWWl4Bt7/AFDToXnlOMfLBczb9hB4bLZ9BVezktWwU4ye kbnVahous2ltCt1o99c6dIjF7m1djtzjgo2cAjPBKgk8ZNYeiWV14i1a/wBGnsJLWWAebE7iJlul IYLsZhknPqyEHuaZ4P0PxV4YW8kj8TLq4VNqaZqVmlkrkDjcsYT9GftgVe1fWmudNmtfFOkpodvk P9n1YXM0MbnBBSZjtAPYrIvOMnitHbz/AK8zNJc1jkfFH7J3g/xXDM1/Z2emX/mF5pX/ANDuoHz8 yujLsmU44cSL1yAR18u8Q/sA6DcrBPonim40rchzJqEkU0RfPG11C7VPYnk+g7/U0bRf2Daf2TrY 1I2zq4UFrxYVPyjMRPzIeMtGQQR1PQ+XeE/iJYeM/Het+DjdafpfiPTbp4MWV19nNx/tW8pb5iCS CkmQcEFxU3V1bqLe6j0/rqfGPxC/Z31j4famljP4X17VFdgqahEd1vIMZyoSNj+vaun+HHhHWtOE cd3rWoaQkWNlv/Y0DBR2+aVgf0r6/t/DvjbUtZ1HR9PFhba3ptk11c6PfwuLW9jztWeFFdMfxq6h sA7SBhq8wsB8QJdXWDXvD2ihdQt3C6dp15cWMlnPnKq7MZCQy/MGAIPTcDQpW1aOepCVRcqf3nTe GPEEWnaWDqN5JqFsg+aWTT1RvqdjsP0orGvPh1YpA66nY+ItGuFUeZD/AG5Ph2Of9WfNZZB7jB9h RXoPF1FpFr53PHlhFf30/l/w58HtoN1pOuT3uh3oktDcNDbXMDlTIeu1eMnGRntXWaz8UPE2mR/Y 9RKGVJAfOjI3HBOcY4Pcdj/TQ8C6HZX82mxxXDC3tdRmuY7sHy8oEUncOxyMDBJOCMVreLPBlj4u 0C+16JJoJpy91BGy7dg3MANozktjJ55/Gvn5VoKSU1fpe2p9fHRanlWr+K01qRbi5drmYsR5M67V APQ8EDv7YHesO/1K51JI1dYIYwNojtY0j3HPcL1P1rf8Y+ApdBkie3drqFlAd2Xbsb0J6c/WuPuI JLSUxOCrDqDXo0+Vq8NjNty1Z0el6MsKf8TnTryOFvlt3nzFGD1PJxz+dd94R+C1z43t4bzwu013 dRMGu9DBaOZh3MLH/WADqPvYPGa8qk1y+uo44rm7uJ1QgoHlZguOnBOK+i/2Uvjp/wAIbrKWOoxQ S28beek1wypswOmTjPsKTT3Gm0j1PwD8B/A/xyW88O3nh/VPhn44tIUFtq72j29vLKP4ZITgEkDg jDdzmrmoaNqnwg8LzzXGsXnivxHbQmzZLSELFCgJwFQckknJY4J9OufoLQf2vfAHxFisrS1uYjdW R+RfL2FGJ68jJ5HauA8WDw34l1Rp28SWlnI8h3nesZJPXrWFRvl01IjVtK0tF82VfBnja98NfsyX D6oS/ifVJluHM2AYwXZo0cc/3mXsQCBgYqp8J/CWjeM/EqXQ0yyn1Z5BMGt0+ZTtwW+vqRjsSM13 +lfDTwpdwLa3mvG5R8FZbd0J/M56/T8K9KsNV0TwFoq6fotpb20jdbuGFVmYZz94AYJ6Zx0HGDg1 n9WlUanNpIf1qnFOMbt37HTS+C4LWFLCe68lgoZ5EkIYcY3Egg5HIGOnUYNcfqln4d8HxyDTWtbG 7dspc63cPNGH/vLC0gUevXvUEvie71y5lmV7fdHHudpCfl7DPdjx3YfWuW8RaXDrLwajqGr3rXsU 3mRXFkYkMaHI2/KOVIPcE8da6nTh9iPzONVpN2k9DXsvE3xEntrqdNY0DWbcDzLe3tIJYA3AyOGI wecHPpXpfw/sde8U6LDe3Wlw6UAMyi8bzGyOu1FPT6tya8u0/V9P8KyWUCazd6hqU5bZbQ2tqJSM ZLyOifIo45Iye3PS1qnibWPF1u0WoX0ekaZbf6uFb0xM/o7MXBY4IwM49q6Ipw1buRKd9kelXnjL xPcWM39g6ebSwjLRm5uogl3uBxmNGUoB7sx+g78vf2HiO/nivpra/ubnH/MTLTI46cGJjsHXgLj6 Vh6J4oOjRkR+JNW1tQuDFb29zdiP03fMqA+7E/pW5YT6Z4wItL/w/Lqty5Kz3V5fbJnHUYwqouOP lU1so839f5D2KeneDLPVfEYfXZoBqNmD9l+zarK8qDGSFjDNKTjsR+Va9l4S06xnvJLa81rTriYE RXem2xhnGepKtw31cE+9c/ZW32OK6s7TRLSOwgkIf7ZNG7Kp6fvBGcd8gsfSrGl6qloFTT9Da3cH ywbYSgSc/eG7YMYHXb+NJpJa/qJSUtv0I7n4bjxMTHqV/wCKHQ5RbnyLiFmGOGBQbcjHfKn+7XPe L/BOq6fo5t/DVjeah4ot3LQ6hObixVM92Z5dkrY52qMZ9K7DW9TjvIx9vtL+2myM7bicCRfQBZAn erfh7wpY3s2y21CKJ1j3CGIPJkjn7ybnBP8AsuPoazcL9DTS254x4KsfE/gW8udautZl17V7tQt3 Z3CrZkIp5jaMKGBwTtkBYEnBxkGvLvFfw01zTp9bvPDUtpDpeu3e9rjX9NjvyrcFFEwXzEKHohyR gYz2+oZNLvCs9ndXE2p6fE++SVXM8kHJ5+6GXHPO1WHcYy1Zev8AhGc6lLHFdfZjdQjzIWGYrtD9 yYA5DnnDdeCD8wBzyuGl0Vdp+Z4x4U8a+MNOvv7W8R3mmnXp7JLax1CFXhtWtoyfljuYpPMVgWIO 9SBu+bAr0uDxBpd6+mST3WpoI0LQ2j3cF6oXb83lmeMKcdfkkI55DVxnjW//AOESaHSb/Q1PmL52 DbubQlTgtDIhMsTjPIOe4HFY3jLxlZeHPhxrNzpGjyJKtq7ywrP9rQvjv8qyqfd6cbx/r5g0pbIw PjP+0MuhXn9maY097YupJN1BtjBPQoCxKHkghWC+gAor4psrXV/EWpbdRvJERzvCSOdgzzyeworN za+Nq50fVova/wCBr/DzXLa3aW1Mv2KSRf8AWOA6uR0GNuR+dejSarZJosrK8sV15q/6LHENk8e7 nDk8HqR8tWPiV+0ppZmksvAvhvTba1f/AF11dadH5kp+gHT61yel6X4y8QXEd/L4c1ZUmw0YsdPK QMOxGRgfhWNegm+Y5qc5SXNNcvzQ3WribWXnRLcNY9RHMw3gY5y6lQcfTvVOfw/pfiNXgkieC4Vc oY42kwMe30Feln4H3V1YLeJrUtkXHzRvZzAo3cZ2f/W4rv8A9lX4X3Gu/HrwzpHi62tbzwrPO/2m 5jmV1kdYmaNGPDKHdUUggZ3YrmjzfY0/A29rT6SPkjxJ8P59LaJ4pFEDqeXjdeQfXb3/AMay7Xwb fyrbSLsKSvsAbIIPuCM/lmv1/wDCfww1G/8A2qPHun+MNP0tr200Z7nwTp84R9P+z+Y6wlYQML5Z AyhGcszYPBryL4LfsY6x8Z/H/iLxX8ZJp9LtPDV/Kl59muAJL+5VVaQmRchY0ULkr1yQNuDXfTnO 1pFcy6nxd4cmur3wzd+H7PyNMllKM13AWM52nJAII+Ugnqa7N9Jgs/DNjb31zNe+RG4MsufmxjG7 JJH4flXqnwy/ac+DmpfGK18Nah8EdE0jwNeXg06x1JPO/tK2jdtqzTStJkgkgsBggE8nHPs/7Rvw Vuv2bfid4C1nwzoVr4n8E63q8Wm3Npq9st2li0jrlXVlIZWUuVc8gryc4Jc4t7GjtezR8deGf2k4 fBMUOnWunJIkJC7pkxkYHBPXiuwsf2ztMbUAL/S5LaNWId7aTcrr2GCAfyNe8f8ABXXwBb2tt8Ht J8JeHIoZpptVCWWjWIDSELadEjXnv2r8zdY0bUdCvpbLUrO5069iOJLa7iaKRPYqwBH41tGnFmTj GfvWPuPTPj/deKlvotE1S2tdOERd2toxI8Kj7mIm6scHJcHsBWpP4/up/D5vPt6XMsMW1or668yV jtHzlUCqMZHAP5VH/wAEzPDHww+Nd/rfhXxj8PNKk1XQ7Jby38QQ3l1BNcq82xkmAm2lsyIF2hQQ MEE8nS/bF+C4/Zk8bW2oT6dLq/w41e6MljKFZltZeGNpOVZSQcfKwKsyZGSyk00lF2MnFXskcd8N ZX1/Trm71C+s9Jmu3iZYzaNHdQIOi5Ey/Lzu3FcEtnmvR9UufE9lHFdR6/HBEVWIX0d1bO4YZARh cEY7YIY+nFZ/jLUvh3a/sz+CvGPh/wAC+HtE8WeJ7i+sZNUtLu7jNsYjsLxEzlt+GQ7ZGYDBGDxX melHxnceDNTF54em8c2hXi6k08SRIoxwzIpGRzzwaHZvUJSb1X9f15nqT/FYwyx27ayL+6b5XhEs DMzY6okQkYkd8Gt25+Idx4ce3tBeXds1wAfMEp+0SHGfljG5yPyxjoK+a9H1XUII0t7bRf8AhGbR QH83TYUPlS9Nylo2P3evTpWvFFfeBNLfWmm8a3cDSEQzSWvkrOW/6alBnnnOfwrQxaue3v8AFPUI LSZ7qxnSGRl+yrqWRKWH/LR1dhkkngYYj61v6X401LVdN3zao1rMG3FbO0GMf7UjoP0GK+YfBPif UdbutRvV0LWr3c/lT21npcuoBB/z0luPvbvxwB6V1OleJNEnvNMg/sPT/sBvEW8GoX3lIEDjfmNG Ys2MjB71EW3uwa5dj6L0v4uSaNCINK1rU9XvZnVfsmlhChUH5vMlMZAx6Kc13tv46uZ5YtQGg6ja TRYJkEKvjHcFWBB9wa9Q+JHw0+Gfg/xT8NLJPDWmW0Wo6obKOBCEjdDE2Bs3AMd5i5AJ/OtHWjpf w4+NHh7RvDXh+yT+0bb/AE2KOFiVjMmN45wm0KxJx0rWNToyZe7qjgLfxLPr2qw38U39qMmPKFzF 5F9bN3CzIDuXjowPXrWpcWl3r9/FNJaRQpGvlzFl+UkDI5UgKfwweuKt/Db4habL8aPHej6ZpdmP AkStc3GuM5KrIEQMFfO1Y9+8Aceq8V4/p3xI0yXV5dNspLi8/eM8b3F0T5CEkq0mwYBI5wSTVxcJ aCcnFanonjL4aP4ktYEV11NA2Uge53zQSjGGSUrjp8uGGCpwSeMeQ+OvhxcxkRXVjeaYUby3lmhc oFPRcqThfXGV9DWhf/GKzvtXuNN0/UV1Y25C3M28rDF7AKPnb8MCud1H9pbQfDcsgRhe3k0pUx2s awgbMZDMeuD1bGBRKNC7uSpyfqfKXxu+CUXhPFxpbSDT42aS6lhJYgE9dh5wP0or3HXv2gNHvNev Le/tbKS8MBu5YrRDPGy9FVnJ57dKK8/lhDSNRpHb9bqNLmpcz7nF+H/2bfDdt4VuI9c1Dy9QmiCz XcssJWJs8lFUfrnNdV4O+EN74dw+l/EbWpo9m1VlmSWHaBwNrDpXx/p1rceKrkG81O6Ety2C0u4q 59yOK9D0e1tfDkZtLXVLgGaPZIouWUbsenvXNOvCno1r8zj+o1p6Op+B9a2yaTpmjzLrF/Y3TJyz oRCR9Ap6151fa18Pdd86bTdaNndA8ykMSCOnzZ3dvWvBJbeKD9zJLJJE/RnO/aeoxk81p+HbaeO7 a3is/OM4yFWIktj0H41zTxXtFZR2/r1NqWW+z96VR3+SX6o727+MGoaTqSXUWs3mo6jbtiO8fUGd yBwAGcFlGM9DX6Lfs8a1B8S/2OxcWFusN3qGn6nDPAh3uLlpJlbcRyWYkN6ncK/M3/hAtRuIRcx6 IxTPzSeUVKjqcjFe5fsyftPTfs9aleaXeQpceGL5xNNYltjxTYwZIieMkAAg8HaORRRrcvx3szql Rp/FTd36nxxr/hmwuNQea1DFCBsMcTRsD7E8/qa/YH9ta/WH4K+FobptmpXXijQ44cnDeYLqN3/8 cWQfjXz59s+AV/40j8R2l/qr6ebk358OGwiOJC24oJDJtVN38POBwDUnxZ+OmgfFjx54e1nxr9o0 rwp4fuRe2lralZXEqsrBmDMgZjtAz/COgOTnWGI5FaT9CZXbWh6N/wAFA/jr40+CXjD4LP4PuYbV dV1S5h1BpLOOZpIQ9qPK3spKK29s7SCcLzwK8T/4LOeGNMhtfhnr6WsUerTSXtnLdKoDyxKsTIrH uFJbHpvb1o/ak/av+Evx+1zwDNBceKrBPDepvNOY9NgYTQvsLbMzj5g0KAZ4wxPYA87+29+1H8NP 2oPBejQaNa+JLbWNEuHmt4tQ06AW84k2LIGcTMyEKuQQpyRjjOR3xqK9y405Jxuj5z/ZJuprL4df tC3NvNJb3EPgkyRzRMVZGF5AQwI5BBGc1+gP7I/7QPhj9vH4Fav8MPiUkN54qtbMQ6jE+Fe+hBAj vYvSRWC7iPuuAejAV8e/s7+O/gv8Ofhz490fxbL4nbWfGOlPo90mj6fbtFZwliQyO0yl2J2HlQBj HPWvIfBmrWPwc+LVj4p+HutatH/ZdwJLG+voVhllQjDJLCjMNrAspXccg9u2jmrag6bbaPuf/hjc eHtY/Z8+D/ip4tS0W18QeI76SeElReWiRwzxBgDlS+FVh2+bHYns/jj8Y9b+Fv7e/wAFvA2iXD6V 4QuLK3s20a0PlWji4lmhJMS4Uldse3jjbx3rzj49ftjWfxL1/wCEPjTwL5tn4p8JXFzdXVlfDbby edFHHJFvUkspUSLnAOCD1rU+Jn7Q3wd+I/xN+HvxZ12013TfEHg4ZuNLgsEuftJDb4kjm81FGyQk 7mHIY8L1rNVYS6mVpdT6q1f9mjwxqPx/svGMllbmyNhJLPpnlr5Mt4siBJmXGPus2R3ZQTzmvPLH 4w+FfC2qfEnS/iP43Xxho2p6hJDBozaVKq6eis6PBlzggDyxxgApkcmvmC5/4KVeMdO/aB/4TO+8 PeT8Phaf2d/wj4mU3AhJ3+eHxgzbucfd2/L/ALVJ8ef2yv2aPFlxJ4y0XwRrfiLx1Km6OyvzJZ6f 52MCS6RJdsmOpCg7sYJHWrs+hm6cuh9d2/w+tfi18DvCcfwY8ey+C5tHKzRyWIwss4ADrdxqQSxY EncCDuJwwIr4c+Ovh/WtG+PPifUPG+h2mn6lcyxzz21mTLayMY1BmjY7TtcqX55BYg9DV/R/2vvh BefEnwn8U08QeMfBHiGxih/4SDw1punJNbatJHGEIjcTKqI+PmDDnrgHJPgX7S37T837Qnxpu/GD GfStBUQw2+kmQ5eCPojFe75Yk9t2B0qlBidNyVj7s+MXxo8M+K9Q+C18L63vL3RrCDUmENyD5E5a PejgE4YGAcHkfjXOftgeMtO8YfFLW5NK8TTRWMVvb2Utzpd2XinhCrIyMFO113scgkg4rlfi/wDt +/AnxR4l+FNzo/w8l1Cx0S9WfUEubCK3NpBtAEMShtshVsNg4T5Bg/MceI/t2ftMeGvjr8RdP1D4 b2t1pul2titvdzvbrBJey7iQ2xSThVIXJ5/ACtFddDD2M2/ddiHUvE154Mub+3vtb1G90bV5tyRz 3rwoWwACqKdoIHGcZx3rij4m8Rabr+pz6PNKbNUVrfTrCb91KO+85yegzjrXjl5LI+J5Jp5oVGFj uJPnHHOPamQ3Fpa3Fs0E07uRkCOUxmM+mcc1m466G0YS6s9O0f4max4ct7yWCylkup0e4vNQVCGL EYC57BeABVfwt4sfV/FWhrq8c8sr73uYgDvuNoJjhCn5QhOCc9cEmqk/xVvYvDk2kzG++yyApKs8 SE8+hAH5mrnw08LDXNasdUOuW1vMFIhjllDyDj17GhxDmsnKSt/wxB4q1DV7Pxpd6pdZubqBCL3y WxbQqRhIAQB0yMjvRWj4+ZfCWovZm4tZ7eKZbmK3gJZZCcZYk53tkZzRXO4N9Lm0GpxUkj6B0D4D eFtAuCBPc3MJPyK85Gw/hW5N8EPCst7HdNpIlZTkb5CwP1Her6TO0pyc59qZrWr3lraoIp2QA+gr WUKcFzNHhc9ab+Nl618D6DDC9rHotmqnkqY+f8a1dH8MaXo9/Fc2tmltNGCFdeMA14Dr3jrXre4m kj1KVHAIBAX1+lcV47+IPiQXcIXWbqMNCCRG+3J/Cuf2kHtE6KeCqzWs/wAz7G1nx/pGiyNFdXUP nMu4IMZYe1c1r914C8Y2Bjv3tQR3yEavj7QNZv8AUL2EXV7cXIMg4mlZ/wCZr0Cz+f7WrfMo6A9q wrYiWqkk0d1LLY09eZp90dTe/C3QtR1iVNG1uG1tYl3jzOrN6AiuQuPDWrNNcy3KPqEEIwpdyQvv VYajc2zskUpRT2AFWLXxBqJKqbuTaQcjPFefJtq9j24xlFau/qcFLpk9qTnZuU5KsM80TaZd3CRy hQExklehFdtG/wBpmXzQr5JzlRzXSeIrKC00y2MMKR5jBO0YrpVd221FKSTUTxm48PXKEmNGw/dq js/DF0jmR5HODyFFdRrVxIJ+Gxj2rW8J6ncJdKA4IOOGRT/MV0e3mo6ilFRV0VNBjh02BZX+R16M 4OR+Fa0viC2WOUeZ5rScnjJH6Vp3sEdzFq0skamRItysBjB454rye7mkiLujsrZPINYwgqjuzNzu +U6/V9YtZXCgvKrrzvH3fzrnrfTvDWpX0X9q2svkA4Zrc7WYelYi3Ejt8zk565NWYHJkPPauqEfZ rRnLKN9D0Wy0z4Z6lfWLNoK20gby0heUiED+/K38Vc14k+G1h4h+I3k6PqNgkJ5kfyPLt4QB/CB9 4/XrVCBRIg3DPNRoTFcnYSh5GVOK39rPZM41TUHdN/mZ/wAWPh/Y6BqcMWl6odVlK5ndwq89toHQ VzuneFfEa2DNDa/ZraQZMzkLkfUnNdXfQoQCVBJ7nrVe6lkkXY0jMicKpYkD6CtfaM6IaRSvc8/u LVYJSszyTyg4ZQDj8zVuaVbmwjCTJC0TfLb7DvPvuxzXWLBG6ElATnqa19I0Owupcy2sb7duMj2p +2ja9hymo6Hn9jqjtqUYlaWeNziaK4kOxwOxIrsdL8TaRA4+y6KbZ4iQTFdkkg9cDFeg+DPA+hX1 7cmfTYZSjDbnPHP1r1ObwD4csoopoNFs4pcqN6xDPWuiMeaPMcNWvFdGeEL4e0zxTb2802lXVkVB JuZZjkr6gEUV6B8RruWHT9TijfZGoOFAGB9KKiVk9DOnOck7Ox//2Q== --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, ABCs 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). http://force7.de/nimrod/system.html#139 http://force7.de/nimrod/system.html#606 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). http://force7.de/nimrod/system.html#139 http://force7.de/nimrod/system.html#606 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? ;-) t() # the compiler needs to *expand* t here; parsing t's # header and put it into the symbol table is not enough template t() = ... And Nimrod supports symbol table inspection: when not defined(p): proc p = echo "a" else: proc p = echo "b" p() # what should that do? 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 seen that happen in practice in C# (which allows for arbitrary 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? ;-) t() # the compiler needs to *expand* t here; parsing t's # header and put it into the symbol table is not enough 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"
 p() # what should that do?

 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 happen in practice in C# (which allows for arbitrary order); but 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 
 seen that happen in practice in C# (which allows for arbitrary 
 order); but admittedly that's a very weak point.
I wrote tons of C# and I never did it bottom to top. They're 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