Est-ce que quelque chose de similaire existe en .Net? https://vimeo.com/39819321 En gros, ça utilise les méthodes d'extensions pour construire une "distance" à partir d'un Integer.
Ex:
1.mm + 3.cm - 2.km
Ca serait aussi sympa d'avoir ça pour le temps:
1.sec + 3.min - 4.h
Il n'y a rien de bien officiel à ma connaissance malgré de nombres options
de librairies de traitement des unités qui vadrouillent à droite à gauche...
C# n'étant pas tout à fait un langage extensible au niveau de sa structure,
on ne peut pas lui coller des membres sur des nombres comme ça, par contre
à coup d'extension methods, oui, tu peux faire quelque chose de ressemblant:
var distance = 1.mm() + 3.cm() + 2.5.Km();
if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
que tu as en vrac avec une classe à l'arrache:
public static class IntTimeExtensions
{
public static double mm(this double current)
{
return current * 0.001;
}
public static double cm(this double current)
{
return current * 0.01;
}
public static double m(this double current)
{
return current;
}
public static double Km(this double current)
{
return current * 1000;
}
public static double mm(this int current)
{
return current * 0.001;
}
public static double cm(this int current)
{
return current * 0.01;
}
public static double m(this int current)
{
return current;
}
public static double Km(this int current)
{
return current * 1000;
}
}
Idéalement au lieu de retourner un double il faudrait retourner directement
une unité typee compatible double dans lequel on aurait setter au passage
l'unité en cours.
Après on peut imaginer plein de trucs sympa à base de lambdas et autres
choses mais dans tous les cas tu ne pourras pas y échapper si tu essaye de
faire autre chose que des unités à dimension simple, il faut être capable
d'analyser l'arbre produit par le calcul complet et là c'est une autre
paire de manches...
> Est-ce que quelque chose de similaire existe en .Net?
> https://vimeo.com/39819321 > En gros, ça utilise les méthodes d'extensions pour construire une
> "distance" à partir d'un Integer.
> Ex:
> 1.mm + 3.cm - 2.km
> Ca serait aussi sympa d'avoir ça pour le temps:
> 1.sec + 3.min - 4.h
> Est-ce que quelque chose de similaire existe en .Net?
> https://vimeo.com/39819321 > En gros, ça utilise les méthodes d'extensions pour construire une
> "distance" à partir d'un Integer.
> Ex:
> 1.mm + 3.cm - 2.km
> Ca serait aussi sympa d'avoir ça pour le temps:
> 1.sec + 3.min - 4.h
> Il n'y a rien de bien officiel à ma connaissance malgré de nombres options
> de librairies de traitement des unités qui vadrouillent à droite à gauche...
> C# n'étant pas tout à fait un langage extensible au niveau de sa
> structure, on ne peut pas lui coller des membres sur des nombres comme ça,
> par contre à coup d'extension methods, oui, tu peux faire quelque chose de
> ressemblant:
> var distance = 1.mm() + 3.cm() + 2.5.Km();
> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
> que tu as en vrac avec une classe à l'arrache:
> public static class IntTimeExtensions
> {
> public static double mm(this double current)
> {
> return current * 0.001;
> }
> public static double cm(this double current)
> {
> return current * 0.01;
> }
> public static double m(this double current)
> {
> return current;
> }
> public static double Km(this double current)
> {
> return current * 1000;
> }
> public static double mm(this int current)
> {
> return current * 0.001;
> }
> public static double cm(this int current)
> {
> return current * 0.01;
> }
> public static double m(this int current)
> {
> return current;
> }
> public static double Km(this int current)
> {
> return current * 1000;
> }
> }
> Idéalement au lieu de retourner un double il faudrait retourner
> directement une unité typee compatible double dans lequel on aurait setter
> au passage l'unité en cours.
> Après on peut imaginer plein de trucs sympa à base de lambdas et autres
> choses mais dans tous les cas tu ne pourras pas y échapper si tu essaye de
> faire autre chose que des unités à dimension simple, il faut être capable
> d'analyser l'arbre produit par le calcul complet et là c'est une autre
> paire de manches...
> my 2 cents
> Rui.
> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>> Hello!
>> Est-ce que quelque chose de similaire existe en .Net?
>> https://vimeo.com/39819321 >> En gros, ça utilise les méthodes d'extensions pour construire une
>> "distance" à partir d'un Integer.
>> Ex:
>> 1.mm + 3.cm - 2.km
>> Ca serait aussi sympa d'avoir ça pour le temps:
>> 1.sec + 3.min - 4.h
>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
>> options de librairies de traitement des unités qui vadrouillent à droite à
>> gauche...
>> C# n'étant pas tout à fait un langage extensible au niveau de sa
>> structure, on ne peut pas lui coller des membres sur des nombres comme ça,
>> par contre à coup d'extension methods, oui, tu peux faire quelque chose de
>> ressemblant:
>> var distance = 1.mm() + 3.cm() + 2.5.Km();
>> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
>> que tu as en vrac avec une classe à l'arrache:
>> public static class IntTimeExtensions
>> {
>> public static double mm(this double current)
>> {
>> return current * 0.001;
>> }
>> public static double cm(this double current)
>> {
>> return current * 0.01;
>> }
>> public static double m(this double current)
>> {
>> return current;
>> }
>> public static double Km(this double current)
>> {
>> return current * 1000;
>> }
>> public static double mm(this int current)
>> {
>> return current * 0.001;
>> }
>> public static double cm(this int current)
>> {
>> return current * 0.01;
>> }
>> public static double m(this int current)
>> {
>> return current;
>> }
>> public static double Km(this int current)
>> {
>> return current * 1000;
>> }
>> }
>> Idéalement au lieu de retourner un double il faudrait retourner
>> directement une unité typee compatible double dans lequel on aurait setter
>> au passage l'unité en cours.
>> Après on peut imaginer plein de trucs sympa à base de lambdas et autres
>> choses mais dans tous les cas tu ne pourras pas y échapper si tu essaye de
>> faire autre chose que des unités à dimension simple, il faut être capable
>> d'analyser l'arbre produit par le calcul complet et là c'est une autre
>> paire de manches...
>> my 2 cents
>> Rui.
>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>>> Hello!
>>> Est-ce que quelque chose de similaire existe en .Net?
>>> https://vimeo.com/39819321 >>> En gros, ça utilise les méthodes d'extensions pour construire une
>>> "distance" à partir d'un Integer.
>>> Ex:
>>> 1.mm + 3.cm - 2.km
>>> Ca serait aussi sympa d'avoir ça pour le temps:
>>> 1.sec + 3.min - 4.h
rhaaa, voila c'était ds F#, que j'avais apperçu les units, je me disais
bien qu'il devait y avoir qqch comme ça ds .net. Je me demande si il n'y
avait pas une lib de ms labs pour .net en général qui s'occupait de ça?
Juste pour revenir sur les méthodes d'ext, même si cela peut sembler
pratique au premier abord (comme toujours avec ces dernières), je ne suis
pas sur que l'on puisse aller très loin avec dans tous les cas.
J'ai un peu cherché la manière la moins crade en termes de fonctionnalités
et d'écriture (je m'amuse d'un rien faut dire, merci Mathias ;-), et j'en
suis arrivé à utiliser les cast pour ça...voila ce a quoi j'arrive:
var a = (Meter)123 + (Kilometer)2.3 + (Centimeter)1234;
Console.WriteLine(a.ToString());
Console.WriteLine(a.To<Kilometer>().ToString());
Console.WriteLine(a.To<Centimeter>().ToString());
var b = (Meter)2 * (Centimeter)30;
Console.WriteLine(b.ToString());
Console.WriteLine(b.ToSurface<Centimeter>().ToString());
>>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
>>> options de librairies de traitement des unités qui vadrouillent à droite à
>>> gauche...
>>> C# n'étant pas tout à fait un langage extensible au niveau de sa
>>> structure, on ne peut pas lui coller des membres sur des nombres comme ça,
>>> par contre à coup d'extension methods, oui, tu peux faire quelque chose de
>>> ressemblant:
>>> var distance = 1.mm() + 3.cm() + 2.5.Km();
>>> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
>>> que tu as en vrac avec une classe à l'arrache:
>>> public static class IntTimeExtensions
>>> {
>>> public static double mm(this double current)
>>> {
>>> return current * 0.001;
>>> }
>>> public static double cm(this double current)
>>> {
>>> return current * 0.01;
>>> }
>>> public static double m(this double current)
>>> {
>>> return current;
>>> }
>>> public static double Km(this double current)
>>> {
>>> return current * 1000;
>>> }
>>> public static double mm(this int current)
>>> {
>>> return current * 0.001;
>>> }
>>> public static double cm(this int current)
>>> {
>>> return current * 0.01;
>>> }
>>> public static double m(this int current)
>>> {
>>> return current;
>>> }
>>> public static double Km(this int current)
>>> {
>>> return current * 1000;
>>> }
>>> }
>>> Idéalement au lieu de retourner un double il faudrait retourner
>>> directement une unité typee compatible double dans lequel on aurait setter
>>> au passage l'unité en cours.
>>> Après on peut imaginer plein de trucs sympa à base de lambdas et autres
>>> choses mais dans tous les cas tu ne pourras pas y échapper si tu essaye de
>>> faire autre chose que des unités à dimension simple, il faut être capable
>>> d'analyser l'arbre produit par le calcul complet et là c'est une autre
>>> paire de manches...
>>> my 2 cents
>>> Rui.
>>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>>>> Hello!
>>>> Est-ce que quelque chose de similaire existe en .Net?
>>>> https://vimeo.com/39819321 >>>> En gros, ça utilise les méthodes d'extensions pour construire une
>>>> "distance" à partir d'un Integer.
>>>> Ex:
>>>> 1.mm + 3.cm - 2.km
>>>> Ca serait aussi sympa d'avoir ça pour le temps:
>>>> 1.sec + 3.min - 4.h
> rhaaa, voila c'était ds F#, que j'avais apperçu les units, je me disais
> bien qu'il devait y avoir qqch comme ça ds .net. Je me demande si il n'y
> avait pas une lib de ms labs pour .net en général qui s'occupait de ça?
> Juste pour revenir sur les méthodes d'ext, même si cela peut sembler
> pratique au premier abord (comme toujours avec ces dernières), je ne suis
> pas sur que l'on puisse aller très loin avec dans tous les cas.
> J'ai un peu cherché la manière la moins crade en termes de fonctionnalités
> et d'écriture (je m'amuse d'un rien faut dire, merci Mathias ;-), et j'en
> suis arrivé à utiliser les cast pour ça...voila ce a quoi j'arrive:
> var a = (Meter)123 + (Kilometer)2.3 + (Centimeter)1234;
>>>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
>>>> options de librairies de traitement des unités qui vadrouillent à droite à
>>>> gauche...
>>>> C# n'étant pas tout à fait un langage extensible au niveau de sa
>>>> structure, on ne peut pas lui coller des membres sur des nombres comme ça,
>>>> par contre à coup d'extension methods, oui, tu peux faire quelque chose de
>>>> ressemblant:
>>>> var distance = 1.mm() + 3.cm() + 2.5.Km();
>>>> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
>>>> que tu as en vrac avec une classe à l'arrache:
>>>> public static class IntTimeExtensions
>>>> {
>>>> public static double mm(this double current)
>>>> {
>>>> return current * 0.001;
>>>> }
>>>> public static double cm(this double current)
>>>> {
>>>> return current * 0.01;
>>>> }
>>>> public static double m(this double current)
>>>> {
>>>> return current;
>>>> }
>>>> public static double Km(this double current)
>>>> {
>>>> return current * 1000;
>>>> }
>>>> public static double mm(this int current)
>>>> {
>>>> return current * 0.001;
>>>> }
>>>> public static double cm(this int current)
>>>> {
>>>> return current * 0.01;
>>>> }
>>>> public static double m(this int current)
>>>> {
>>>> return current;
>>>> }
>>>> public static double Km(this int current)
>>>> {
>>>> return current * 1000;
>>>> }
>>>> }
>>>> Idéalement au lieu de retourner un double il faudrait retourner
>>>> directement une unité typee compatible double dans lequel on aurait setter
>>>> au passage l'unité en cours.
>>>> Après on peut imaginer plein de trucs sympa à base de lambdas et autres
>>>> choses mais dans tous les cas tu ne pourras pas y échapper si tu essaye de
>>>> faire autre chose que des unités à dimension simple, il faut être capable
>>>> d'analyser l'arbre produit par le calcul complet et là c'est une autre
>>>> paire de manches...
>>>> my 2 cents
>>>> Rui.
>>>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>>>>> Hello!
>>>>> Est-ce que quelque chose de similaire existe en .Net?
>>>>> https://vimeo.com/39819321 >>>>> En gros, ça utilise les méthodes d'extensions pour construire une
>>>>> "distance" à partir d'un Integer.
>>>>> Ex:
>>>>> 1.mm + 3.cm - 2.km
>>>>> Ca serait aussi sympa d'avoir ça pour le temps:
>>>>> 1.sec + 3.min - 4.h
> rhaaa, voila c'était ds F#, que j'avais apperçu les units, je me disais bien qu'il devait y avoir qqch comme ça ds .net. Je me demande si il n'y avait pas une lib de ms labs pour .net en général qui s'occupait de ça?
> Juste pour revenir sur les méthodes d'ext, même si cela peut sembler pratique au premier abord (comme toujours avec ces dernières), je ne suis pas sur que l'on puisse aller très loin avec dans tous les cas.
> J'ai un peu cherché la manière la moins crade en termes de fonctionnalités et d'écriture (je m'amuse d'un rien faut dire, merci Mathias ;-), et j'en suis arrivé à utiliser les cast pour ça...voila ce a quoi j'arrive:
> var a = (Meter)123 + (Kilometer)2.3 + (Centimeter)1234;
> Console.WriteLine(a.ToString());
> Console.WriteLine(a.To<Kilometer>().ToString());
> Console.WriteLine(a.To<Centimeter>().ToString());
> var b = (Meter)2 * (Centimeter)30;
> Console.WriteLine(b.ToString());
> Console.WriteLine(b.ToSurface<Centimeter>().ToString());
> C'est en mode poc, donc pas clean, et c'est dans un gist pour qu'on puisse discuter dessus si il y en a que ça intéresse.
> Sinon je serai intéressé de voir toute implem de cette problématique.
> Voici le gist avec le code:
> https://gist.github.com/4dafaa0252944815f16c
> > 2012/7/4 Yann Schwartz <abolibibe...@gmail.com (mailto:abolibibe...@gmail.com)>
> > > Il y a un langage spécialisé très marrant qui se spécialise dans ce genre de choses : Frink ( http://futureboy.us/frinkdocs/#HowFrinkIsDifferent ) qui compile sur la JVM.
> > > Et bien sûr, un portage vers Clojure appelé Frinj et qui illustre la facilité de définir des DSL en Lisp :
> > > qui reprend le tutorial de Frink, mais en clojure.
> > > 2012/7/4 Rui Carvalho <r...@rui.fr (mailto:r...@rui.fr)>
> > > > Il n'y a rien de bien officiel à ma connaissance malgré de nombres options de librairies de traitement des unités qui vadrouillent à droite à gauche...
> > > > C# n'étant pas tout à fait un langage extensible au niveau de sa structure, on ne peut pas lui coller des membres sur des nombres comme ça, par contre à coup d'extension methods, oui, tu peux faire quelque chose de ressemblant:
> > > > que tu as en vrac avec une classe à l'arrache:
> > > > public static class IntTimeExtensions
> > > > {
> > > > public static double mm(this double current)
> > > > {
> > > > return current * 0.001;
> > > > }
> > > > public static double cm(this double current)
> > > > {
> > > > return current * 0.01;
> > > > }
> > > > public static double m(this double current)
> > > > {
> > > > return current;
> > > > }
> > > > public static double Km(this double current)
> > > > {
> > > > return current * 1000;
> > > > }
> > > > public static double mm(this int current)
> > > > {
> > > > return current * 0.001;
> > > > }
> > > > public static double cm(this int current)
> > > > {
> > > > return current * 0.01;
> > > > }
> > > > public static double m(this int current)
> > > > {
> > > > return current;
> > > > }
> > > > public static double Km(this int current)
> > > > {
> > > > return current * 1000;
> > > > }
> > > > }
> > > > Idéalement au lieu de retourner un double il faudrait retourner directement une unité typee compatible double dans lequel on aurait setter au passage l'unité en cours.
> > > > Après on peut imaginer plein de trucs sympa à base de lambdas et autres choses mais dans tous les cas tu ne pourras pas y échapper si tu essaye de faire autre chose que des unités à dimension simple, il faut être capable d'analyser l'arbre produit par le calcul complet et là c'est une autre paire de manches...
> > > > > Est-ce que quelque chose de similaire existe en .Net? https://vimeo.com/39819321 > > > > > En gros, ça utilise les méthodes d'extensions pour construire une "distance" à partir d'un Integer.
> > > > > Ex:
> > > > > 1.mm (http://1.mm) + 3.cm (http://3.cm) - 2.km (http://2.km)
> > > > > Ca serait aussi sympa d'avoir ça pour le temps:
> > > > > 1.sec + 3.min - 4.h
Petite proposition d'amélioration pour les prochains exemples de codes :)
Au lieu des Console.Writeline, un petit Assert dans une méthode décorée
avec [Test] :)
D'autant que je ne m'imagine pas une seconde traiter ce genre de problèmes
sans TDD... ! :)
> rhaaa, voila c'était ds F#, que j'avais apperçu les units, je me disais
> bien qu'il devait y avoir qqch comme ça ds .net. Je me demande si il n'y
> avait pas une lib de ms labs pour .net en général qui s'occupait de ça?
> Juste pour revenir sur les méthodes d'ext, même si cela peut sembler
> pratique au premier abord (comme toujours avec ces dernières), je ne suis
> pas sur que l'on puisse aller très loin avec dans tous les cas.
> J'ai un peu cherché la manière la moins crade en termes de fonctionnalités
> et d'écriture (je m'amuse d'un rien faut dire, merci Mathias ;-), et j'en
> suis arrivé à utiliser les cast pour ça...voila ce a quoi j'arrive:
> var a = (Meter)123 + (Kilometer)2.3 + (Centimeter)1234;
>>>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
>>>> options de librairies de traitement des unités qui vadrouillent à droite à
>>>> gauche...
>>>> C# n'étant pas tout à fait un langage extensible au niveau de sa
>>>> structure, on ne peut pas lui coller des membres sur des nombres comme ça,
>>>> par contre à coup d'extension methods, oui, tu peux faire quelque chose de
>>>> ressemblant:
>>>> var distance = 1.mm() + 3.cm() + 2.5.Km();
>>>> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
>>>> que tu as en vrac avec une classe à l'arrache:
>>>> public static class IntTimeExtensions
>>>> {
>>>> public static double mm(this double current)
>>>> {
>>>> return current * 0.001;
>>>> }
>>>> public static double cm(this double current)
>>>> {
>>>> return current * 0.01;
>>>> }
>>>> public static double m(this double current)
>>>> {
>>>> return current;
>>>> }
>>>> public static double Km(this double current)
>>>> {
>>>> return current * 1000;
>>>> }
>>>> public static double mm(this int current)
>>>> {
>>>> return current * 0.001;
>>>> }
>>>> public static double cm(this int current)
>>>> {
>>>> return current * 0.01;
>>>> }
>>>> public static double m(this int current)
>>>> {
>>>> return current;
>>>> }
>>>> public static double Km(this int current)
>>>> {
>>>> return current * 1000;
>>>> }
>>>> }
>>>> Idéalement au lieu de retourner un double il faudrait retourner
>>>> directement une unité typee compatible double dans lequel on aurait setter
>>>> au passage l'unité en cours.
>>>> Après on peut imaginer plein de trucs sympa à base de lambdas et autres
>>>> choses mais dans tous les cas tu ne pourras pas y échapper si tu essaye de
>>>> faire autre chose que des unités à dimension simple, il faut être capable
>>>> d'analyser l'arbre produit par le calcul complet et là c'est une autre
>>>> paire de manches...
>>>> my 2 cents
>>>> Rui.
>>>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>>>>> Hello!
>>>>> Est-ce que quelque chose de similaire existe en .Net?
>>>>> https://vimeo.com/39819321 >>>>> En gros, ça utilise les méthodes d'extensions pour construire une
>>>>> "distance" à partir d'un Integer.
>>>>> Ex:
>>>>> 1.mm + 3.cm - 2.km
>>>>> Ca serait aussi sympa d'avoir ça pour le temps:
>>>>> 1.sec + 3.min - 4.h
> Est-ce que quelque chose de similaire existe en .Net?
> https://vimeo.com/39819321 > En gros, ça utilise les méthodes d'extensions pour construire une
> "distance" à partir d'un Integer.
> Ex:
> 1.mm + 3.cm - 2.km
> Ca serait aussi sympa d'avoir ça pour le temps:
> 1.sec + 3.min - 4.h
oui c'était le but de ces write mais pour ce genre de poc, je fais ça en
live sur linqpad qui est tres bien pour faire ce genre de tests
et du coup tu fais du tdd implicite sans framework de test mais ce n'est
pas grave car tu as ton feedback en live ;-)
@mathias,
comme je le disais, j'ai fait un petit test avec les méthodes d'extension,
mais je ne suis pas convaincu par l'approche dans la mesure où elles ne
sont qu'un artifice pour se greffer sur les nombres et où l'on aurait
certainement mieux fait d'encapsuler les nombres dans des vraies classes.
Est-ce que faire 'Distance.Meter(123) + Distance.Kilometer(2.4)' est
beaucoup plus contraignant que de faire '123.Distance<Meter>() +
2.5.Distance<Kilometer>()' ou un truc du genre?
De plus encore une fois cela ne te permet pas d'agir au niveau de
l'expression complete mais juste de transformer un nombre en quelque chose
de plus riche avec une unité. Si au lieu d'additionner, tu multiplie cela
devient quoi?
reprend ça '123.Distance<Meter>() * 2.5.Distance<Kilometer>()' mais avec la
multiplication cette fois ci, comment tu récupère un résultat sous forme de
surface?
C'est tout l'intérêt de jouer avec la redéfinition des casts et des
opérations, tu peut agir sur des membres deux a deux au niveau des
opérations (sans passer par de la manipulation d'expressions. Dans mon
exemple quand je fais '(Meter)2 * (Centimeter)30;'je récupère bien un type
surface de 0,6 M^2. L'autre avantage aussi c'est que tu peux vérifier à la
compil que tu ne fais pas d'opérations sur les choux et les carottes!
> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>> Hello!
>> Est-ce que quelque chose de similaire existe en .Net?
>> https://vimeo.com/39819321 >> En gros, ça utilise les méthodes d'extensions pour construire une
>> "distance" à partir d'un Integer.
>> Ex:
>> 1.mm + 3.cm - 2.km
>> Ca serait aussi sympa d'avoir ça pour le temps:
>> 1.sec + 3.min - 4.h
> De plus encore une fois cela ne te permet pas d'agir au niveau de
> l'expression complete mais juste de transformer un nombre en quelque
> chose de plus riche avec une unité. Si au lieu d'additionner, tu
> multiplie cela devient quoi?
> reprend ça '123.Distance<Meter>() * 2.5.Distance<Kilometer>()' mais avec
> la multiplication cette fois ci, comment tu récupère un résultat sous
> forme de surface?
> C'est tout l'intérêt de jouer avec la redéfinition des casts et des
> opérations, tu peut agir sur des membres deux a deux au niveau des
> opérations (sans passer par de la manipulation d'expressions. Dans mon
> exemple quand je fais '(Meter)2*(Centimeter)30;'je récupère bien un type
> surface de 0,6 M^2. L'autre avantage aussi c'est que tu peux vérifier à
> la compil que tu ne fais pas d'opérations sur les choux et les carottes!
Une idée pour passer par les extension methods sans cast et avoir les surfaces en multipliant des distances :
https://gist.github.com/3052728
on a a peu de choses près la meme implémentation, ce qui compte c'est 1) de
définir des types de base pour définir sur quel type de mesure on est et 2)
redéfinir les opérateurs pour les associations.
dans ton implem, je rajouterai peut être un enum avec l'unité de mesure
dans le constructeur pour que l'on aie une trace de la mesure initiale
(genre un DistanceUnits.Meters), un peu comme le T de la timezone dans les
dates.
> De plus encore une fois cela ne te permet pas d'agir au niveau de
>> l'expression complete mais juste de transformer un nombre en quelque
>> chose de plus riche avec une unité. Si au lieu d'additionner, tu
>> multiplie cela devient quoi?
>> reprend ça '123.Distance<Meter>() * 2.5.Distance<Kilometer>()' mais avec
>> la multiplication cette fois ci, comment tu récupère un résultat sous
>> forme de surface?
>> C'est tout l'intérêt de jouer avec la redéfinition des casts et des
>> opérations, tu peut agir sur des membres deux a deux au niveau des
>> opérations (sans passer par de la manipulation d'expressions. Dans mon
>> exemple quand je fais '(Meter)2*(Centimeter)30;'je récupère bien un type
>> surface de 0,6 M^2. L'autre avantage aussi c'est que tu peux vérifier à
>> la compil que tu ne fais pas d'opérations sur les choux et les carottes!
> Visiblement, dans F# les Units of Measure ne sont pas conservées après
> compilation... donc il faut aller voir ailleurs ;o)
Elles le sont.
Seulement elles ne sont accessibles que depuis F#.
Avec F# 2 tu as un module SI dans le powerpack, dans F# 3 c'est
directement dans le runtime F# il me semble.
Je pensais que Rob allait répondre, mais comme il ne le fait pas, je
vais faire le F#ista intérim.
Le système d'unité de F# est super chouette, mais il n'est pas
vraiment fait pour pour représenter des simples multiples de la même
unité.
Là où c'est fort on sait toujours dans quelle unité on s'exprime. Si
on regarde l'exemple d'un pseudo langage (non pas que scala est un
pseudo langage, hein):
2.cm + 4.m
On ne sait pas quelle est l'unité de sortie. Ok c'est une distance,
mais exprimée en quoi ? En centimètres ? En mètres ? Il va falloir
décider nous même lors de son utilisation, en fait.
On peut faire un parallèle avec le typage : c'est un peu comme si on
passait des “object” de partout, et qu'on castait à l'usage. Du coup
on peut facilement faire des conneries.
F# force statiquement à répondre à cette question (faut dire c'est un
peu son créneau).
Si on veut passer dans un multiple, il va falloir définir nous même
les conversions, ça donne une syntaxe un peu moche, et verbeuse:
[<Measure>]
type m =
static member to_km(m) = m * 0.0001<km/m>
and [<Measure>] km =
static member to_m(km) = km * 1000.0<m/km>
and [<Measure>] cm =
static member to_m(cm) = cm * 0.001<m/cm>
and [<Measure>] mm =
static member to_m(mm) = mm * 0.0001<m/mm>
Du coup on peut écrire:
let d = mm.to_m(1.0<mm>) + cm.to_m(3.0<cm>) + km.to_m(2.0<km>)
Au moins on sait que d est de type float<m>
F# ne nous laisse pas définir des méthodes d'extensions sur des
unités, du coup c'est dur d'avoir un truc fluent.
>>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
>>> options de librairies de traitement des unités qui vadrouillent à droite à
>>> gauche...
>>> C# n'étant pas tout à fait un langage extensible au niveau de sa
>>> structure, on ne peut pas lui coller des membres sur des nombres comme ça,
>>> par contre à coup d'extension methods, oui, tu peux faire quelque chose de
>>> ressemblant:
>>> var distance = 1.mm() + 3.cm() + 2.5.Km();
>>> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
>>> que tu as en vrac avec une classe à l'arrache:
>>> public static class IntTimeExtensions
>>> {
>>> public static double mm(this double current)
>>> {
>>> return current * 0.001;
>>> }
>>> public static double cm(this double current)
>>> {
>>> return current * 0.01;
>>> }
>>> public static double m(this double current)
>>> {
>>> return current;
>>> }
>>> public static double Km(this double current)
>>> {
>>> return current * 1000;
>>> }
>>> public static double mm(this int current)
>>> {
>>> return current * 0.001;
>>> }
>>> public static double cm(this int current)
>>> {
>>> return current * 0.01;
>>> }
>>> public static double m(this int current)
>>> {
>>> return current;
>>> }
>>> public static double Km(this int current)
>>> {
>>> return current * 1000;
>>> }
>>> }
>>> Idéalement au lieu de retourner un double il faudrait retourner
>>> directement une unité typee compatible double dans lequel on aurait setter
>>> au passage l'unité en cours.
>>> Après on peut imaginer plein de trucs sympa à base de lambdas et autres
>>> choses mais dans tous les cas tu ne pourras pas y échapper si tu essaye de
>>> faire autre chose que des unités à dimension simple, il faut être capable
>>> d'analyser l'arbre produit par le calcul complet et là c'est une autre paire
>>> de manches...
>>> my 2 cents
>>> Rui.
>>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>>>> Hello!
>>>> Est-ce que quelque chose de similaire existe en .Net?
>>>> https://vimeo.com/39819321 >>>> En gros, ça utilise les méthodes d'extensions pour construire une
>>>> "distance" à partir d'un Integer.
>>>> Ex:
>>>> 1.mm + 3.cm - 2.km
>>>> Ca serait aussi sympa d'avoir ça pour le temps:
>>>> 1.sec + 3.min - 4.h
> Je pensais que Rob allait répondre, mais comme il ne le fait pas, je
> vais faire le F#ista intérim.
> Le système d'unité de F# est super chouette, mais il n'est pas
> vraiment fait pour pour représenter des simples multiples de la même
> unité.
> Là où c'est fort on sait toujours dans quelle unité on s'exprime. Si
> on regarde l'exemple d'un pseudo langage (non pas que scala est un
> pseudo langage, hein):
> 2.cm + 4.m
> On ne sait pas quelle est l'unité de sortie. Ok c'est une distance,
> mais exprimée en quoi ? En centimètres ? En mètres ? Il va falloir
> décider nous même lors de son utilisation, en fait.
> On peut faire un parallèle avec le typage : c'est un peu comme si on
> passait des “object” de partout, et qu'on castait à l'usage. Du coup
> on peut facilement faire des conneries.
> F# force statiquement à répondre à cette question (faut dire c'est un
> peu son créneau).
> Si on veut passer dans un multiple, il va falloir définir nous même
> les conversions, ça donne une syntaxe un peu moche, et verbeuse:
> [<Measure>]
> type m =
> static member to_km(m) = m * 0.0001<km/m>
> and [<Measure>] km =
> static member to_m(km) = km * 1000.0<m/km>
> and [<Measure>] cm =
> static member to_m(cm) = cm * 0.001<m/cm>
> and [<Measure>] mm =
> static member to_m(mm) = mm * 0.0001<m/mm>
> Du coup on peut écrire:
> let d = mm.to_m(1.0<mm>) + cm.to_m(3.0<cm>) + km.to_m(2.0<km>)
> Au moins on sait que d est de type float<m>
> F# ne nous laisse pas définir des méthodes d'extensions sur des
> unités, du coup c'est dur d'avoir un truc fluent.
> Voilà.
> Jb
> 2012/7/4 Yann Schwartz <abolibibe...@gmail.com>:
> > On pourrait aussi citer les units of measure de F#
> >>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
> >>> options de librairies de traitement des unités qui vadrouillent à
> droite à
> >>> gauche...
> >>> C# n'étant pas tout à fait un langage extensible au niveau de sa
> >>> structure, on ne peut pas lui coller des membres sur des nombres comme
> ça,
> >>> par contre à coup d'extension methods, oui, tu peux faire quelque
> chose de
> >>> ressemblant:
> >>> var distance = 1.mm() + 3.cm() + 2.5.Km();
> >>> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
> >>> que tu as en vrac avec une classe à l'arrache:
> >>> public static class IntTimeExtensions
> >>> {
> >>> public static double mm(this double current)
> >>> {
> >>> return current * 0.001;
> >>> }
> >>> public static double cm(this double current)
> >>> {
> >>> return current * 0.01;
> >>> }
> >>> public static double m(this double current)
> >>> {
> >>> return current;
> >>> }
> >>> public static double Km(this double current)
> >>> {
> >>> return current * 1000;
> >>> }
> >>> public static double mm(this int current)
> >>> {
> >>> return current * 0.001;
> >>> }
> >>> public static double cm(this int current)
> >>> {
> >>> return current * 0.01;
> >>> }
> >>> public static double m(this int current)
> >>> {
> >>> return current;
> >>> }
> >>> public static double Km(this int current)
> >>> {
> >>> return current * 1000;
> >>> }
> >>> }
> >>> Idéalement au lieu de retourner un double il faudrait retourner
> >>> directement une unité typee compatible double dans lequel on aurait
> setter
> >>> au passage l'unité en cours.
> >>> Après on peut imaginer plein de trucs sympa à base de lambdas et autres
> >>> choses mais dans tous les cas tu ne pourras pas y échapper si tu
> essaye de
> >>> faire autre chose que des unités à dimension simple, il faut être
> capable
> >>> d'analyser l'arbre produit par le calcul complet et là c'est une autre
> paire
> >>> de manches...
> >>> my 2 cents
> >>> Rui.
> >>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
> >>>> Hello!
> >>>> Est-ce que quelque chose de similaire existe en .Net?
> >>>> https://vimeo.com/39819321 > >>>> En gros, ça utilise les méthodes d'extensions pour construire une
> >>>> "distance" à partir d'un Integer.
> >>>> Ex:
> >>>> 1.mm + 3.cm - 2.km
> >>>> Ca serait aussi sympa d'avoir ça pour le temps:
> >>>> 1.sec + 3.min - 4.h
Sexy, je sais pas, mais les unités de mesure F# assurent que la dimension
de ta valeur finale est correcte (tu n'additionnes pas de N/m² et des Pa
par exemple), ce qui est terriblement utile dans les calculs physiques. Par
contre, comme le dit jb, ça ne gère pas les multiples d'une même unité.
>> Je pensais que Rob allait répondre, mais comme il ne le fait pas, je
>> vais faire le F#ista intérim.
>> Le système d'unité de F# est super chouette, mais il n'est pas
>> vraiment fait pour pour représenter des simples multiples de la même
>> unité.
>> Là où c'est fort on sait toujours dans quelle unité on s'exprime. Si
>> on regarde l'exemple d'un pseudo langage (non pas que scala est un
>> pseudo langage, hein):
>> 2.cm + 4.m
>> On ne sait pas quelle est l'unité de sortie. Ok c'est une distance,
>> mais exprimée en quoi ? En centimètres ? En mètres ? Il va falloir
>> décider nous même lors de son utilisation, en fait.
>> On peut faire un parallèle avec le typage : c'est un peu comme si on
>> passait des “object” de partout, et qu'on castait à l'usage. Du coup
>> on peut facilement faire des conneries.
>> F# force statiquement à répondre à cette question (faut dire c'est un
>> peu son créneau).
>> Si on veut passer dans un multiple, il va falloir définir nous même
>> les conversions, ça donne une syntaxe un peu moche, et verbeuse:
>> [<Measure>]
>> type m =
>> static member to_km(m) = m * 0.0001<km/m>
>> and [<Measure>] km =
>> static member to_m(km) = km * 1000.0<m/km>
>> and [<Measure>] cm =
>> static member to_m(cm) = cm * 0.001<m/cm>
>> and [<Measure>] mm =
>> static member to_m(mm) = mm * 0.0001<m/mm>
>> Du coup on peut écrire:
>> let d = mm.to_m(1.0<mm>) + cm.to_m(3.0<cm>) + km.to_m(2.0<km>)
>> Au moins on sait que d est de type float<m>
>> F# ne nous laisse pas définir des méthodes d'extensions sur des
>> unités, du coup c'est dur d'avoir un truc fluent.
>> Voilà.
>> Jb
>> 2012/7/4 Yann Schwartz <abolibibe...@gmail.com>:
>> > On pourrait aussi citer les units of measure de F#
>> >>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
>> >>> options de librairies de traitement des unités qui vadrouillent à
>> droite à
>> >>> gauche...
>> >>> C# n'étant pas tout à fait un langage extensible au niveau de sa
>> >>> structure, on ne peut pas lui coller des membres sur des nombres
>> comme ça,
>> >>> par contre à coup d'extension methods, oui, tu peux faire quelque
>> chose de
>> >>> ressemblant:
>> >>> var distance = 1.mm() + 3.cm() + 2.5.Km();
>> >>> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
>> >>> que tu as en vrac avec une classe à l'arrache:
>> >>> public static class IntTimeExtensions
>> >>> {
>> >>> public static double mm(this double current)
>> >>> {
>> >>> return current * 0.001;
>> >>> }
>> >>> public static double cm(this double current)
>> >>> {
>> >>> return current * 0.01;
>> >>> }
>> >>> public static double m(this double current)
>> >>> {
>> >>> return current;
>> >>> }
>> >>> public static double Km(this double current)
>> >>> {
>> >>> return current * 1000;
>> >>> }
>> >>> public static double mm(this int current)
>> >>> {
>> >>> return current * 0.001;
>> >>> }
>> >>> public static double cm(this int current)
>> >>> {
>> >>> return current * 0.01;
>> >>> }
>> >>> public static double m(this int current)
>> >>> {
>> >>> return current;
>> >>> }
>> >>> public static double Km(this int current)
>> >>> {
>> >>> return current * 1000;
>> >>> }
>> >>> }
>> >>> Idéalement au lieu de retourner un double il faudrait retourner
>> >>> directement une unité typee compatible double dans lequel on aurait
>> setter
>> >>> au passage l'unité en cours.
>> >>> Après on peut imaginer plein de trucs sympa à base de lambdas et
>> autres
>> >>> choses mais dans tous les cas tu ne pourras pas y échapper si tu
>> essaye de
>> >>> faire autre chose que des unités à dimension simple, il faut être
>> capable
>> >>> d'analyser l'arbre produit par le calcul complet et là c'est une
>> autre paire
>> >>> de manches...
>> >>> my 2 cents
>> >>> Rui.
>> >>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>> >>>> Hello!
>> >>>> Est-ce que quelque chose de similaire existe en .Net?
>> >>>> https://vimeo.com/39819321 >> >>>> En gros, ça utilise les méthodes d'extensions pour construire une
>> >>>> "distance" à partir d'un Integer.
>> >>>> Ex:
>> >>>> 1.mm + 3.cm - 2.km
>> >>>> Ca serait aussi sympa d'avoir ça pour le temps:
>> >>>> 1.sec + 3.min - 4.h
> Sexy, je sais pas, mais les unités de mesure F# assurent que la dimension de
> ta valeur finale est correcte (tu n'additionnes pas de N/m² et des Pa par
> exemple), ce qui est terriblement utile dans les calculs physiques. Par
> contre, comme le dit jb, ça ne gère pas les multiples d'une même unité.
>>> Je pensais que Rob allait répondre, mais comme il ne le fait pas, je
>>> vais faire le F#ista intérim.
>>> Le système d'unité de F# est super chouette, mais il n'est pas
>>> vraiment fait pour pour représenter des simples multiples de la même
>>> unité.
>>> Là où c'est fort on sait toujours dans quelle unité on s'exprime. Si
>>> on regarde l'exemple d'un pseudo langage (non pas que scala est un
>>> pseudo langage, hein):
>>> 2.cm + 4.m
>>> On ne sait pas quelle est l'unité de sortie. Ok c'est une distance,
>>> mais exprimée en quoi ? En centimètres ? En mètres ? Il va falloir
>>> décider nous même lors de son utilisation, en fait.
>>> On peut faire un parallèle avec le typage : c'est un peu comme si on
>>> passait des “object” de partout, et qu'on castait à l'usage. Du coup
>>> on peut facilement faire des conneries.
>>> F# force statiquement à répondre à cette question (faut dire c'est un
>>> peu son créneau).
>>> Si on veut passer dans un multiple, il va falloir définir nous même
>>> les conversions, ça donne une syntaxe un peu moche, et verbeuse:
>>> [<Measure>]
>>> type m =
>>> static member to_km(m) = m * 0.0001<km/m>
>>> and [<Measure>] km =
>>> static member to_m(km) = km * 1000.0<m/km>
>>> and [<Measure>] cm =
>>> static member to_m(cm) = cm * 0.001<m/cm>
>>> and [<Measure>] mm =
>>> static member to_m(mm) = mm * 0.0001<m/mm>
>>> Du coup on peut écrire:
>>> let d = mm.to_m(1.0<mm>) + cm.to_m(3.0<cm>) + km.to_m(2.0<km>)
>>> Au moins on sait que d est de type float<m>
>>> F# ne nous laisse pas définir des méthodes d'extensions sur des
>>> unités, du coup c'est dur d'avoir un truc fluent.
>>> Voilà.
>>> Jb
>>> 2012/7/4 Yann Schwartz <abolibibe...@gmail.com>:
>>> > On pourrait aussi citer les units of measure de F#
>>> >> Il y a un langage spécialisé très marrant qui se spécialise dans ce
>>> >> genre
>>> >> de choses : Frink (
>>> >> http://futureboy.us/frinkdocs/#HowFrinkIsDifferent )
>>> >> qui compile sur la JVM.
>>> >> Et bien sûr, un portage vers Clojure appelé Frinj et qui illustre la
>>> >> facilité de définir des DSL en Lisp :
>>> >>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
>>> >>> options de librairies de traitement des unités qui vadrouillent à
>>> >>> droite à
>>> >>> gauche...
>>> >>> C# n'étant pas tout à fait un langage extensible au niveau de sa
>>> >>> structure, on ne peut pas lui coller des membres sur des nombres
>>> >>> comme ça,
>>> >>> par contre à coup d'extension methods, oui, tu peux faire quelque
>>> >>> chose de
>>> >>> ressemblant:
>>> >>> var distance = 1.mm() + 3.cm() + 2.5.Km();
>>> >>> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
>>> >>> que tu as en vrac avec une classe à l'arrache:
>>> >>> public static class IntTimeExtensions
>>> >>> {
>>> >>> public static double mm(this double current)
>>> >>> {
>>> >>> return current * 0.001;
>>> >>> }
>>> >>> public static double cm(this double current)
>>> >>> {
>>> >>> return current * 0.01;
>>> >>> }
>>> >>> public static double m(this double current)
>>> >>> {
>>> >>> return current;
>>> >>> }
>>> >>> public static double Km(this double current)
>>> >>> {
>>> >>> return current * 1000;
>>> >>> }
>>> >>> public static double mm(this int current)
>>> >>> {
>>> >>> return current * 0.001;
>>> >>> }
>>> >>> public static double cm(this int current)
>>> >>> {
>>> >>> return current * 0.01;
>>> >>> }
>>> >>> public static double m(this int current)
>>> >>> {
>>> >>> return current;
>>> >>> }
>>> >>> public static double Km(this int current)
>>> >>> {
>>> >>> return current * 1000;
>>> >>> }
>>> >>> }
>>> >>> Idéalement au lieu de retourner un double il faudrait retourner
>>> >>> directement une unité typee compatible double dans lequel on aurait
>>> >>> setter
>>> >>> au passage l'unité en cours.
>>> >>> Après on peut imaginer plein de trucs sympa à base de lambdas et
>>> >>> autres
>>> >>> choses mais dans tous les cas tu ne pourras pas y échapper si tu
>>> >>> essaye de
>>> >>> faire autre chose que des unités à dimension simple, il faut être
>>> >>> capable
>>> >>> d'analyser l'arbre produit par le calcul complet et là c'est une
>>> >>> autre paire
>>> >>> de manches...
>>> >>> my 2 cents
>>> >>> Rui.
>>> >>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>>> >>>> Hello!
>>> >>>> Est-ce que quelque chose de similaire existe en .Net?
>>> >>>> https://vimeo.com/39819321 >>> >>>> En gros, ça utilise les méthodes d'extensions pour construire une
>>> >>>> "distance" à partir d'un Integer.
>>> >>>> Ex:
>>> >>>> 1.mm + 3.cm - 2.km
>>> >>>> Ca serait aussi sympa d'avoir ça pour le temps:
>>> >>>> 1.sec + 3.min - 4.h
> 2012/7/5 Yann Schwartz <abolibibe...@gmail.com>:
> > Sexy, je sais pas, mais les unités de mesure F# assurent que la
> dimension de
> > ta valeur finale est correcte (tu n'additionnes pas de N/m² et des Pa par
> > exemple), ce qui est terriblement utile dans les calculs physiques. Par
> > contre, comme le dit jb, ça ne gère pas les multiples d'une même unité.
> >>> Je pensais que Rob allait répondre, mais comme il ne le fait pas, je
> >>> vais faire le F#ista intérim.
> >>> Le système d'unité de F# est super chouette, mais il n'est pas
> >>> vraiment fait pour pour représenter des simples multiples de la même
> >>> unité.
> >>> Là où c'est fort on sait toujours dans quelle unité on s'exprime. Si
> >>> on regarde l'exemple d'un pseudo langage (non pas que scala est un
> >>> pseudo langage, hein):
> >>> 2.cm + 4.m
> >>> On ne sait pas quelle est l'unité de sortie. Ok c'est une distance,
> >>> mais exprimée en quoi ? En centimètres ? En mètres ? Il va falloir
> >>> décider nous même lors de son utilisation, en fait.
> >>> On peut faire un parallèle avec le typage : c'est un peu comme si on
> >>> passait des “object” de partout, et qu'on castait à l'usage. Du coup
> >>> on peut facilement faire des conneries.
> >>> F# force statiquement à répondre à cette question (faut dire c'est un
> >>> peu son créneau).
> >>> Si on veut passer dans un multiple, il va falloir définir nous même
> >>> les conversions, ça donne une syntaxe un peu moche, et verbeuse:
> >>> [<Measure>]
> >>> type m =
> >>> static member to_km(m) = m * 0.0001<km/m>
> >>> and [<Measure>] km =
> >>> static member to_m(km) = km * 1000.0<m/km>
> >>> and [<Measure>] cm =
> >>> static member to_m(cm) = cm * 0.001<m/cm>
> >>> and [<Measure>] mm =
> >>> static member to_m(mm) = mm * 0.0001<m/mm>
> >>> Du coup on peut écrire:
> >>> let d = mm.to_m(1.0<mm>) + cm.to_m(3.0<cm>) + km.to_m(2.0<km>)
> >>> Au moins on sait que d est de type float<m>
> >>> F# ne nous laisse pas définir des méthodes d'extensions sur des
> >>> unités, du coup c'est dur d'avoir un truc fluent.
> >>> Voilà.
> >>> Jb
> >>> 2012/7/4 Yann Schwartz <abolibibe...@gmail.com>:
> >>> > On pourrait aussi citer les units of measure de F#
> >>> >> Il y a un langage spécialisé très marrant qui se spécialise dans ce
> >>> >> genre
> >>> >> de choses : Frink (
> >>> >> http://futureboy.us/frinkdocs/#HowFrinkIsDifferent )
> >>> >> qui compile sur la JVM.
> >>> >> Et bien sûr, un portage vers Clojure appelé Frinj et qui illustre la
> >>> >> facilité de définir des DSL en Lisp :
> >>> >>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
> >>> >>> options de librairies de traitement des unités qui vadrouillent à
> >>> >>> droite à
> >>> >>> gauche...
> >>> >>> C# n'étant pas tout à fait un langage extensible au niveau de sa
> >>> >>> structure, on ne peut pas lui coller des membres sur des nombres
> >>> >>> comme ça,
> >>> >>> par contre à coup d'extension methods, oui, tu peux faire quelque
> >>> >>> chose de
> >>> >>> ressemblant:
> >>> >>> var distance = 1.mm() + 3.cm() + 2.5.Km();
> >>> >>> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
> >>> >>> que tu as en vrac avec une classe à l'arrache:
> >>> >>> public static class IntTimeExtensions
> >>> >>> {
> >>> >>> public static double mm(this double current)
> >>> >>> {
> >>> >>> return current * 0.001;
> >>> >>> }
> >>> >>> public static double cm(this double current)
> >>> >>> {
> >>> >>> return current * 0.01;
> >>> >>> }
> >>> >>> public static double m(this double current)
> >>> >>> {
> >>> >>> return current;
> >>> >>> }
> >>> >>> public static double Km(this double current)
> >>> >>> {
> >>> >>> return current * 1000;
> >>> >>> }
> >>> >>> public static double mm(this int current)
> >>> >>> {
> >>> >>> return current * 0.001;
> >>> >>> }
> >>> >>> public static double cm(this int current)
> >>> >>> {
> >>> >>> return current * 0.01;
> >>> >>> }
> >>> >>> public static double m(this int current)
> >>> >>> {
> >>> >>> return current;
> >>> >>> }
> >>> >>> public static double Km(this int current)
> >>> >>> {
> >>> >>> return current * 1000;
> >>> >>> }
> >>> >>> }
> >>> >>> Idéalement au lieu de retourner un double il faudrait retourner
> >>> >>> directement une unité typee compatible double dans lequel on aurait
> >>> >>> setter
> >>> >>> au passage l'unité en cours.
> >>> >>> Après on peut imaginer plein de trucs sympa à base de lambdas et
> >>> >>> autres
> >>> >>> choses mais dans tous les cas tu ne pourras pas y échapper si tu
> >>> >>> essaye de
> >>> >>> faire autre chose que des unités à dimension simple, il faut être
> >>> >>> capable
> >>> >>> d'analyser l'arbre produit par le calcul complet et là c'est une
> >>> >>> autre paire
> >>> >>> de manches...
> >>> >>> my 2 cents
> >>> >>> Rui.
> >>> >>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
> >>> >>>> Hello!
> >>> >>>> Est-ce que quelque chose de similaire existe en .Net?
> >>> >>>> https://vimeo.com/39819321 > >>> >>>> En gros, ça utilise les méthodes d'extensions pour construire une
> >>> >>>> "distance" à partir d'un Integer.
> >>> >>>> Ex:
> >>> >>>> 1.mm + 3.cm - 2.km
> >>> >>>> Ca serait aussi sympa d'avoir ça pour le temps:
> >>> >>>> 1.sec + 3.min - 4.h
>> 2012/7/5 Yann Schwartz <abolibibe...@gmail.com>:
>> > Sexy, je sais pas, mais les unités de mesure F# assurent que la
>> dimension de
>> > ta valeur finale est correcte (tu n'additionnes pas de N/m² et des Pa
>> par
>> > exemple), ce qui est terriblement utile dans les calculs physiques. Par
>> > contre, comme le dit jb, ça ne gère pas les multiples d'une même unité.
>> >> donc au final, ce que je peux en comprendre de tes exemples Jb, en F#
>> ce
>> >> n'est pas forcément plus sexy que ce que l'on peut faire en C#...
>> >>> Je pensais que Rob allait répondre, mais comme il ne le fait pas, je
>> >>> vais faire le F#ista intérim.
>> >>> Le système d'unité de F# est super chouette, mais il n'est pas
>> >>> vraiment fait pour pour représenter des simples multiples de la même
>> >>> unité.
>> >>> Là où c'est fort on sait toujours dans quelle unité on s'exprime. Si
>> >>> on regarde l'exemple d'un pseudo langage (non pas que scala est un
>> >>> pseudo langage, hein):
>> >>> 2.cm + 4.m
>> >>> On ne sait pas quelle est l'unité de sortie. Ok c'est une distance,
>> >>> mais exprimée en quoi ? En centimètres ? En mètres ? Il va falloir
>> >>> décider nous même lors de son utilisation, en fait.
>> >>> On peut faire un parallèle avec le typage : c'est un peu comme si on
>> >>> passait des “object” de partout, et qu'on castait à l'usage. Du coup
>> >>> on peut facilement faire des conneries.
>> >>> F# force statiquement à répondre à cette question (faut dire c'est un
>> >>> peu son créneau).
>> >>> Si on veut passer dans un multiple, il va falloir définir nous même
>> >>> les conversions, ça donne une syntaxe un peu moche, et verbeuse:
>> >>> [<Measure>]
>> >>> type m =
>> >>> static member to_km(m) = m * 0.0001<km/m>
>> >>> and [<Measure>] km =
>> >>> static member to_m(km) = km * 1000.0<m/km>
>> >>> and [<Measure>] cm =
>> >>> static member to_m(cm) = cm * 0.001<m/cm>
>> >>> and [<Measure>] mm =
>> >>> static member to_m(mm) = mm * 0.0001<m/mm>
>> >>> Du coup on peut écrire:
>> >>> let d = mm.to_m(1.0<mm>) + cm.to_m(3.0<cm>) + km.to_m(2.0<km>)
>> >>> Au moins on sait que d est de type float<m>
>> >>> F# ne nous laisse pas définir des méthodes d'extensions sur des
>> >>> unités, du coup c'est dur d'avoir un truc fluent.
>> >>> Voilà.
>> >>> Jb
>> >>> 2012/7/4 Yann Schwartz <abolibibe...@gmail.com>:
>> >>> > On pourrait aussi citer les units of measure de F#
>> >>> >> Il y a un langage spécialisé très marrant qui se spécialise dans ce
>> >>> >> genre
>> >>> >> de choses : Frink (
>> >>> >> http://futureboy.us/frinkdocs/#HowFrinkIsDifferent )
>> >>> >> qui compile sur la JVM.
>> >>> >> Et bien sûr, un portage vers Clojure appelé Frinj et qui illustre
>> la
>> >>> >> facilité de définir des DSL en Lisp :
>> >>> >>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
>> >>> >>> options de librairies de traitement des unités qui vadrouillent à
>> >>> >>> droite à
>> >>> >>> gauche...
>> >>> >>> C# n'étant pas tout à fait un langage extensible au niveau de sa
>> >>> >>> structure, on ne peut pas lui coller des membres sur des nombres
>> >>> >>> comme ça,
>> >>> >>> par contre à coup d'extension methods, oui, tu peux faire quelque
>> >>> >>> chose de
>> >>> >>> ressemblant:
>> >>> >>> var distance = 1.mm() + 3.cm() + 2.5.Km();
>> >>> >>> if (distance == 2500.031) Console.WriteLine("{0}
>> mètres",distance);
>> >>> >>> que tu as en vrac avec une classe à l'arrache:
>> >>> >>> public static class IntTimeExtensions
>> >>> >>> {
>> >>> >>> public static double mm(this double current)
>> >>> >>> {
>> >>> >>> return current * 0.001;
>> >>> >>> }
>> >>> >>> public static double cm(this double current)
>> >>> >>> {
>> >>> >>> return current * 0.01;
>> >>> >>> }
>> >>> >>> public static double m(this double current)
>> >>> >>> {
>> >>> >>> return current;
>> >>> >>> }
>> >>> >>> public static double Km(this double current)
>> >>> >>> {
>> >>> >>> return current * 1000;
>> >>> >>> }
>> >>> >>> public static double mm(this int current)
>> >>> >>> {
>> >>> >>> return current * 0.001;
>> >>> >>> }
>> >>> >>> public static double cm(this int current)
>> >>> >>> {
>> >>> >>> return current * 0.01;
>> >>> >>> }
>> >>> >>> public static double m(this int current)
>> >>> >>> {
>> >>> >>> return current;
>> >>> >>> }
>> >>> >>> public static double Km(this int current)
>> >>> >>> {
>> >>> >>> return current * 1000;
>> >>> >>> }
>> >>> >>> }
>> >>> >>> Idéalement au lieu de retourner un double il faudrait retourner
>> >>> >>> directement une unité typee compatible double dans lequel on
>> aurait
>> >>> >>> setter
>> >>> >>> au passage l'unité en cours.
>> >>> >>> Après on peut imaginer plein de trucs sympa à base de lambdas et
>> >>> >>> autres
>> >>> >>> choses mais dans tous les cas tu ne pourras pas y échapper si tu
>> >>> >>> essaye de
>> >>> >>> faire autre chose que des unités à dimension simple, il faut être
>> >>> >>> capable
>> >>> >>> d'analyser l'arbre produit par le calcul complet et là c'est une
>> >>> >>> autre paire
>> >>> >>> de manches...
>> >>> >>> my 2 cents
>> >>> >>> Rui.
>> >>> >>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>> >>> >>>> Hello!
>> >>> >>>> Est-ce que quelque chose de similaire existe en .Net?
>> >>> >>>> https://vimeo.com/39819321 >> >>> >>>> En gros, ça utilise les méthodes d'extensions pour construire une
>> >>> >>>> "distance" à partir d'un Integer.
>> >>> >>>> Ex:
>> >>> >>>> 1.mm + 3.cm - 2.km
>> >>> >>>> Ca serait aussi sympa d'avoir ça pour le temps:
>> >>> >>>> 1.sec + 3.min - 4.h
> 2012/7/5 Yann Schwartz <abolibibe...@gmail.com>:
>> Sexy, je sais pas, mais les unités de mesure F# assurent que la dimension de
>> ta valeur finale est correcte (tu n'additionnes pas de N/m² et des Pa par
>> exemple), ce qui est terriblement utile dans les calculs physiques. Par
>> contre, comme le dit jb, ça ne gère pas les multiples d'une même unité.
>>>> Je pensais que Rob allait répondre, mais comme il ne le fait pas, je
>>>> vais faire le F#ista intérim.
>>>> Le système d'unité de F# est super chouette, mais il n'est pas
>>>> vraiment fait pour pour représenter des simples multiples de la même
>>>> unité.
>>>> Là où c'est fort on sait toujours dans quelle unité on s'exprime. Si
>>>> on regarde l'exemple d'un pseudo langage (non pas que scala est un
>>>> pseudo langage, hein):
>>>> 2.cm + 4.m
>>>> On ne sait pas quelle est l'unité de sortie. Ok c'est une distance,
>>>> mais exprimée en quoi ? En centimètres ? En mètres ? Il va falloir
>>>> décider nous même lors de son utilisation, en fait.
>>>> On peut faire un parallèle avec le typage : c'est un peu comme si on
>>>> passait des “object” de partout, et qu'on castait à l'usage. Du coup
>>>> on peut facilement faire des conneries.
>>>> F# force statiquement à répondre à cette question (faut dire c'est un
>>>> peu son créneau).
>>>> Si on veut passer dans un multiple, il va falloir définir nous même
>>>> les conversions, ça donne une syntaxe un peu moche, et verbeuse:
>>>> [<Measure>]
>>>> type m =
>>>> static member to_km(m) = m * 0.0001<km/m>
>>>> and [<Measure>] km =
>>>> static member to_m(km) = km * 1000.0<m/km>
>>>> and [<Measure>] cm =
>>>> static member to_m(cm) = cm * 0.001<m/cm>
>>>> and [<Measure>] mm =
>>>> static member to_m(mm) = mm * 0.0001<m/mm>
>>>> Du coup on peut écrire:
>>>> let d = mm.to_m(1.0<mm>) + cm.to_m(3.0<cm>) + km.to_m(2.0<km>)
>>>> Au moins on sait que d est de type float<m>
>>>> F# ne nous laisse pas définir des méthodes d'extensions sur des
>>>> unités, du coup c'est dur d'avoir un truc fluent.
>>>> Voilà.
>>>> Jb
>>>> 2012/7/4 Yann Schwartz <abolibibe...@gmail.com>:
>>>>> On pourrait aussi citer les units of measure de F#
>>>>>> Il y a un langage spécialisé très marrant qui se spécialise dans ce
>>>>>> genre
>>>>>> de choses : Frink (
>>>>>> http://futureboy.us/frinkdocs/#HowFrinkIsDifferent )
>>>>>> qui compile sur la JVM.
>>>>>> Et bien sûr, un portage vers Clojure appelé Frinj et qui illustre la
>>>>>> facilité de définir des DSL en Lisp :
>>>>>>> Il n'y a rien de bien officiel à ma connaissance malgré de nombres
>>>>>>> options de librairies de traitement des unités qui vadrouillent à
>>>>>>> droite à
>>>>>>> gauche...
>>>>>>> C# n'étant pas tout à fait un langage extensible au niveau de sa
>>>>>>> structure, on ne peut pas lui coller des membres sur des nombres
>>>>>>> comme ça,
>>>>>>> par contre à coup d'extension methods, oui, tu peux faire quelque
>>>>>>> chose de
>>>>>>> ressemblant:
>>>>>>> var distance = 1.mm() + 3.cm() + 2.5.Km();
>>>>>>> if (distance == 2500.031) Console.WriteLine("{0} mètres",distance);
>>>>>>> que tu as en vrac avec une classe à l'arrache:
>>>>>>> public static class IntTimeExtensions
>>>>>>> {
>>>>>>> public static double mm(this double current)
>>>>>>> {
>>>>>>> return current * 0.001;
>>>>>>> }
>>>>>>> public static double cm(this double current)
>>>>>>> {
>>>>>>> return current * 0.01;
>>>>>>> }
>>>>>>> public static double m(this double current)
>>>>>>> {
>>>>>>> return current;
>>>>>>> }
>>>>>>> public static double Km(this double current)
>>>>>>> {
>>>>>>> return current * 1000;
>>>>>>> }
>>>>>>> public static double mm(this int current)
>>>>>>> {
>>>>>>> return current * 0.001;
>>>>>>> }
>>>>>>> public static double cm(this int current)
>>>>>>> {
>>>>>>> return current * 0.01;
>>>>>>> }
>>>>>>> public static double m(this int current)
>>>>>>> {
>>>>>>> return current;
>>>>>>> }
>>>>>>> public static double Km(this int current)
>>>>>>> {
>>>>>>> return current * 1000;
>>>>>>> }
>>>>>>> }
>>>>>>> Idéalement au lieu de retourner un double il faudrait retourner
>>>>>>> directement une unité typee compatible double dans lequel on aurait
>>>>>>> setter
>>>>>>> au passage l'unité en cours.
>>>>>>> Après on peut imaginer plein de trucs sympa à base de lambdas et
>>>>>>> autres
>>>>>>> choses mais dans tous les cas tu ne pourras pas y échapper si tu
>>>>>>> essaye de
>>>>>>> faire autre chose que des unités à dimension simple, il faut être
>>>>>>> capable
>>>>>>> d'analyser l'arbre produit par le calcul complet et là c'est une
>>>>>>> autre paire
>>>>>>> de manches...
>>>>>>> my 2 cents
>>>>>>> Rui.
>>>>>>> 2012/7/4 mathias kluba <mathias.kl...@gmail.com>
>>>>>>>> Hello!
>>>>>>>> Est-ce que quelque chose de similaire existe en .Net?
>>>>>>>> https://vimeo.com/39819321 >>>>>>>> En gros, ça utilise les méthodes d'extensions pour construire une
>>>>>>>> "distance" à partir d'un Integer.
>>>>>>>> Ex:
>>>>>>>> 1.mm + 3.cm - 2.km
>>>>>>>> Ca serait aussi sympa d'avoir ça pour le temps:
>>>>>>>> 1.sec + 3.min - 4.h
