And Boo Makes Three
I just came upon Boo, a CLI
(.NET) language. It's statically typed, but the syntax is based on
Python. With
Pyrex
and Prothon, that makes three
recent languages inspired by Python.
The
manifesto
(PDF, ick) seems like the best description of the language.
-
Timespan and regular expression literals. (Timespan seems like a
weird choice)
-
String interpolation, like "Hello \$name!". Only in
double-quote strings, not single-quote. I find that very
annoying, the equivalence of these quotes in Python is a good
feature. I've cursed PHP for this. Maybe in shell this makes
sense, but not in a normal language.
- Statically typed. But...
-
Type inference, so you don't have to declare types too often,
unless you want to. Of course, you need all your code bundled up
before hand to do inference, where Python only looks at code on
an on-demand basis. But in practice all the code is usually
available.
-
Variables are somewhat casually declared. Whenever you first use
a variable, use as type to indicate the type (if
necessary). Like def func(a as int, b as str).
-
Duck typing, i.e., Python's typing (if it looks like a duck and
quacks like a duck, it must be a duck). When you really don't
care about type signatures.
-
Syntactic attributes. I don't fully understand the mechanism
here, but it's a lot like Python's decorators, and uses the
proposed syntax for decorators. I think it might be a little
more general than descriptors, perhaps in part because it may
work at compile time.
-
Macros. They seem very complicated to implement, but basically
you can manipulate the compilation, inserting your own
transformation into the process. I don't know if this causes
problems with debuggability -- debuggability is frequently a
feature left out of languages in the early days, when it should
be a major concern. If used sparingly, this could be a nice
feature. (I bet you could make lazy introspectable expressions
this way!)
-
Some minor things. print is a function. Assignment is
an expression (like if (var = func()) is not None:). It
doesn't use self in method signatures or method
bodies. Instance variables become local variables. I don't mind
the signature bit, but I like using self.attr for
instance variables. finally: is called ensure:
Prothon also had another release just a week ago. The
changes
all seem pretty good -- lots of little syntactic nits in Python are
corrected. E.g., default values for function parameters are
evaluated when the function is called.
Created 16 Jul '04
Modified 14 Dec '04
The URLs (which seem to be missing):
Boo:
http://boo.codehaus.org/
Manifesto:
http://boo.codehaus.org/BooManifesto.pdf
Having skimmed the manifesto briefly, there doesn't seem to be much
about classes and inheritance, and the type inference section on the
site is tantalisingly missing. However, the existence of decorators
and macros should fuel the debate about their introduction into
standard Python, and I could imagine the Twisted people finding the
asynchronous stuff of interest.
Great stuff. Especially the type declarations and type inference...
it can prove to be educational for cpython as well.
There are some perlistic warts (regex and timespan literals,
dostuff() while foo()), but I assume they will be removed as the
project matures.
This project might benefit from some co-operation with IronPython...
In skimming through the example code, I felt that this was more a
"terse C#", rather than Pythonesque or similar..maybe it was just
the lack of duck typing and peppered attributes. More palitable to
see as an easier C#, and I'm used to the Pythonic view of C# as
wordy.
The Python acknowledgement and documentation humor are appreciated.
Thanks for the thorough technical review.
OSNews reports that IronPython a .Net dynamic language has been open
sourced here. What it doesn't mention is that its creator has joined
the MS CLR team as reported a little bit further down here:
http://www.ironpython.com/