As a follow-up to yesterdays article, I would like to point out the following article written by Ola Bini on the JRuby
team: JRuby Regular Expressions
This article represents everything that differs in the mentality between the Groovy
& the JRuby teams. In essence, the JRuby team are planning on
ditching java.util.regex and implementing their own regex parser to
match the Ruby regex semantics.
Regardless as to whether this is
a good thing or not, and regardless as to whether you can change the
default implementation this is the essence of the debate over Java
integration. So whenever you drop out of Java and into Ruby-land you
need to remember that the semantics differ between regex
implementations. To be clear: Java integration means more than just
being able to call a method on a Java class.
To quote Dierk Koenig, author of Groovy in Action, who posted this comment yesterday:
would like to add that there is a fundamental difference between the
two types of languages for the Java platform: type A, which are
languages designed specifically for that platform (Groovy, Scala,
etc.), and type B, which are ports of a foreign language (Jython,
JRuby, Kawa, Bistro, and the likes).
While type B languages can
achieve a decent level of interoperability, only type A languages can
truly integrate with Java. This is because foreign languages not only
have their own libraries, APIs, and such but more important, they come
with their own object model, threading architecture, security concept,
performance and debugging hooks, and last not least their own runtime
architecture that can be fundamentally different from Java. Any type B
language has to overcome this impedance mismatch breaking either Java's
or the foreign language's behavior.
The acid test for
integration is to replace any given Java class (be it abstract, or in
the middle of an inheritance chain, or having overloaded methods, or
using annotations) and replace it with an implementation in your
language. This is what only type A languages can possibly achieve."
other words, this is another example of how the JRuby developers have
to make a hard choice in order to support C Ruby compatibility.
Unfortunately on this occasion, it is Java integration that suffers.
Groovy the expression ~/pattern/ results in an instance of
java.util.regex.Pattern therefore the semantics are the same, you can
call all the regular JDK methods on the object and the object can be
passed to a Java object to hook into other frameworks and tools.
posted on 2007-04-04 20:58 山风小子
阅读(741) 评论(0) 编辑 收藏
所属分类: Groovy & Grails