#lost · 2017-04-06

242 Nachrichten · Seite 1 von 2 · Original-CSV herunterladen

  1. Svenskagn8
  2. kevinAntoine: Hast du das Lowlevel-Wiki kaputtgemacht oder hat sich das selber zerlegt?
  3. MasterQ32morgen
  4. XanClicmoin moin
  5. MasterQ32const f = fn(x:int) with x >= 0 { };
  6. MasterQ32const f = fn(x:int) where x >= 0 { };
  7. MasterQ32const f = fn(x:int) having x >= 0 { };
  8. MasterQ32ich weiß, schon wieder wortwahl-fragen
  9. MasterQ32das ganze geht um eine restriction auf parameter und rückgabewert
  10. XanClicich mag ja das zweite
  11. MasterQ32war auch mein erster gedanke, fand `with` aber auch nicht schlecht
  12. XanClicwobei andere Sprachen auch “require” und “ensure” haben, wenn ich mich recht entsinne
  13. XanClicalso require für das, was Parameter sein müssen und ensure dafür, was der Rückgabewert sein wird, oder so
  14. MasterQ32hmm
  15. XanClicmüsste jetzt die Eiffelspezifikation rauskramen und das will ich nicht
  16. MasterQ32:D
  17. MasterQ32fn(x:int) requires x >= 0 ensures ???<=0
  18. XanClichttps://archive.eiffel.com/doc/online/eiffel50/intro/language/invitation-07.html
  19. MasterQ32hm, da war ich jetzt auch schon
  20. MasterQ32mein `where` wäre ja dann `require`
  21. XanClicjo
  22. MasterQ32ensure gilt ja hier aber nicht konkret auf den rückgabewert, sondern eher auf das objekt selbst
  23. MasterQ32worüber ich grade noch grüble:
  24. MasterQ32ich könnte eine reseriverte variable einführen, welche bei where als rückgabewert dient
  25. XanClicManche Programmiersprachen benutzen ja den Funktionsnamen als Rückgabewert
  26. XanClicAlso anstatt foo { return x } hat man dann foo { foo := x }
  27. MasterQ32finde ich grauenhaft :D
  28. XanClicOder wenn du return hast, dann ist return ja schon reserviert und du könntest ensure return >= 0 schreiben
  29. MasterQ32joar, war jetzt auch mein gedanke
  30. MasterQ32klingt sinnvoll, dann mach ich das mal
  31. MasterQ32wobei ich glaube, das "with" korrekter ist
  32. MasterQ32function with x larger zero
  33. MasterQ32ich bekomme grade noch folgenden vorschlag:
  34. MasterQ32fn(x:int) mumsaid x >= 0
  35. XanCliclolcode gibts aber schon
  36. MasterQ32jop
  37. MasterQ32HAI
  38. MasterQ32CAN I HAZ STDIO?
  39. MasterQ32KTHXBYE.
  40. 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.
  41. kevinWenn nicht, dann finde ich "requires" sinnvoller
  42. kevinWobei ich ja finde, dass "require" mit Konjunktiv benutzt gehört, also brauchst du eine Konjunktiv-Version der Vergleichsoperatoren *g*
  43. XanClic#define were
  44. XanClic#define was
  45. XanClicund dann kann man sich auch das grammatikalisch richtige aussuchen
  46. XanClicrequires x was >= 0
  47. XanClicAber ich kann kein Englisch
  48. XanClicoder #define to #define be; requires x to be >= 0
  49. XanClicOder ist bei den Vergleichsoperatoren das “is” schon eingebaut?
  50. kevinIch glaube schon
  51. kevinUnd das ich haben wollte, ist eher das
  52. kevin#define that #define be; requires that x be >= 0
  53. MasterQ32zum glück hab ich keinen präprozessor :D
  54. MasterQ32wisst ihr was?
  55. MasterQ32(WSO * (P"with" + P"where") * WS * V"exprlist")^-1
  56. MasterQ32das is mir jetzt zu doof :P
  57. MasterQ32with und where machen beide sinn, soll der coder halt selbst entscheiden :D
  58. XanClicthis is not okay
  59. kevinMasterQ32: Kann ich denn basierend auf diesen Einschränkungen Funktionen überladen?
  60. MasterQ32das ist die frage, die ich mir grade noch stelle
  61. MasterQ32was ist, wenn ich zwei funktionen schreibe, welche so aussehen:
  62. MasterQ32f(i:int) with x >= 0;
  63. MasterQ32f(i:int) with x <= 0;
  64. MasterQ32EDOMAIN?
  65. kevinUnd sind das Runtime-Checks oder willst du es statisch prüfbar machen?
  66. MasterQ32im moment ist alles als statischer check geplant
  67. kevinDann sind "überlappende" Funktionen einfach ein Compilerfehler
  68. MasterQ32joar, macht sinn
  69. MasterQ32das wird noch ein wahnsinn, den tatsächlichen typ von variablen nachzuverfolgen ^^
  70. kevinWie willst du das denn anstellen? Überall den möglichen Wertebereich mitschleppen?
  71. MasterQ32korrekt
  72. MasterQ32:D
  73. MasterQ32i hat aktuell die domain [-infty, +infty]
  74. MasterQ32if(i >= 0) {
  75. MasterQ32 // i hat die domain [0,+infty]
  76. MasterQ32}
  77. kevinUnd wenn ich ein 'if x > 0 then ... ' mache, ist der Typ in diesem Block entsprechend eingeschränkt?
  78. MasterQ32korrekt
  79. MasterQ32damit sollten dir die ganzen restriktionen nur in grenzbereichen aufn sack gehen
  80. MasterQ32und genau da müssen sie es auch :D
  81. kevinUnd wenn ich 'if (x * y) > (z / 42)' mache? ;-)
  82. MasterQ32ach, wer braucht schon multiplikation?! :D
  83. MasterQ32so ein modernes konzept
  84. MasterQ32wird überbewertet :P
  85. kevinVielleicht wäre eher eine explizite Typprüfung sinnvoll wie halt in OO-Sprachen
  86. MasterQ32wie meinst?
  87. kevinif x is int[>= 0] konvertiert x innerhalb des Blocks, if x >= 0 nicht
  88. kevinIn ersterem brauchst vor dem 'is' eine lvalue, also keine Multiplikation oder sonstigen Mist
  89. kevinUnd letzteres bleibt konsistent ohne Magie
  90. kevins/konsistent/konsequent/
  91. MasterQ32hm
  92. MasterQ32ich denk drüber nach :)
  93. MasterQ32klingt auf jeden fall vernünftig und besser durchdacht als mein aktueller ansatz
  94. kevinVon der Theorie her ja, aber ich weiß nicht, wie nervig das in der Praxis wird
  95. MasterQ32was mir grade noch eingefallen ist:
  96. MasterQ32theoretisch kann ich ja auch einfach sagen
  97. MasterQ32if(x*y>0) {} // tut nix
  98. MasterQ32if(x > 0 && y > 0) // tut restrictions
  99. MasterQ32also comparisons der form (variable op constexpr) bzw. (constexpr op variable) erzeugen restrictions
  100. kevinJa, kannst du schon
  101. XanClicTheoretisch kannst du auch assertions vom Nutzer akzeptieren
  102. kevinMein Gefühl sagt aber -EMAGIC
  103. XanClicif x * y > z / 42 { assert(x < 23) }
  104. MasterQ32damit kann die assertion ja aber noch zu runtime failen
  105. MasterQ32if(restricted x > 0) { }
  106. MasterQ32restrict(x >= 0) { /*happy here*/ } else { /*sad here*/ }
  107. kevinHm, letzteres ist eine interessante Idee
  108. MasterQ32ist glaube ich das mit der geringsten magie und der höchsten lesbarkeit
  109. XanClicfn assert(x): ensures(x) { restrict(x) { return } else { abort } }
  110. XanClicdas war ja einfach
  111. MasterQ32ich hab assert auf language level
  112. MasterQ32assert x != 0;
  113. XanClicdann sollte das aber auch restricten
  114. MasterQ32restrict nimmt ne expressionlist, welche mit logisch und verknüpft wird, jede expr muss in einer statisch auswertbaren form vorliegen
  115. MasterQ32restrict(x > 0, y > 0) { }
  116. 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 ;-)
  117. MasterQ32hrhr :D
  118. MasterQ32ja, das frag ich mich grade auch
  119. MasterQ32durch die jetzige form von restrict erlaube ich ja nur einschnitte in der domäne
  120. MasterQ32der wertebereich wird also immer kleiner
  121. 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.
  122. MasterQ32naja, ich werds rausfinden, wie gut sich sowas tatsächlich umsetzen lässt
  123. MasterQ32ansonsten hab ich halt dieses fancyfeature nicht statisch, sondern muss das zu runtime prüfen
  124. kevinHm, hast du wirklich nur Einschnitte?
  125. MasterQ32restrict(x > 0, x < 0) // wait, what?
  126. MasterQ32ist halt die frage, ob man sowas verlaubt
  127. MasterQ32*erlaubt
  128. MasterQ32wenn ja, hab ich frögliches domänenwürfeln
  129. kevinconst f = fn(x:int) with x < 42 { x *= 2 };
  130. kevinCompilerfehler oder erweitert sich der Wertebereich?
  131. MasterQ32das with bezieht sich nur auf die parameterübergabe
  132. MasterQ32also zu übergabezeit muss gelten, dass x < 42
  133. kevinconst f = fn(x:int) with x < 42 { x *= 2; fn(x); };
  134. MasterQ32hm
  135. kevinOder ist x jetzt nur noch ein int und ich muss wieder von vorne prüfen, obwohl ich ja was drüber weiß
  136. kevinMein Code tut so natürlich eh nicht, aber angenommen er würde eine zweite Funktion mit x < 84 aufrufen
  137. kevinDas kann der Compiler ja ohne weitere Prüfung wissen, dass das tut
  138. MasterQ32ich hatte mir darüber tatsächlich schon mal gedanken gemacht
  139. XanClicdas ist ja wohl eindeutig ein Compilerfehler
  140. MasterQ32und meine damalige lösung für das problem war, dass ein typ nur <min,max> seiner domäne kennt
  141. MasterQ32wenn ich jetzt <min0,max0> mit <min1,max1> multipliziere, erhalte ich einen typ mit *bitte warten, felix denkt...*
  142. MasterQ32<min0 * min1, max0 * max1> ∀ min,max >= 0
  143. kevinFelix? Ich dachte Klaus? ;-)
  144. MasterQ32mit vorzeichen muss ich fallunterscheidung machen
  145. MasterQ32wüsste nicht, wann ich mich mal klaus genannt haben sollte ^^
  146. MasterQ32ich glaube, das ganze mit <min,max> durchzurechnen, sollte für die meisten fälle schon reichen
  147. kevinAm Mittwoch, 29. März 2017 15:34:16, behaupten meine Logs *g*
  148. MasterQ32achso ^^
  149. kevinUnd was, wenn meine Assertion x != 0 war? min/max decken das ja nicht wirklich ab.
  150. MasterQ32stimmt
  151. kevinHaben wir implizit eigentlich schon ein assert(will terminate) abgedeckt oder sind wir nur kurz davor? ;-)
  152. MasterQ32wie meinst?
  153. MasterQ32du meinst das halteproblem mit einbauen? :D
  154. MasterQ32also die haltelösung
  155. MasterQ32:D
  156. XanClicnur weil das Halteproblem nicht generell lösbar ist… :-P
  157. kevinEben, ich habe halt so den leisen Verdacht, dass das ganze Assertionsystem eventuell auch nicht generell lösbar ist ;-)
  158. MasterQ32kann schon sein
  159. XanClicIst es natürlich auch nicht
  160. MasterQ32ja, satz von rice und so ^^
  161. 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
  162. MasterQ32joar, das wäre jetzt auch meine lösung gewesen
  163. kevinDie Frage ist halt, welche nützliche Teilmenge man statisch erledigt bekommt
  164. XanClicUnd ansonsten kann man manche Sachen dann vielleicht leider nicht absichern
  165. kevinRuntime-Checks finde ich wesentlich weniger attraktiv als statische
  166. XanClicWer nicht
  167. MasterQ32<min,max>+0? dürfte für relativ viel reichen denke ich
  168. kevinAlle, die die Typisierung in Skriptsprachen toll finden?
  169. MasterQ32:D
  170. XanClicSkriptsprachen sind halt Skriptsprachen
  171. XanClicUnd Design by Contract ist ja nun allgemein nicht gerade neu
  172. kevinViele sinnvolle Sachen sind nicht wirklich neu und werden trotzdem nicht gemacht
  173. XanClicPfff nur weil du kein Eiffel machst
  174. XanClicIch würde jetzt gern ins Wiki gehen und den Satherartikel aufrufen, aber das Wiki ist ja leider kaputt
  175. kevinSo, und jetzt schaue ich mir das hier näher an: "Zusicherung >>ctx->external_disable_cnt > 0<< nicht erf?llt."
  176. kevinDoofe dynmaische Prüfungen
  177. kevinXanClic: Mein Antoine-Ping-Versuch hat noch nichts gebracht
  178. MasterQ32hmm
  179. MasterQ32ich glaube, ich versuch mich erst mal mit <min,max,0?>
  180. MasterQ32bekommt ein c-compiler (gcc, clang) es hin, c = add(a,b) mit add(a,b){return a+ b; } das ganze sinnvoll zu optimieren?
  181. kevinSollte er
  182. MasterQ32okay, gut :)
  183. MasterQ32wann löscht/dekonstruiert man so sachen wie refernenzen mit refcount?
  184. MasterQ32bzw. wann würdest du das machen?
  185. kevinWenn der Refcount auf 0 geht?
  186. MasterQ32genau
  187. MasterQ32der teil ist klar
  188. MasterQ32die frage war, WO/WANN das geschieht
  189. kevinWenn eine Referenz überschreieben wird oder out of scope geht, nehme ich an
  190. MasterQ32theoretisch brauch ich ja für jede instruktion ein eigenes scope für alle temporären werte
  191. MasterQ32damit funktionsparameter auch direkt nach dem aufruf dekonstruiert werden
  192. SommerSonneIt's been a loooong time...
  193. SommerSonneSchoen, tyndur mal wieder zu sehen
  194. kevinMoin
  195. SommerSonneServus kevin
  196. MasterQ32hey
  197. MasterQ32wer war das denn?
  198. kevinWer weiß?
  199. MasterQ32hey, ich rede grade via USB mit einem PDP8 :)
  200. MasterQ32Ich HASSE Fehler, bei denen man die Ursache nicht kennt