An­drei Alexan­dres­cu, PhD
Re­search Sci­en­tist, Face­book.

Das ist mir jetzt auch neu.

Witzig, hat auch Spot in der D Newsgroup gehagelt.

Naja. Tun und lassen kann er ja was er will, aber ich frage mich, was er da effektiv tut. Soziale Netzwerke sind ja nicht gerade sein Fachgebiet.

Sind das nicht die gleichen Hörer im selben Raum:
http://www.youtube.com/watch?v=F6k8lTrAE2g&feature=channel

Selber Raum, andere Hörer.

drakon schrieb:

...Soziale Netzwerke sind ja nicht gerade sein Fachgebiet.

<rethorische_Frage>
Mal böse gefragt: Was ist denn sein Fachgebiet? "Unnütze Informationen"?
(Ich denke da an an das Buch Modern C++ Design)
</rethorische_Frage>

Ich habe mir den Vortrag auch angesehen, gestern Mittag. Richtig überzeugend war das IMHO nicht. Es gibt immer wieder Dinge, die mich an dem, was er sagt, stören. Um, mal ein Beispiel zu bringen: min . In D sei

auto min(L, R)(L lhs, R rhs) {
  return rhs < lhs ? rhs : lhs;
}

eine perfekte, vollständige, generische Implementierung von min , wobei hier klar auf Werte-Semantik gesetzt wird. N2199 dagegen versuchte eine Eier legende Wollmichsau zu sein, welche zB Referenzen zurück gibt, falls beide Argumente LValues und Referenz-kompatibel sind und auch noch signed/unsigned-Überraschungen, soweit möglich, umgeht, zB für den Fall min(-1,UINT_MAX). Das ist also eine ganz andere Zielsetzung. Ein "minvalue", so, wie es A.A. in D geschrieben hat, würde in C++0x so aussehen:

#include <type_traits>

template<class T, class U>
auto minvalue(T const& t, U const& u) -> std::common_type<T,U>::type
{
  return u<t ? u : t;
}

Immer noch kurz und knapp genug, wie ich finde. Da muss er sich eigentlich ein anderes Beispiel suchen, um D eine bessere Unterstützung für generische Programmierung attestieren zu können. Möchte man dazu noch unnötiges Kopieren vermeiden, könnte es so aussehen:

template<class T, class U>
auto minvalue(T && t, U && u) -> std::common_type<T,U>::type
{
  if (u<t) return std::forward<U>(u);
  return std::forward<T>(t);
}

Interessant dagegen fand ich das scope-Schlüsselwort. Das müsste sich aber auch mit C++0x-Mitteln über eine kleine Bibliothek emulieren lassen können.

kk

drakon schrieb:

...Soziale Netzwerke sind ja nicht gerade sein Fachgebiet.

<rethorische_Frage>
Mal böse gefragt: Was ist denn sein Fachgebiet? "Unnütze Informationen"?
(Ich denke da an an das Buch Modern C++ Design)
</rethorische_Frage>

Ich weiss jetzt nicht von was seine Doktorarbeit so handelt oder auch sonstige Arbeiten, aber ich denke mal, dass es eher mit Programmiersprachen und deren Entwicklung/Möglichkeiten oder aber auch Bibliotheksentwicklung zu tun hat. Das sagt ja auch seine Mitarbeit bei D über ihn aus.

Hab jetzt doch schnell nachgeschaut:

An­drei's re­search is in Ma­chine Learn­ing ap­plied to all do­mains of Human Lan­guage tech­nol­o­gy (Nat­u­ral Lan­gauge Pro­cess­ing, Speech Recog­ni­tion, Ma­chine Trans­la­tion).

Ok. Das kann Facebook sicher irgendwie gebrauchen.

@krümelkacker
Wird das so in Video gesagt?
Der Algo ist für Werte- als auch Referenz-Semantik zutreffend.

Naja, es lässt sich eigentlich schlecht vergleichen; denn D macht soweit ich weiß einen großen Unterschied zwischen class und nicht-class (struct, int, double, etc). Klassen-Objecte gibt es nur im Heap und können nur indirekt über Referenzen erreicht werden, die selbst in dem Sinne vollwertige "Objekte" (nach C++ Definition von Objekt) sind, als dass man sie verändern, auf Null setzten/testen kann u.s.w (also eher sich wie Zeiger verhalten, die "Adressen als Werte" haben). Ich wollte darauf hinaus, dass diese Funktion in D zB nicht das hier erlaubt:

int i = 2;
int j = 3;
min(i,j) = 5;

wobei das aber auch eines der Ziele des N2199 Proposals war, wenn ich das richtig verstanden habe.

Ich bin in D nicht so fit, dass ich behaupten könnte, die struct/class/Zeiger/Referenz-Thematik 100%ig verstanden zu haben.

kk

Ich habe mir den Vortrag auch angesehen, gestern Mittag. Richtig überzeugend war das IMHO nicht. Es gibt immer wieder Dinge, die mich an dem, was er sagt, stören. Um, mal ein Beispiel zu bringen: min . In D sei

auto min(L, R)(L lhs, R rhs) {
  return rhs < lhs ? rhs : lhs;
}

eine perfekte, vollständige, generische Implementierung von min , wobei hier klar auf Werte-Semantik gesetzt wird. N2199 dagegen versuchte eine Eier legende Wollmichsau zu sein, welche zB Referenzen zurück gibt, falls beide Argumente LValues und Referenz-kompatibel sind und auch noch signed/unsigned-Überraschungen, soweit möglich, umgeht, zB für den Fall min(-1,UINT_MAX). Das ist also eine ganz andere Zielsetzung. Ein "minvalue", so, wie es A.A. in D geschrieben hat, würde in C++0x so aussehen:

