Esistono lingue che consentono le unità?

Question

Quando si scrive il seguente oggi in C#

DateTime.Now.AddYears(-60) 

mi chiedevo se ci sono lingue che permettono una sintassi più naturale con le unità:

DateTime.Now - 60years 

Qualcuno sa di qualsiasi? Nello specifico, sono interessato alla presenza di operatori di unità (?) Che trasformano "60 anni" in ad es. "TimeSpan.FromYears (60)". Sarebbe anche bello poter definire i propri operatori di unità, in modo simile a come è possibile scrivere operatori di conversione in C#

(Sì, so che TimeSpan non soddisfa per anni - è un esempio.)

Answer 1

F # ha unità di misura. Alcuni esempi

http://blogs.msdn.com/andrewkennedy/archive/2008/08/20/units-of-measure-in-f-part-one-introducing-units.aspx

alt text http://blogs.msdn.com/blogfiles/andrewkennedy/WindowsLiveWriter/UnitsofMeasureinFPartOneIntroducingUnits_A131/image_12.png

alt text http://blogs.msdn.com/blogfiles/andrewkennedy/WindowsLiveWriter/UnitsofMeasureinFPartOneIntroducingUnits_A131/image_20.png

Answer 2

ho gues C++, è possibile effettuare la classe di quote con gli operatori di overload e alcune macro #define

Answer 3

In Perl, è possibile utilizzare DateTime che permette cose come:

my $dt = DateTime->now 
$dt->subtract(hours => 1); 

Answer 4

non ho visto un tale linguaggio che lo supporta intrinsecamente. Comunque potresti certamente scrivere i tuoi oggetti basati sulla data in una varietà di lingue, se sei così incline.

Answer 5

La libreria Java JODA funziona in questo modo.

E c'è il JSR-275 che propone un quadro di unità.

Ho sentito parlare di questo problema nel 1997 da Martin Fowler. Ha scritto su di esso nel suo "Analysis Patterns".

Answer 6

Bene biblioteca ActiveSupport per Ruby estende la classe Integer con metodi come ore e giorni, che permette di scrivere le cose come:

Time.now + 5.days 

Ma che non è proprio una caratteristica della sintassi - è solo una chiamata di metodo ed è possibile in qualsiasi lingua che consente di aggiungere metodi a una classe esistente. Potresti farlo in C# con i metodi di estensione, anche se dovrebbe essere 5.days() lì.

Answer 7

Non so se ne esiste ancora uno, ma mi aspetterei di iniziare a vedere queste cose spuntare come DSL s nel prossimo paio di anni. Sto pensando un po 'come una nuova generazione MATLAB o qualcosa del genere. Sono sicuro che ci sono un sacco di usi matematici, scientifici e ingegneristici per queste cose.

Answer 8

Sono sicuro che non è quello che stai cercando, ma nel settore delle apparecchiature di test e misura, non sarebbe inusuale per un 'programma di test' includere istruzioni che operano su valori espressi in tensione, corrente o unità di tempo.

Cose molto specializzate, tuttavia, e difficilmente riconoscibili dalla maggior parte come linguaggi di programmazione.

Answer 9

C'è una libreria Boost C++ per le unità che fa ampio uso della metaprogrammazione del modello per fornire qualcosa di simile alla sintassi che si desidera.

quantity<force>  F(2.0*newton); 
quantity<length> dx(2.0*meter); 
quantity<energy> E(work(F,dx)); 

http://www.boost.org/doc/libs/1_37_0/doc/html/boost_units.html

Answer 10

funzione di PHP strtotime() lo fa molto bene.Prende una stringa e un tempo opzionale come parametri e analizzerà la stringa per capire una nuova ora.

Esempi:

$newTime = strtotime('last monday'); 
$newTime = strtotime('- 2 days', $originalTime); 
$newTime = strtotime('- 60 years', $originalTime); 
$newTime = strtotime('+ 1 week 1 day', $originalTime); 

