Commentando porzioni di codice in Scala

Question

Sto cercando un modo C (++) #if 0 -like di essere in grado di commentare interi pezzi del codice sorgente Scala, per mantenere un codice sperimentale o scaduto per un po '.

Ho provato un paio di alternative e mi piacerebbe sentire cosa usi e se hai trovato qualcosa di meglio?

// Simply block-marking N lines by '//' is one way... 
// <tags> """ anything 

Il mio editor lo rende facile, ma non è proprio The Thing. Si mescola facilmente con i commenti di una riga effettivi.

Poi ho pensato che ci sia il supporto XML nativo, quindi:

<!-- 
    ... did not work 
--> 

Wrapping in opere XML, a meno che non si dispone di <tags> all'interno del blocco:

class none { val a= <ignore> 
    ... 
    cannot have //<tags> <here> (not even in end-of-line comments!) 
</ignore> } 

Lo stesso per le stringhe multilinea sembra tipo del meglio, ma c'è un sacco di piatti (non di moda in Scala) per compiacere il compilatore (meno se lo fai all'interno di una classe o di un oggetto):

object none { val ignore= """ This seems like 
    ... 
    <truly> <anything goes> but three "'s of course 
""" } 

Il modo 'giusto' per fare questo potrebbe essere:

/*** 
    /* 
    ... works but not properly syntax highlighed in SubEthaEdit (or StackOverflow) 
    */ 
***/ 

..ma che corrisponde al /* e */ non solo, vale a dire /***-***/. Ciò significa che i commenti all'interno del blocco devono essere bilanciati. E - l'attuale modalità di evidenziazione della sintassi di Scala per SubEthaEdit fallisce miseramente su questo.

Come confronto, Lua ha --[==[ corrispondente a ]==] e così via. Penso di essere viziato?

Quindi - c'è qualche trucco utile che sto supervisionando?

Answer 1

Perché non utilizzare il meccanismo di controllo del codice sorgente? Tieni il codice separato, controllalo come file separati e dimenticalo. Non vorrei che il mio codice base quotidiano ingombrasse questo genere di cose.

Si noti tuttavia che se non si utilizza regolarmente questo codice (ad esempio nei test automatici, ecc.) Subirà il code rot. Non appena commentate o altrimenti accantonate questa roba, le dipendenze andranno avanti e scoprirete che beofre long non si collegherà alla base di codice esistente.

Answer 2

Ho modificato il modo Scala SyntaxDefinition.xml per supportare i commenti di stile /***...***/.

Questo non è lo stesso del supporto del parser Scala per i commenti nidificati /*...*/, ma non ho trovato un modo per esprimerlo per il mio editor.

Nel caso in cui qualcuno vuole fare lo stesso, ecco qui:

<!-- AK 30-Nov-2012 
- 
- The Scala parser handles nested '/*...*/' style comments, but the SEE 
- syntax highlighting seems not. 
- 
- We introduce '/***...***/' style comments (starting with three asterisks 
- since JavaDoc uses '/**..*/' style) and deeper levels, to be used for 
- blocking out code blocks, even if they contain '/*..*/' comments within. 
- 
- Note: Original comment handling misses a 'type="comment"' field. Is that vital? 
- 
- Test: If this works right, the following will be highlighted as a single comment: 
-  << 
-  /*** 
-  */ 
-  ***/ <- green, not black (note: Scala parses these differently; this is just to test the mode) 
-  << 
--> 
<state id="Multilevel Comment AK" color="#236E25" type="comment" font-style="italic"> 
    <begin><regex>/\*\*(?'commentCatch'\*+)</regex></begin> 
    <end><regex>(?#see-insert-start-group:commentCatch)\*\*/</regex></end> 
    <import mode="Base" state="EmailAndURLContainerState" keywords-only="yes"/> 
</state> 

Si consiglia inoltre di aggiungere type="comment" alle norme esistenti evidenziazione pochi commento. Non sono sicuro che sia di vitale importanza (altre modalità rispetto a quelle di Scala).

Informazioni su SubEthaEdit modes.

Answer 3

C'è un'altra opzione che hai tralasciato. Commentando di qualsiasi tipo ha lo svantaggio di disabilitare l'evidenziazione della sintassi così come non essere incluso in refactoring IDE (Emacs + Ensime, IDEA, Eclipse, ecc) o altri strumenti di codice di intelligence, pertanto preferisco l'approccio seguente invece:

def ignore(block: => Any) =() 
def ignoreIf(cond: Boolean)(block: => Any): Unit = if (!cond) block 

ignore { 
    // experimental and/or disabled code 
    syntaxHighlightingEnabled(true, 3, "foobar") 
} 

ignoreIf(SomeFeatureEnabled) { 
    // experimental and conditionally enabled code 
    syntaxHighlightingEnabled(true, 3, "foobar") 
} 

Answer 4

Io uso "gradi di cancellazione". (1) Commenta. (2) Se è un codice che non mi serve più ma potrebbe trovare utile più tardi/altrove, ho una cartella '.boneyard' dove lancio frammenti di codice (appena fuori dall'albero di produzione) - sorprendentemente comoda. (3) Basta eliminarlo e fare affidamento sul controllo del codice sorgente se risulta che ne ho davvero bisogno.