#lost · 2017-04-06
242 Nachrichten · Seite 1 von 2 · Original-CSV herunterladen
- Svenskagn8
- kevinAntoine: Hast du das Lowlevel-Wiki kaputtgemacht oder hat sich das selber zerlegt?
- MasterQ32morgen
- XanClicmoin moin
- MasterQ32const f = fn(x:int) with x >= 0 { };
- MasterQ32const f = fn(x:int) where x >= 0 { };
- MasterQ32const f = fn(x:int) having x >= 0 { };
- MasterQ32ich weiß, schon wieder wortwahl-fragen
- MasterQ32das ganze geht um eine restriction auf parameter und rückgabewert
- XanClicich mag ja das zweite
- MasterQ32war auch mein erster gedanke, fand `with` aber auch nicht schlecht
- XanClicwobei andere Sprachen auch “require” und “ensure” haben, wenn ich mich recht entsinne
- XanClicalso require für das, was Parameter sein müssen und ensure dafür, was der Rückgabewert sein wird, oder so
- MasterQ32hmm
- XanClicmüsste jetzt die Eiffelspezifikation rauskramen und das will ich nicht
- MasterQ32:D
- MasterQ32fn(x:int) requires x >= 0 ensures ???<=0
- XanClichttps://archive.eiffel.com/doc/online/eiffel50/intro/language/invitation-07.html
- MasterQ32hm, da war ich jetzt auch schon
- MasterQ32mein `where` wäre ja dann `require`
- XanClicjo
- MasterQ32ensure gilt ja hier aber nicht konkret auf den rückgabewert, sondern eher auf das objekt selbst
- MasterQ32worüber ich grade noch grüble:
- MasterQ32ich könnte eine reseriverte variable einführen, welche bei where als rückgabewert dient
- XanClicManche Programmiersprachen benutzen ja den Funktionsnamen als Rückgabewert
- XanClicAlso anstatt foo { return x } hat man dann foo { foo := x }
- MasterQ32finde ich grauenhaft :D
- XanClicOder wenn du return hast, dann ist return ja schon reserviert und du könntest ensure return >= 0 schreiben
- MasterQ32joar, war jetzt auch mein gedanke
- MasterQ32klingt sinnvoll, dann mach ich das mal
- MasterQ32wobei ich glaube, das "with" korrekter ist
- MasterQ32function with x larger zero
- MasterQ32ich bekomme grade noch folgenden vorschlag:
- MasterQ32fn(x:int) mumsaid x >= 0
- XanCliclolcode gibts aber schon
- MasterQ32jop
- MasterQ32HAI
- MasterQ32CAN I HAZ STDIO?
- MasterQ32KTHXBYE.
- kevinBei "with" würde ich erwarten, dass ich eine Funktion with x >= 0 und gleichzeitig eine with x < 0 definieren kann und das dann das richtige tut.
- kevinWenn nicht, dann finde ich "requires" sinnvoller
- kevinWobei ich ja finde, dass "require" mit Konjunktiv benutzt gehört, also brauchst du eine Konjunktiv-Version der Vergleichsoperatoren *g*
- XanClic#define were
- XanClic#define was
- XanClicund dann kann man sich auch das grammatikalisch richtige aussuchen
- XanClicrequires x was >= 0
- XanClicAber ich kann kein Englisch
- XanClicoder #define to #define be; requires x to be >= 0
- XanClicOder ist bei den Vergleichsoperatoren das “is” schon eingebaut?
- kevinIch glaube schon
- kevinUnd das ich haben wollte, ist eher das
- kevin#define that #define be; requires that x be >= 0
- MasterQ32zum glück hab ich keinen präprozessor :D
- MasterQ32wisst ihr was?
- MasterQ32(WSO * (P"with" + P"where") * WS * V"exprlist")^-1
- MasterQ32das is mir jetzt zu doof :P
- MasterQ32with und where machen beide sinn, soll der coder halt selbst entscheiden :D
- XanClicthis is not okay
- kevinMasterQ32: Kann ich denn basierend auf diesen Einschränkungen Funktionen überladen?
- MasterQ32das ist die frage, die ich mir grade noch stelle
- MasterQ32was ist, wenn ich zwei funktionen schreibe, welche so aussehen:
- MasterQ32f(i:int) with x >= 0;
- MasterQ32f(i:int) with x <= 0;
- MasterQ32EDOMAIN?
- kevinUnd sind das Runtime-Checks oder willst du es statisch prüfbar machen?
- MasterQ32im moment ist alles als statischer check geplant
- kevinDann sind "überlappende" Funktionen einfach ein Compilerfehler
- MasterQ32joar, macht sinn
- MasterQ32das wird noch ein wahnsinn, den tatsächlichen typ von variablen nachzuverfolgen ^^
- kevinWie willst du das denn anstellen? Überall den möglichen Wertebereich mitschleppen?
- MasterQ32korrekt
- MasterQ32:D
- MasterQ32i hat aktuell die domain [-infty, +infty]
- MasterQ32if(i >= 0) {
- MasterQ32 // i hat die domain [0,+infty]
- MasterQ32}
- kevinUnd wenn ich ein 'if x > 0 then ... ' mache, ist der Typ in diesem Block entsprechend eingeschränkt?
- MasterQ32korrekt
- MasterQ32damit sollten dir die ganzen restriktionen nur in grenzbereichen aufn sack gehen
- MasterQ32und genau da müssen sie es auch :D
- kevinUnd wenn ich 'if (x * y) > (z / 42)' mache? ;-)
- MasterQ32ach, wer braucht schon multiplikation?! :D
- MasterQ32so ein modernes konzept
- MasterQ32wird überbewertet :P
- kevinVielleicht wäre eher eine explizite Typprüfung sinnvoll wie halt in OO-Sprachen
- MasterQ32wie meinst?
- kevinif x is int[>= 0] konvertiert x innerhalb des Blocks, if x >= 0 nicht
- kevinIn ersterem brauchst vor dem 'is' eine lvalue, also keine Multiplikation oder sonstigen Mist
- kevinUnd letzteres bleibt konsistent ohne Magie
- kevins/konsistent/konsequent/
- MasterQ32hm
- MasterQ32ich denk drüber nach :)
- MasterQ32klingt auf jeden fall vernünftig und besser durchdacht als mein aktueller ansatz
- kevinVon der Theorie her ja, aber ich weiß nicht, wie nervig das in der Praxis wird
- MasterQ32was mir grade noch eingefallen ist:
- MasterQ32theoretisch kann ich ja auch einfach sagen
- MasterQ32if(x*y>0) {} // tut nix
- MasterQ32if(x > 0 && y > 0) // tut restrictions
- MasterQ32also comparisons der form (variable op constexpr) bzw. (constexpr op variable) erzeugen restrictions
- kevinJa, kannst du schon
- XanClicTheoretisch kannst du auch assertions vom Nutzer akzeptieren
- kevinMein Gefühl sagt aber -EMAGIC
- XanClicif x * y > z / 42 { assert(x < 23) }
- MasterQ32damit kann die assertion ja aber noch zu runtime failen
- MasterQ32if(restricted x > 0) { }
- MasterQ32restrict(x >= 0) { /*happy here*/ } else { /*sad here*/ }
- kevinHm, letzteres ist eine interessante Idee
- MasterQ32ist glaube ich das mit der geringsten magie und der höchsten lesbarkeit
- XanClicfn assert(x): ensures(x) { restrict(x) { return } else { abort } }
- XanClicdas war ja einfach
- MasterQ32ich hab assert auf language level
- MasterQ32assert x != 0;
- XanClicdann sollte das aber auch restricten
- MasterQ32restrict nimmt ne expressionlist, welche mit logisch und verknüpft wird, jede expr muss in einer statisch auswertbaren form vorliegen
- MasterQ32restrict(x > 0, y > 0) { }
- kevinIch frage mich nur, wie komplex deine Typen werden können und ob du die komplette Liste an Bedingungen dem Benutzer vor die Füße kotzen willst, wenn ein Typname in die Fehlermeldung muss ;-)
- MasterQ32hrhr :D
- MasterQ32ja, das frag ich mich grade auch
- MasterQ32durch die jetzige form von restrict erlaube ich ja nur einschnitte in der domäne
- MasterQ32der wertebereich wird also immer kleiner
- kevinVor allem, wenn man mal nicht auf eine Konstante testen will, sondern mit anderen Variablen vergleichen. Wobei das dann schon nicht mehr wirklich unter Typ läuft.
- MasterQ32naja, ich werds rausfinden, wie gut sich sowas tatsächlich umsetzen lässt
- MasterQ32ansonsten hab ich halt dieses fancyfeature nicht statisch, sondern muss das zu runtime prüfen
- kevinHm, hast du wirklich nur Einschnitte?
- MasterQ32restrict(x > 0, x < 0) // wait, what?
- MasterQ32ist halt die frage, ob man sowas verlaubt
- MasterQ32*erlaubt
- MasterQ32wenn ja, hab ich frögliches domänenwürfeln
- kevinconst f = fn(x:int) with x < 42 { x *= 2 };
- kevinCompilerfehler oder erweitert sich der Wertebereich?
- MasterQ32das with bezieht sich nur auf die parameterübergabe
- MasterQ32also zu übergabezeit muss gelten, dass x < 42
- kevinconst f = fn(x:int) with x < 42 { x *= 2; fn(x); };
- MasterQ32hm
- kevinOder ist x jetzt nur noch ein int und ich muss wieder von vorne prüfen, obwohl ich ja was drüber weiß
- kevinMein Code tut so natürlich eh nicht, aber angenommen er würde eine zweite Funktion mit x < 84 aufrufen
- kevinDas kann der Compiler ja ohne weitere Prüfung wissen, dass das tut
- MasterQ32ich hatte mir darüber tatsächlich schon mal gedanken gemacht
- XanClicdas ist ja wohl eindeutig ein Compilerfehler
- MasterQ32und meine damalige lösung für das problem war, dass ein typ nur <min,max> seiner domäne kennt
- MasterQ32wenn ich jetzt <min0,max0> mit <min1,max1> multipliziere, erhalte ich einen typ mit *bitte warten, felix denkt...*
- MasterQ32<min0 * min1, max0 * max1> ∀ min,max >= 0
- kevinFelix? Ich dachte Klaus? ;-)
- MasterQ32mit vorzeichen muss ich fallunterscheidung machen
- MasterQ32wüsste nicht, wann ich mich mal klaus genannt haben sollte ^^
- MasterQ32ich glaube, das ganze mit <min,max> durchzurechnen, sollte für die meisten fälle schon reichen
- kevinAm Mittwoch, 29. März 2017 15:34:16, behaupten meine Logs *g*
- MasterQ32achso ^^
- kevinUnd was, wenn meine Assertion x != 0 war? min/max decken das ja nicht wirklich ab.
- MasterQ32stimmt
- kevinHaben wir implizit eigentlich schon ein assert(will terminate) abgedeckt oder sind wir nur kurz davor? ;-)
- MasterQ32wie meinst?
- MasterQ32du meinst das halteproblem mit einbauen? :D
- MasterQ32also die haltelösung
- MasterQ32:D
- XanClicnur weil das Halteproblem nicht generell lösbar ist… :-P
- kevinEben, ich habe halt so den leisen Verdacht, dass das ganze Assertionsystem eventuell auch nicht generell lösbar ist ;-)
- MasterQ32kann schon sein
- XanClicIst es natürlich auch nicht
- MasterQ32ja, satz von rice und so ^^
- XanClicAber in erster Ebene kann man ja Probleme auf die Laufzeit verlagern, eben mit einem dynamischen assert(), das dann halt zur Laufzeit aborten könnte
- MasterQ32joar, das wäre jetzt auch meine lösung gewesen
- kevinDie Frage ist halt, welche nützliche Teilmenge man statisch erledigt bekommt
- XanClicUnd ansonsten kann man manche Sachen dann vielleicht leider nicht absichern
- kevinRuntime-Checks finde ich wesentlich weniger attraktiv als statische
- XanClicWer nicht
- MasterQ32<min,max>+0? dürfte für relativ viel reichen denke ich
- kevinAlle, die die Typisierung in Skriptsprachen toll finden?
- MasterQ32:D
- XanClicSkriptsprachen sind halt Skriptsprachen
- XanClicUnd Design by Contract ist ja nun allgemein nicht gerade neu
- kevinViele sinnvolle Sachen sind nicht wirklich neu und werden trotzdem nicht gemacht
- XanClicPfff nur weil du kein Eiffel machst
- XanClicIch würde jetzt gern ins Wiki gehen und den Satherartikel aufrufen, aber das Wiki ist ja leider kaputt
- kevinSo, und jetzt schaue ich mir das hier näher an: "Zusicherung >>ctx->external_disable_cnt > 0<< nicht erf?llt."
- kevinDoofe dynmaische Prüfungen
- kevinXanClic: Mein Antoine-Ping-Versuch hat noch nichts gebracht
- MasterQ32hmm
- MasterQ32ich glaube, ich versuch mich erst mal mit <min,max,0?>
- MasterQ32bekommt ein c-compiler (gcc, clang) es hin, c = add(a,b) mit add(a,b){return a+ b; } das ganze sinnvoll zu optimieren?
- kevinSollte er
- MasterQ32okay, gut :)
- MasterQ32wann löscht/dekonstruiert man so sachen wie refernenzen mit refcount?
- MasterQ32bzw. wann würdest du das machen?
- kevinWenn der Refcount auf 0 geht?
- MasterQ32genau
- MasterQ32der teil ist klar
- MasterQ32die frage war, WO/WANN das geschieht
- kevinWenn eine Referenz überschreieben wird oder out of scope geht, nehme ich an
- MasterQ32theoretisch brauch ich ja für jede instruktion ein eigenes scope für alle temporären werte
- MasterQ32damit funktionsparameter auch direkt nach dem aufruf dekonstruiert werden
- SommerSonneIt's been a loooong time...
- SommerSonneSchoen, tyndur mal wieder zu sehen
- kevinMoin
- SommerSonneServus kevin
- MasterQ32hey
- MasterQ32wer war das denn?
- kevinWer weiß?
- MasterQ32hey, ich rede grade via USB mit einem PDP8 :)
- MasterQ32Ich HASSE Fehler, bei denen man die Ursache nicht kennt