più qui: http://us2.php.net/strtotime

Answer 11

Quando si utilizza le unità, si sta effettivamente l'assegnazione di un tipo. Le conversioni potrebbero essere implementate tramite casting o tramite chiamate di funzioni di differenziazione basate su tipi di parametri (overloading di funzioni). Quasi qualsiasi linguaggio tipizzato staticamente (che consente di definire a fondo i tipi) ti consentirebbe di fare qualcosa di simile. Ciò renderebbe il tuo programma più robusto, sebbene coloro che preferiscono linguaggi tipizzati dinamicamente potrebbero sostenere che i guadagni sono piccoli rispetto al tempo impiegato per implementare un sistema di tipo così completo per la maggior parte delle applicazioni. Costruire un Mars Climate Orbiter, d'altra parte, dovrebbe meritare un tale sistema di tipi.

La sintassi è un po 'diversa, ma il tuo esempio mi sembra molto simile agli esempi comuni di come alcuni userebbero il sistema di tipi di Haskell (o quello di qualsiasi linguaggio funzionale digitato), anche se, come ho detto, anche questo è fattibile anche in lingue simili a C.

Answer 12

SQL, o almeno MySQL ha un supporto di base basato sull'orario di base.

mysql> SELECT DATE_SUB(NOW(), INTERVAL 1 DAY) AS `yesterday`, NOW() + INTERVAL 1 DAY AS `tomorrow`; 
+---------------------+---------------------+ 
| yesterday   | tomorrow   | 
+---------------------+---------------------+ 
| 2009-08-20 06:55:05 | 2009-08-22 06:55:05 | 
+---------------------+---------------------+ 
1 row in set (0.00 sec) 

Answer 13

MySQL ha this feature

mysql> SELECT '2008-12-31 23:59:59' + INTERVAL 1 SECOND; 
     -> '2009-01-01 00:00:00' 
mysql> SELECT INTERVAL 1 DAY + '2008-12-31'; 
     -> '2009-01-01' 
mysql> SELECT '2005-01-01' - INTERVAL 1 SECOND; 
     -> '2004-12-31 23:59:59' 

Answer 14

vedere la risposta sul C# Extensions in cui la classe int è esteso per supportare metodi come Hours(), Giorni(), ecc

Powershell ha la kB, MB, and GB operators per gestire le dimensioni dei file, ecc.

Il DATE_ADD() function in MSSQL accetta unità come giorno, ora ecc. Per data aritmetica.

Answer 15

Non fa parte del linguaggio, ma ho visto che fatto prima in C, qualcosa come:

#define NOW  time(0) 
#define PLUS + 
#define AND  + 
#define MINUS - 
#define SECOND * 1 
#define SECONDS * 1 
#define MINUTE * 60 
#define MINUTES * 60 
#define HOUR * 3600 
#define HOURS * 3600 
#define DAY  * 86400 
#define DAYS * 86400 

time_t waitUntil = NOW PLUS 1 HOUR AND 23 MINUTES; 

Sembrava un abominio per me in quel momento, nella stessa classe come "#define begin {" e "#define end }" - se non ti piace il modo in cui la lingua funziona, usa una lingua diversa; non cercare di piegarlo alla tua volontà in un modo così orribile.

Sembra ancora un abominio, ma mi sono ammorbidito nella mia vecchiaia e posso almeno capire perché forse qualcuno ha pensato che fosse una buona idea.

Answer 16

Potreste essere interessati in F # Units of Measure supporto

Answer 17

PowerShell ha qualche supporto di base.Ad esempio, 5GB/1MB valuta a 5120

Answer 18

La nuova lingua di Sun Fortress supporta le unità e, se la memoria serve, è abbastanza intelligente da impedirti di fare cose strane come sottrarre misure di tempo da misure di lunghezza.

E Mathematica ha unità di misura e una sintassi non troppo complessa per gestirle.

Answer 19

Unum praticamente fa esattamente questo per Python, permettendo il codice come:

>>> TON + 500*KG 

