Implementierungsvielfalt

feat. higher-order Varianten

Disclaimer: Dieser Thread wurde aus dem alten Forum importiert. Daher werden eventuell nicht alle Formatierungen richtig angezeigt. Der ursprüngliche Thread beginnt im zweiten Post dieses Threads.

Implementierungsvielfalt
Wollte mal fragen ob Bedarf für “schöne”/“generische”/“elegante”/meinLieblingsAttribut Implementierungen von whatever besteht.
Bezieht sich jetzt auf Scheme und Prolog.
Den Musterlösungen kann ich persönlich zB so garnichts abgewinnen. Muss man ja froh sein wenn sie überhaupt mal map und Co (von higher-order Prädikaten in Prolog hab ich von ihnen mal so garnichts gesehen) benutzen. :>


Ich zerbrech mir gerade den Kopf ueber den Y-Combinator

(define Y
    (lambda (X)
      ((lambda (procedure)
         (X (lambda (arg) ((procedure procedure) arg))))
       (lambda (procedure)
         (X (lambda (arg) ((procedure procedure) arg)))))))

http://www.ececs.uc.edu/~franco/C511/html/Scheme/ycomb.html

Darauf gestossen bin ich im Seasoned Schemer darein muss du gucken wenn du schoenen sehen willst :wink:

Jetzt bist du dran uns was zu zeigen :-p


Willst du was bestimmtes wissen?

(define Y
    (lambda (X)
      ((lambda (procedure)
         (X (lambda (arg) ((procedure procedure) arg))))
       (lambda (procedure)
         (X (lambda (arg) ((procedure procedure) arg)))))))

ist übrigens der applikative der in der Literatur oftmals als Z bezeichnet wird und durch eta-Expansion aus Y entsteht.
Hier mal in mathematischer Schreibweise Y=λf.(λg.g g)(λg. f (g g)) Z=λf.(λg.g g)(λg.λx.f (g g) x), finde ich leichter zum „Rechnen“.
Mir hats immer geholfen ein paar beta-Reduktionen zu machen um mich wieder mit der Funktionsweise vertraut zu machen.

(define Z
    (lambda (f)
      ((lambda (g) (g g))
       (lambda (g) (lambda (x) ((f (g g)) x))))))

wäre vllt ein bisschen „handlicher“. Bei den langen Namen verliere ich immer leicht die Struktur aus den Augen. ^^

Um was gehts dir? Was konkretes?

BTW: sieht so aus als hättest du tiefergehendes Interesse an Scheme. Lass mich wissen wenn du Literaturbedarf oder so hast. :>


Nichts bestimmtes, mir ist nur gerade ein wenig schwindlig, ich glaube ich gruebel morgen weiter :wink:

nee nix konkretes, irgendwas was man an die wand haengen, sich zuruecklegen und dabei „oh wie ist das schoen“ denken kann :smiley:

hehe mein Schrank mit Buechern, die ich englich mal lesen will quillt langsam ueber. da steht z.b. on lisp von paul graham, paradigms of ai programming in common lisp von peter norvig, the haskell road to logic, math and programming von kees doets,…

Was wuerdest du mir denn empfehlen?


Das ist schon beinahe symptomatisch. Bin mittlerweile ersthaft am überlegen so Organisationssoftware für Bücher, Papers, Journals, Zitate, Referenzen usw zu nutzen. Schlimm was sich da alles ansammelt, verliert man leicht den Überblick. :>

Noch sowas wie ne Warnung: nicht zuviel auf Grahams Meinung geben (aber technisch gesehen ist On Lisp nicht schlecht), er stellt viele Sachen in nem sehr subjektiven Licht dar. Rest hab ich persönlich nicht richtig gelesen („paradigms of ai“ überflogen, gibt nen relativ guten Programmierstil vor und zeigt Anwendungen auf die man erstmal so nicht gekommen wäre, „Wow-Effekt“), aber viel gutes drüber gehört.

Je nachdem wie nah du der der „Theorie“ (nicht so schlimm wie es zunächst mal klingt, vieles geht mehr in Richtung SoftwareEngineering oder mathematische DesignPatterns wenn man so will) verbunden sein willst/bist, wäre es entweder ne gute Sache Haskell zu lernen (hier trifft sich quasi Theorie und Praxis, man hat gleich schöne Anwendungen, Leitmotiv „hard things easy, the impossible just happened“ ;D), oder erstmal Scheme zu „hacken“ (sag ich mal so weil es oftmals weniger diszipliniert, dafür sehr kreativ, flexibel, teilweise auch einfach nur krass kommt; hands-on Metaprogramming wenn du so willst, „Compiler zum anfassen“).
Entsprechende Bücher wären eben „Haskell School of Expression“ und Co (weiß ehrlich gesagt nicht wie das im Vergleich zu „Road to Logic“ ist, denke aber nach den Beschreibungen das „Road to Logic“ mehr reisst; hier gibts ne ganze Sammlung: Books and tutorials - HaskellWiki), oder für Scheme die LittleSchemer-Reihe („liest“ sich ja recht schnell, man kommt sich aber nicht immer „erleuchtet“ vor, viel Redundanz), klassisch SICP, Essentials of Programming Languages und der ganze Kram. Würde sagen SICP hat die höchste Informationsdichte, danach bist du für den normalen Scheme-„alltag“ gewappnet, fehlen halt noch Macros. Und hier wirds auch schon schwer: ein „On Lisp“ für Scheme hab ich noch nicht gesehen, das beste Metaprogramming kriegste wohl immernoch durch Papers und „klassische“ Hacks von lokalen Berühmtheiten (schonmal von Oleg gehört? :>) drauf.
www.lambda-the-ultimate.org ist für alles rund um Programmiersprachentheorie der ideale Ort. Mit etwas Glück kannste sogar direkt mit Autoren reden. Hat meinen Horizont nochmal enorm erweitert und tut es noch!