Introducción
Como desarrollador, estoy involucrado en escribir mucho código matemático todos los días y me gustaría añadir muy pocas azúcares sintácticas al lenguaje C# para facilitar la escritura y revisión de códigos.Extender el lenguaje C#, ¿cuánto esfuerzo/ganancia?
Ya he leído sobre este thread y este otro one para encontrar posibles soluciones y simplemente me gustaría saber qué dirección tomar y cuánto esfuerzo puede representar resolver solo para los tres problemas sintácticos siguientes *.
*: Puedo sobrevivir sin azúcares sintácticas descritos, pero si no es demasiado trabajo y Rube-Goldberg diseño de proceso de compilación sencilla, puede ser interesante para investigar más a fondo.
1. argumentos múltiple salida
me gustaría escribir:
[double x, int i] = foo(z);
En lugar de:
double x;
int i;
foo(out x, out i, z);
NB: out parámetros que se colocan primero y foo ser declaradas como de costumbre (o usando el mismo tipo de sintaxis).
2. Los operadores adicionales
me gustaría tener unos nuevos operadores unarios/binarios. No sé mucho cómo definir para estos (y parece bastante complejo para no introducir ambigüedad al analizar las fuentes), de todos modos le gustaría tener algo como:
namespace Foo
{
using binary operator "\" as "MyMath.LeftDivide";
using unary operator "'" as "MyMath.ConjugateTranspose";
public class Test
{
public void Example()
{
var y = x';
var z = x \ y;
}
}
}
En lugar de:
namespace Foo
{
public class Test
{
public void Example()
{
var y = MyMath.ConjugateTranspose(x);
var z = MyMath.LeftDivide(x, y);
}
}
}
3. inserción automática de nombres para las clases estáticas
es muy poco atractivo para repetir sin cesar Matemáticas .BlaBlaBla() en todas partes de un código de computación en lugar de escribir directamente y simplemente Bl aBlaBla.
Seguro que esto puede ser resuelto agregando métodos locales para envolver Matemáticas .BlaBlaBla dentro de la clase de cálculo. De todos modos sería mejor cuando no hay ambigüedad en absoluto, o cuando la ambigüedad se resolvería con algún tipo de palabra clave implicit, para insertar automáticamente nombres de clase cuando sea necesario.
Por ejemplo:
using System;
using implicit MySystem; // Definying for 'MyMaths.Math.Bessel'
public class Example
{
public Foo()
{
var y = 3.0 * Cos(12.0);
var z = 3.0 * Bessel(42);
}
// Local definition of 'Bessel' function again
public static double Bessel(double x)
{
...
}
}
se convertiría en:
using System;
using MySystem; // Definying for 'Math.Bessel'
public class Example
{
public Foo()
{
var y = 3.0 * System.Math.Cos(12.0); // No ambiguity at all
var z = 3.0 * MySystem.Math.Bessel(42); // Solved from `implicit` keyword
}
// Local definition of 'Bessel' function again
public static double Bessel(double x)
{
...
}
}
* El compilador puede generar simplemente una advertencia para indicar que se resuelve la ambigüedad, porque una solución implicit se ha definido.
NB: 3) es lo suficientemente satisfactorio para resolver 2).
Miguel de Icaza quería tupla en C# también http://tirania.org/blog/archive/2009/Dec-23.html –
Effot == lotes y lotes. Ganancia == casi cero. A menos que quieras ser el único programador en cualquier proyecto de programación que persigas, esta es una idea terrible. (aniquilará el soporte de herramientas (es decir, Resharper), hará que cualquier programador de C# calificado no califique repentinamente para usar su idioma favorito, nadie podrá entrar y leer su código, no habrá refactorizaciones, la lista es interminable) –
"Inserción automática de nombres para clases estáticas": uso de funciones estáticas sin el calificador de clase, compatible con Java; Sin embargo, no estoy diciendo que sea exactamente algo bueno/malo: http://www.deitel.com/articles/java_tutorials/20060211/index.html –