Estensione del linguaggio C#, quanto sforzo/guadagno?

Question

Introduzione

Come sviluppatore, io sono coinvolto a scrivere un sacco di codice matematico di tutti i giorni e mi piacerebbe aggiungere pochissimi zucchero sintattico per il linguaggio C# per facilitare la scrittura del codice e la revisione.

Ho già letto su questoe questo altro one per possibili soluzioni e vorrei semplicemente sapere quale direzione migliore andare e quanto sforzo può rappresentare per risolvere solo per i tre problemi sintattici seguenti *.

*: posso sopravvivere senza zuccheri sintattiche descritte, ma se non è troppo lavoro e Rube Goldberg- progetto per semplice processo di compilazione, può essere interessante per indagare ulteriormente.

1. Argomenti multipli uscita

mi piacerebbe scrivere:

[double x, int i] = foo(z); 

Invece di:

double x; 
int i; 
foo(out x, out i, z); 

NB: out parametri di essere immessi prima e foo essere dichiarato come al solito (o usando lo stesso tipo di sintassi).

2. Gli operatori sono inoltre

Mi piacerebbe avere un paio di nuovi operatori unari/binari. Non so molto come definire per queste (e sembra piuttosto complessa per non introdurre l'ambiguità quando analizza le fonti), in ogni caso vorrebbe avere qualcosa di simile:

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; 
     } 
    } 
} 

Invece di:

namespace Foo 
{ 
    public class Test 
    { 
     public void Example() 
     { 
      var y = MyMath.ConjugateTranspose(x); 
      var z = MyMath.LeftDivide(x, y); 
     } 
    } 
} 

3. inserimento nome automatico per classi statiche

è estremamente sgradevole a ripetere all'infinito Math .BlaBlaBla() ovunque in un codice di calcolo invece di scrivere direttamente e semplicemente Bl aBlaBla.

Sicuramente questo può essere risolto aggiungendo metodi locali per avvolgere Math .BlaBlaBla all'interno della classe di calcolo. In ogni caso, sarebbe meglio quando non c'è alcuna ambiguità o quando l'ambiguità sarebbe risolta con una qualche parola chiave implicit, per inserire automaticamente i nomi delle classi quando richiesto.

Ad esempio:

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) 
    { 
     ... 
    } 
} 

diventerebbe:

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) 
    { 
     ... 
    } 
} 

* Il compilatore può semplicemente generare un avviso per indicare che risolve l'ambiguità perché una soluzione implicit è stato definito.

NB: 3) è abbastanza soddisfacente per risolvere 2).

Answer 1

Sarei una delle prime persone a supportare un C# mainstream che può essere esteso dagli utenti. Tuttavia, per diversi motivi (design, tempi o costi), non riesco a vedere C# come estensibile come desideri (or I). Un linguaggio C# -derived che ho trovato che è MOLTO buono per la meta-programmazione e l'estensione della funzionalità/sintassi è Nemerle.

Boo è un altro linguaggio .NET con buone caratteristiche di meta-programmazione. Tuttavia, è talmente lontano da C# che non ho ritenuto una risposta appropriata a questa domanda (ma l'ho aggiunta per completezza, comunque).

Answer 2

Hai considerato di utilizzare F # anziché C#? Nella mia esperienza, ho trovato F # un grande adattamento per il codice orientato scientifico/matematico, molto più di C#.

Il tuo primo scenario è coperto da tuple; puoi scrivere una funzione come let f a b = (a+b, a-b), che restituisce direttamente una tupla di 2 valori, puoi facilmente aggiungere overload operators o aggiungere la tua, e i moduli possono aiutarti con il terzo. E F # interagisce in modo abbastanza fluido con C#, quindi puoi persino selezionare F # per le parti in cui è pratico e mantenere il resto del codice in C#. Ci sono altre sottigliezze che funzionano molto bene per il codice scientifico (units of measure per esempio) ...