Generazione del codice F #

Question

T4 è il motore di generazione del codice "ufficiale" per C#/VB.NET. Ma F# doesn't support it (questo è da aprile, ma non ho trovato nessuna menzione più recente). Allora, qual è un buon modo per generare il codice F #?

EDIT:

Voglio realizzare 2-3 finger trees in F #. Li ho già implementati in C#, quindi questo dovrebbe essere un bel confronto. Le "cifre" e nodi dell'albero possono essere rappresentati come array, così

type 't FingerTree = Empty | Single of 't | Deep of 't array * (('t FingerTree) array) lazy * 't array 

Tuttavia, la dimensione massima di queste matrici è molto piccola, quindi sarebbe bello avere

type 't Digit = Digit1 of 't | Digit2 of 't*'t | Digit3 of 't*'t*'t | Digit4 of 't*'t*'t*'t 
type 't Node = Node2 of 't FingerTree * 't FingerTree | Node3 of 't FingerTree * 't FingerTree * 't FingerTree 
type 't FingerTree = Empty | Single of 't | Deep of 't Digit * ('t Node) lazy * 't Digit 

per evitare il controllo dei limiti, ecc.

Tuttavia, scrivere tutte le funzioni su Digit e Node manualmente diventa più difficile ed è meglio generarle. E un approccio T4 sembra perfetto per questo ...

Answer 1

Poiché F # non supporta gli strumenti personalizzati in soluzione explorer, è possibile posizionare i file T4 in un progetto C# o Visual Basic e reindirizzare l'output sul progetto F #. Ecco come si può fare con T4 Toolbox:

<#@ template language="C#" hostspecific="True" debug="True" #> 
<#@ output extension="txt" #> 
<#@ include file="T4Toolbox.tt" #> 
<# 
    FSharpTemplate template = new FSharpTemplate(); 
    template.Output.Project = @"..\Library1\Library1.fsproj"; 
    template.Output.File = "Module2.fs"; 
    template.Render(); 
#> 
<#+ 
class FSharpTemplate: Template 
{ 
    public override string TransformText() 
    { 
#> 
// Learn more about F# at http://fsharp.net 

module Module2 
<#+ 
     return this.GenerationEnvironment.ToString(); 
    } 
} 

#> 

Answer 2

Dipende da ciò che stai cercando di fare. Sebbene si tratti di un approccio che non è proprio adatto per la generazione di modelli nel modo in cui molti esempi T4 mostrano, in generale consiglierei di progettare una "libreria combinatori" [1] per la generazione di codice o attività di programmazione orientate alla lingua in F #. L'idea è di progettare alcuni combinatori per rappresentare il codice che si tenta di generare, generando il testo sorgente F # dai combinatori, quindi compilando questo tramite il codice DOM.

Tuttavia, spesso sarebbe più semplice scrivere un interprete per i combinatori anziché generare codice.

Buoni esempi di combinatori in F # sono:

• http://www.quanttec.com/fparsec/
• http://www.codeplex.com/fscheck/

[1] http://en.wikipedia.org/wiki/Combinator_library

Answer 3

Io per lo più d'accordo con Robert (anche se ci sono certamente alcune situazioni in cui usare T4 da F # potrebbe essere molto utile). Ad ogni modo, forse sarebbe interessante sapere perché vuoi generare il codice F #? Quindi potremmo forse suggerire qualche tipica soluzione funzionale al problema :-).

Answer 4

Ho dato un'occhiata alle varie opzioni e ho risolto le mie esigenze relativamente semplici e statiche di generazione del codice utilizzando uno script * .fsx che utilizza un TextWriter con fprintf per scrivere il codice F # generato.

In realtà uso FParsec per alcuni lavori di analisi, ma poiché non sto traducendo da qualche altra sintassi in F #, i due pezzi hanno poco a che fare l'uno con l'altro.