4 ms·

Delegates could be done in java albeit not trivially. They're essentially just syntactic sugar for a one-method class. I would be a bit more worried about han

• DrJokepu 17y ago
  Delegates ... are essentially just syntactic sugar for a one-method class No that's not entirely true. There are a lot of similarities but there are essential differences as well. Delegates in .NET are truly functions as first class objects while single-method anonymous classes is Java are first class object wrappers around functions. This means that while in Java an anonymous class is a tuple with a reference to the instance of the anonymous class and a reference to the instance of the container class, in .NET it is a tuple with a reference (pointer actually) to a method and a reference to the instance of the owner class (if not static). This is a subtle but important difference and is entrenched all the way down in the .NET type system, not just on syntax level.
• bad_user 17y ago
  > * Delegates could be done in java albeit not trivially. They're essentially just syntactic sugar for a one-method class.* No, there are many differences, both at the language and at the VM level, although you could emulate the behavior of delegates. You should look at the new MethodHandler from the JDK7 InvokeDynamic proposal ... they've added it for a reason ;) > The CLI has true generics The jury is still out on what constitutes "true generics" ... IMHO the C++ templates are more true than their C# equivalent ;) But yeah, the Java generics system is a far cry from what it should've been. And it also sucks because there are exceptions ... arrays are reified, and the new MethodHandler from JDK7 is also reified. That said ... you can add reified generics on top of the JVM. It is just a lot of hard work because you can't reuse the current generic types. There are other features that are difficult to implement ... stack allocated values, the primitives that aren't mapping to the JVM types (decimal, ulong), pointers / unsafe code, PInvoke, tail-calls (although I know of a way to have tail-calls, but it's heavy). You can implement anything on top of the JVM, but you will lose efficiency (not to mention of interoperability with Java code).
  • DrJokepu 17y ago
    ...tail-calls... Note that neither the Microsoft C# compiler nor the Mono one emit tail calls. In practice, the MS .NET Just-In-Time compiler however transforms tail recursion to loops even if the compiler didn't ask for it if a number of conditions are met. I'm no JVM expert by any means but I don't see why the JVM couldn't do something similar, in theory or in practice.
    • prog 17y ago
      Scala compiler does self-tail calls so in theory Java compiler should be able to do it. But IIUC doing tail calls between functions is not possible (or at least not worth the effort) on the JVM.
    • bad_user 17y ago
      > Note that neither the Microsoft C# compiler nor the Mono one emit tail calls The F# compiler does, and not just for self-recursive calls. > the MS .NET Just-In-Time compiler however transforms tail recursion to loops The hard problem is to have mutually recursive functions ... A() calls B() calls C() calls A(). I'm currently working on a compiler that behind the scenes implements trampolines, so if you had something like ... int methodA() { // does something here return methodB("calling B"); } This would be translated to something like (pseudocode) ... int methodA(TailCallException ex) { // do something here ex.method = methodB; ex.args = [ 'calling B' ]; throw ex; } // trampoline implemented for any method with tail-calls int methodA() { int result; has_next = true; method = reference to methodA; args = [] // reusing the same TailCallException instance exc = new TailCallException(); while (has_next) { try { result = method.invoke(args, exc); has_next = false; } catch (TailCallException ex) { method = ex.method; args = ex.args; } } return result; } So yeah, it's possible. But this is overkill for functional languages where you've got recursion all over the place.
    • j_baker 17y ago
      The only thing that you really need for tail call recursion is a goto statement. Mutually recursive functions may be a different story though.