Jensek81
15.09.2020, 16:23
Ein Makro in Lisp schreiben?

Miau, miau, miau, ich bin 'ne Katze.😺

Nein, bin ich natürlich nicht. Aber ich fühl mich gerad' wie 'ne Katze, wenn ich mir meinen derzeitigen Kenntnisstand über Macros vor Augen führe. Folgende Aufgabe wurde uns in die Whiskas-Dose gestreut:

Schreiben Sie ein Makro zur Iteration über Listen mit folgender Syntax:

(for-each (<var> <some-list>)
  <body-expression*>)

Hinweise:* Starten Sie mit einer Beispielexpansion

(for-each (x (list 1 2 3))
  (print x))

könnte etwa folgenden Code generieren

(let ((list-var-123 (list 1 2 3)))
 (loop
    (when (null list-var-123)
      (return))
    (let ((x (first list-var-123)))
      (print x))
    (setf list-var-123 (rest list-var-123))))

Schreiben SIe eine Funktion translate

(defun translate (var list-expr &rest body)

 )

die diese Uebersetzung * automatisch macht, d.h.

(translate x (list 1 2 3) (print x))

 liefert den obigen code zurück. Benutzen Sie translate, um das Makro for-each zu definieren

Jetzt natürlich die 1-Millionen Eurofrage bei Günther Jauch: Wie schreibt man ein Makro zur Iteration von Listen. ich weiß, dass ein Makro sozusagen eine Meta-Sprache bei Lisp ist und eigene Lists-Comprehensions erstellt werden. Aber wie generiert man die Iteration und Translate-Funktion?

 ...zum Beitrag
Hilfreichste Antwort
von Vlatiha
24.05.2023, 16:13

Schon ein wenig her, aber ich versuche mich mal dran:

(for-each (i (list 1 2 3)) (write i) (terpri))

ist meine Eingabe, die das Macro übersetzen soll - das terpri dient nur dem Zeilenvorschub nach der Ausgabe. Ich habe mich mal dazu entschlossen, keine vorhandenen Schleifen-Befehle zu verwenden, sondern mit Rekursion zu arbeiten.

Das heißt, aus dem obigen soll etwas werden, das in etwa so aussieht:

(labels ((func-name (l)
            (when l
               (let ((i (car l)))
                   (write i)
                   (terpri))
               (func-name (cdr l)))))
   (func-name lst))

Da wird also die Funktion func-name mit der Liste aufgerufen. Solange die Liste nicht leer ist, wird das erste Element der Liste der Variablen i zugewiesen und die Befehle abgearbeitet. Anschließend ruft sich die Funktion rekursiv mit dem Rest der Liste (ohne das erste Element) auf, bis die Liste leer ist.

Ein Macro, dass dies bewerkstelligt könnte beispielsweise so aussehen:

(defmacro for-each(box &rest body)
  (destructuring-bind (var lst) box
    (let ((func-name (gensym)))
      `(labels ((,func-name (l)
		  (when l
		    (let ((,var (car l)))
		      ,@body)
		    (,func-name (cdr l)))))
	 (,func-name ,lst)))))

Wendet man den Befehl macroexpand auf dieses Beispiel an, dann erhält man:

(macroexpand '(for-each (i (list 1 2 3)) (write i) (terpri)))
(LABELS ((#:G557 (L)
           (WHEN L
             (LET ((I (CAR L)))
               (WRITE I)
               (TERPRI))
             (#:G557 (CDR L)))))
  (#:G557 (LIST 1 2 3)))

Schön zu sehen ist hier, wie der Name der Funktion durch das gensym automatisch gewählt wird.

Was du allerdings mit dem translate meinst, habe ich nicht ganz begriffen. Vielleicht kannst du das nochmal genauer erläutern?

Vlati

 ...zur Antwort
BillyBoneless
24.04.2014, 14:20
grundlegendes Haskell-Tupel problem

Hi ihr, wir fangen im studium nun mit Haskell an und ich habe noch einige startschwierigkeiten, kann mir jemand bitte hier helfen?

Aufgabe: Write a function 'splitStr' that takes an integer i and a string s and returns a tuple with two strings made up of the first i and the remaining n-i characters (where n is the length of s).

Mein Lösungsansatz: splitStr :: (int, sting) -> (String, String) splitStr n a = (take n a, drop n a)

wenn ich allerdings in cmd *Main> print (splitStr 5 "WurstBrot") bringt er mir: Not in scope: `splitStr´

Danke im Voraus, Luca

 ...zum Beitrag
Antwort
von Vlatiha
13.02.2017, 15:36

Hallo Luca,

ist zwar schon etwas älter, aber vielleicht hat ja noch jemand Probleme damit. Tatsächlich ist deine Lösung absolut richtig. Weshalb dein ghci sie nicht akzeptiert ist unklar:

Prelude> let  splitStr n a = (take n a, drop n a)

Prelude> print (splitStr 5 "WurstBrot")

("Wurst","Brot")

Vlati

 ...zur Antwort
hilfenoetig5
10.01.2017, 16:52
Listen in Haskell?

Es handelt sich um eine absolute Anfängerfrage, aber ich stehe vor folgendem Problem: Ich versuche in Haskell eine Funktion bzw ein Programm zu bauen, das zwei Listen miteinander verknüpft, allerdings reicht die zip-Funktion da nicht aus, da die Listen unterschiedlich lang sein können sollen und trotzdem abwechselnd die Elemente aus den zwei Listen genannt werden sollen. Bisher war meine Idee: verzahnen [x1..x0] [y1..y0] = [x1,y1 .. x0,y0] Dabei wird leider lediglich eine Exception geworfen. Hat jemand vielleicht Tipps zu Herangehensweise? :( :)

 ...zum Beitrag
Antwort
von Vlatiha
13.02.2017, 15:29

Dazu müsste man wissen, was passieren soll, wenn die eine Liste zu Ende ist? Du könntest auch eine rekursive Funktion bauen:

bla (a:as) (b:bs) = (a:b:(bla as bs))
bla [] b = b
bla a [] = a
bla [] [] = []

Solange also a und b noch nicht zu Ende sind, nimmt er ein a und ein b und hängt dann den Rest rekursiv dran. Ist a oder b zu Ende, hängt er b oder a komplett dran. Sind beide zu Ende, wird nichts angehängt.

Vlati

 ...zur Antwort