1.5 [t] 

>>> 5E-8*M - 28*ANGSTROM 

472.0 [angstrom] 

>>> 3*H + 20*MIN + 15*S 

3.3375 [h] 

>>> H == 60*MIN 

True 

>>> 10000*S > 3*H + 15*MIN 

False 

>>> 

Answer 20

Syntacticly, io non sono davvero sicuro di quello che il benifit sarebbe di

DateTime.Now + 60 years 

corso

DateTime.Now.AddYears (60) 

Il mio metodo tipico per gestire "unità" è definire costanti che convertono quelle unità nell'unità di base dell'oggetto dati se moltiplicate. Dal momento che qualcuno (breifly) tagged questo con Ada, la versione Ada sarebbe:

Years : constant := 60.0 * 60.0 * 24.0 * 365.0; 
DateTime.Now := DateTime.Now + (60.0 * Years); 

penso che si può fare più o meno lo stesso pensare in C++, se non che i loro oggetti di tempo sono suscettibili di essere grandi numeri interi, invece di reali .

Answer 21

Non unità, di per sé ... ma un modo per utilizzare i metodi di estensione per fornire funzionalità unitarie. Questo esempio è specifico per TimeSpan.

static class TimeExtensions 
{ 
    public static TimeSpan ToDays(this int i) 
    { 
     return new TimeSpan(i, 0, 0, 0, 0); 
    } 

    public static TimeSpan ToHours(this int i) 
    { 
     return new TimeSpan(0, i, 0, 0, 0); 
    } 

    public static TimeSpan ToMinutes(this int i) 
    { 
     return new TimeSpan(0, 0, i, 0, 0); 
    } 

    public static TimeSpan ToSeconds(this int i) 
    { 
     return new TimeSpan(0, 0, 0, i, 0); 
    } 

    public static TimeSpan ToMilliseconds(this int i) 
    { 
     return new TimeSpan(0, 0, 0, 0, i); 
    } 
} 

Quindi, semplicemente 4.ToMinutes() fornisce un TimeSpan di 4 minuti. Se si dispone di classi di base simili con cui lavorare per rappresentare altri tipi di unità, è possibile aggiungere lo stesso tipo di funzionalità di estensione.

. (Nota: questo è solo una rappresentazione C# dell'esempio Ruby)

Answer 22

io so cosa vuoi dire, e anch'io sono stato curioso di questo. (Il mio insegnante di chimica del liceo era convinto che i numeri senza unità fossero abbastanza privi di significato.)

Con qualsiasi linguaggio fortemente tipizzato, è possibile scrivere classi per questi concetti. Li ho scritti in C++, Java e Pascal. Google "Unità" e "Java" e puoi trovare una libreria che ha incapsulati tutti i tipi di misurazioni fisiche come questa.

C++, con le sue conversioni di tipo slicker e il sovraccarico dell'operatore può rendere questo aspetto più naturale. In realtà puoi rendere le cose piuttosto fluide, ottenere ciò che penso che vuoi. Java, sebbene lo faccia, richiederà conversioni più esplicite e una sintassi scomoda.

Ma no, non l'ho visto.

Cerca linguaggi specifici di dominio creati per gli scienziati, anche quelli "educativi".

Answer 23

Frink è un linguaggio appositamente creato per "calcoli fisici" come quello. Dalla documentazione:

Frink è uno strumento di calcolo e linguaggio di programmazione pratico progettato per fare calcoli fisici semplice, per contribuire a garantire che le risposte vengono fuori destra [..].Tiene traccia di unità di misura (piedi, metri, chilogrammi, watt, etc.) attraverso tutti i calcoli, che consente di mescolare unità di misura in modo trasparente [..]

vostro esempio in Frink:

now[] - 60 years 

Answer 24

Ada e suo cugino, VHDL, supportano direttamente il concetto di unità. Dal momento che queste lingue sono estremamente tipizzate, le unità sono un'abilità naturale della severità dei tipi.