#include <type_traits>

template<class T, class U>
auto minvalue(T const& t, U const& u) -> std::common_type<T,U>::type
{
  return u<t ? u : t;
}

Immer noch kurz und knapp genug, wie ich finde. Da muss er sich eigentlich ein anderes Beispiel suchen, um D eine bessere Unterstützung für generische Programmierung attestieren zu können. Möchte man dazu noch unnötiges Kopieren vermeiden, könnte es so aussehen:

template<class T, class U>
auto minvalue(T && t, U && u) -> std::common_type<T,U>::type
{
  if (u<t) return std::forward<U>(u);
  return std::forward<T>(t);
}

Interessant dagegen fand ich das scope-Schlüsselwort. Das müsste sich aber auch mit C++0x-Mitteln über eine kleine Bibliothek emulieren lassen können.

kk

Wer ist eigentlich auf die Idee gekommen, dass min nicht einfach als retruntyp den der parameter nimmt?

Wer ist eigentlich auf die Idee gekommen, dass min nicht einfach als retruntyp den der parameter nimmt?

std::min arbeitet ja auch so. Aber std::min(-2,3u) klappt zB nicht, weil das eine ein signed int, das andere ein unsigned int ist und std::min nur mit einem Typ-Parameter parametrisiert wurde. Die Template-Argument-Deduction wird in diesem Fall fehlschlagen. Wenn man also einen Typ-Mix zulassen will, was bei a<b?a:b ja auch klappt, kann man zwei Typ-Parameter ( T , U ) verwenden und als Return-Typ std::common_type<T,U>::type benutzen. Beispiel: T = int , T = double , common_type<T,U>::type = double .

template<class T, class U>
auto mymin(T && t, U && u) -> std::common_type<T,U>::type
{
  if (u<t) return std::forward<U>(u);
  return std::forward<T>(t);
}

Ich habe gerade realisiert, dass diese Implementierung viel flexibler ist, als ich eigentlich dachte. Falls beide Argumente LValues waren, kommt auch eine Lvalue-Referenz zurück -- ganz automatisch. Also...

int i = 2;
int j = 3;
mymin(i,j) = 5;

klappt auch.

Lediglich mymin(-1,3u) liefert 3 statt -1, was daran liegt, dass -1 zwischendurch zu UINT_MAX konvertiert wird. Wie gesagt, das wollte N2199 auch verhindern und dafür einen long oder long long zurückgeben. Aber man kann's ja auch übertreiben...

kk

hhuuuuuuu?? schrieb:

Wer ist eigentlich auf die Idee gekommen, dass min nicht einfach als retruntyp den der parameter nimmt?

std::min arbeitet ja auch so. Aber std::min(-2,3u) klappt zB nicht, weil das eine ein signed int, das andere ein unsigned int ist und std::min nur mit einem Typ-Parameter parametrisiert wurde. Die Template-Argument-Deduction wird in diesem Fall fehlschlagen. Wenn man also einen Typ-Mix zulassen will, was bei a<b?a:b ja auch klappt, kann man zwei Typ-Parameter ( T , U ) verwenden und als Return-Typ std::common_type<T,U>::type benutzen. Beispiel: T = int , T = double , common_type<T,U>::type = double .

Wenn man unterschiedliche Typen vergleichen will, kann man ja auch einfach den einen casten. Unsigned/Signed vergleiche geben sowieso eine Compilerwarning.

krümelkacker schrieb:

Lediglich mymin(-1,3u) liefert 3 statt -1, was daran liegt, dass -1 zwischendurch zu UINT_MAX konvertiert wird. Wie gesagt, das wollte N2199 auch verhindern und dafür einen long oder long long zurückgeben. Aber man kann's ja auch übertreiben...

Ja, hast du die Warnung jetzt wegoptimiert.

import std.stdio;
import std.conv;

auto ref min(L, R)(ref L lhs, ref R rhs) { 
	return rhs < lhs ? rhs : lhs; 
}

void main()
{
	int i = 2;
	int j = 5;

	auto x = min(i, j);

	x = 9;

	writefln(to!(string)(i));	
	writefln(to!(string)(j));
	writefln(to!(string)(x));
}

Ausgabe:
2
5
9

@krümelkacker
Ach ja, schon wieder ein Beleg, warum man D nicht ernsthaft einsetzen sollte.

Es fällt mir schwer zu entscheiden, wie das gemeint sein könnte. War das Ironie?

kk

Zeus schrieb:

@krümelkacker
Ach ja, schon wieder ein Beleg, warum man D nicht ernsthaft einsetzen sollte.

Es fällt mir schwer zu entscheiden, wie das gemeint sein könnte. War das Ironie?

Ich tippe mal auf "Nein, war nicht ironisch."

Wie gesagt, ich kenne mich mit D nicht aus. Ich würde erwarten, dass man, damit das so klappt, wie Du es haben wolltest, vielleicht statt "auto" einfach "auto ref" sagt -- und zwar bei beiden stellen. Einmal bei der Funktion und einmal für dein x.

Zumindest funktioniert auto so bei C++0x (Die "auto fun() ->" mal ignoriert):

auto  x = foo(); // x ist nie eine Referenz
auto& x = foo(); // x ist eine Referenz (oder es kompiliert nicht).

Ich kann mir aber auch vorstellen, dass D das 'ref' nur bei Parameterübergabe zulässt, so wie es auch C# macht (glaub'ich).

kk