Generando código F #

Question

T4 es el motor de generación de código "oficial" para C#/VB.NET. Pero F# doesn't support it (esto es de abril, pero no pude encontrar menciones más nuevas). Entonces, ¿cuál es una buena forma de generar código F #?

EDIT:

Quiero poner en práctica 2-3 finger trees en F #. Ya los he implementado en C#, por lo que esta debería ser una buena comparación. Los "dígitos" y nodos del árbol pueden ser representados como matrices, por lo

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

Sin embargo, el tamaño máximo de estas matrices es muy pequeña, así que sería bueno tener

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 

para evitar la comprobación de límites, etc.

Pero luego escribir todas las funciones en Dígitos y Nodos a mano se vuelve más difícil, y es mejor generarlos. Y un enfoque similar al T4 parece perfecto para él ...

Answer 1

Como F # no admite herramientas personalizadas en el explorador de soluciones, puede colocar sus archivos T4 en un proyecto C# o Visual Basic y redirigir su salida a su proyecto F #. He aquí cómo usted puede hacerlo 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

Depende de lo que trates de hacer. Si bien es un enfoque que no es realmente adecuado para generar plantillas en la forma en que lo muestran muchos ejemplos de T4, en general recomendaría diseñar una "biblioteca de combinadores" [1] para generación de código o tareas de programación orientadas al lenguaje en F #. La idea es diseñar algunos combinadores para representar el código que intenta generar, generando el texto fuente F # de los combinadores, luego compilando esto a través del código DOM.

Sin embargo, a menudo sería más fácil simplemente escribir un intérprete para sus combinadores en lugar de generar código.

Buenos ejemplos de combinadores en F # son:

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

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

Answer 3

estoy básicamente de acuerdo con Robert (aunque sin duda hay algunas situaciones en las usar T4 desde F # podría ser muy útil). De todos modos, tal vez sería interesante saber ¿por qué desea generar código F #? Entonces podríamos sugerir alguna solución funcional típica para el problema :-).

Answer 4

Miré a mi alrededor en varias opciones, y terminé con mis necesidades de generación de código relativamente simples y estáticas usando un script * .fsx que usa un TextWriter con fprintf para escribir el código F # generado.

De hecho, uso FParsec para algunos trabajos de análisis, pero como no estoy traduciendo desde otra sintaxis a F #, las dos piezas tienen poco que ver entre sí.