C'è un modo per dichiarare classi e metodi come astratti in Haxe?

Question

C'è un modo in Haxe di ottenere l'equivalente dei metodi astratti di Java e delle classi astratte?

Quello che voglio è

// An abstract class. (Written in a Java/Haxe hybrid.) 
abstract class Process<A> { 
    public function then<B>(f : A -> Process<B>) : Process<B> { 
     var a : A = go() ; 
     return f(a) ; 
    } 

    abstract public function go() : A ; 
} 

// A concrete class. 
class UnitP<A> extends Process<A> { 
    var _a : A ; 

    public function new(a : A) { 
     _a = a ; } 

    public override function go() : A { return _a ; } 
} 

Il più vicino che sono stato in grado di ottenere è quello di definire Process come interfaccia e per la sua attuazione con una classe concettualmente astratta ProcessA, che definisce entrambi i metodi; l'implementazione di go in ProcessA si blocca semplicemente. Quindi posso estendere le mie lezioni concettualmente concrete a ProcessA.

Answer 1

Come accennato da MSGhero, gli abstract di stile java non sono supportati nativamente da Haxe. E 'stato richiesto da diverse persone, però, così Andy Li ha scritto una macro per fornire agli utenti Haxe con una funzionalità simile:

https://gist.github.com/andyli/5011520

Answer 2

Come avrei fatto qualcosa di equivalente a Haxe

• Impostare il costruttore privato per garantire che nessuna istanza della classe Abstract venga creata.
• Creare un'interfaccia con tutti i metodi che devono essere implementati

• Creare una classe che eredita dall'estratto e implementa l'interfaccia.

  // An interface 
  interface IProcess<A, B> { 
      public function then(f : A -> AProcess<B>) : AProcess<B>; 
  
      public function go() : A; 
  } 
  
  // An abstract class. 
  class AProcess<A, B> { 
      private function new() {} 
  
      public function then<B>(f : A -> AProcess<B>) : AProcess<B> { 
       var a : A = go() ; 
       return f(a) ; 
      } 
  
      private function go() : A {}; 
  } 
  
  // A concrete class. 
  class UnitP extends AProcess<A, B> implements IProcess { 
      var _a : A ; 
  
      public function new(a : A) { 
       super(); 
       _a = a ; 
      } 
  
      public function go() : A { return _a ; } 
  }