¿Hay algún idioma que use plantillas de código?

Question

¿Hay algún lenguaje que tenga una forma de creación de plantillas de código? Permítanme explicar a qué me refiero ... Hoy estaba trabajando en un proyecto de C# en el que una de mis clases era muy repetitiva, una serie de getters y setters de propiedades.

public static int CustomerID 
    { 
     get 
     { 
      return SessionHelper.Get<int>("CustomerID", 0); // 0 is the default value 
     } 
     set 
     { 
      SessionHelper.Set("CustomerID", value); 
     } 
    } 

    public static int BasketID 
    { 
     get 
     { 
      return SessionHelper.Get<int>("BasketID", 0); // 0 is the default value 
     } 
     set 
     { 
      SessionHelper.Set("BasketID", value); 
     } 
    } 

... and so forth ... 

Me doy cuenta de que esto podría dividirse básicamente en un tipo, un nombre y un valor predeterminado.

Vi este artículo, que es similar a lo que imagino, pero no tiene espacio para los parámetros (por defecto).

Generic Property in C#

Pero estaba pensando, hay muchas veces que el código se rompe en las plantillas.

Por ejemplo, la sintaxis podría ir como tal:

public template SessionAccessor(obj defaultValue) : static this.type this.name 
{ 
    get 
    { 
      return SessionHelper.Get<this.type>(this.name.ToString(), defaultValue); 
    } 
    set 
    { 
      SessionHelper.Set(this.name.ToString(), value); 
    } 
} 

public int CustomerID(0), BasketID(0) with template SessionAccessor; 
public ShoppingCart Cart(new ShoppingCart()) with template SessionAccessor; // Class example 

Siento que esto tendría muchas posibilidades en la escritura de código sucinta, SECO. Este tipo de cosas se podrían lograr de alguna manera en C# con reflexión, sin embargo, eso es lento y esto debería hacerse durante la compilación.

Entonces, pregunta: ¿Este tipo de funcionalidad es posible en cualquier lenguaje de programación existente?

Answer 1

Como comentó Marc Gravell, es un trabajo fácil para T4 (Text Template Transformation Toolkit), que es un procesador de plantillas integrado en Visual Studio, que se puede usar con C# o VB y puede generar cualquier cosa. Sin embargo, es una herramienta, no una función de lenguaje incorporado.

añadir un archivo de plantillas de texto (.tt) a su proyecto, la plantilla será tan simple como:

<#@ template debug="false" hostspecific="false" language="C#" #> 
<#@ output extension=".generated.cs" #> 
<# 
var properties = new[] { 
    new Property { Type = typeof(int), Name = "CustomerID", DefaultValue = 0 }, 
    new Property { Type = typeof(int), Name = "BasketID", DefaultValue = 0 }, 
}; 
#> 
namespace YourNameSpace { 
    public partial class YourClass { 
<# foreach (Property property in properties) { #> 
     public static <#= property.Type.FullName #> <#= property.Name #> { 
      get { return SessionHelper.Get<<#= property.Type.FullName #>>("<#= property.Name #>", <#= property.DefaultValue #>); } 
      set { SessionHelper.Set("<#= property.Name #>", value); } 
     } 
<# } #> 
    } 
} 
<#+ 
public class Property { 
    public Type Type { get; set; } 
    public string Name { get; set; } 
    public object DefaultValue { get; set; } 
} 
#> 

T4 son ideales para este tipo de generación de código. Recomiendo encarecidamente T4 Toolbox para generar fácilmente múltiples archivos por plantilla, acceda a EnvDTE para analizar su código C# existente directamente dentro de Visual Studio y otras bondades.

Answer 2

... y has descubierto el maravilloso mundo de metaprogramming. ¡Bienvenido! :-)

El lenguaje de metaprogramación arquetípica es Lisp, o realmente cualquier otro lenguaje que pueda representar su propia estructura en el código.

Otros idiomas han intentado copiar esto hasta cierto punto; macros in C son un ejemplo prominente.

Los candidatos prominentes más recientes de los idiomas que admiten esto hasta cierto punto son C++ via its templates y Ruby.