Schema

Mr. N

Ne, nich XML Schema :p. Scheme. Folgender Code (-sammlung):

(define avg
  (lambda x
    (letrec ((sum (lambda (result list)
                    (if (null? list)
                      result
                      (sum (+ result (car list)) (cdr list))))))
      (/ (sum 0 x) (length x)))))

(define != (lambda (x y) (not (= x y))))

(define pythagoras
  (lambda (x y) (sqrt (+ (* x x) (* y y)))))

(define min2
  (lambda (x y z)
    (cond ((and (< x z) (< y z)) (list x y))
          ((and (< x y) (< z y)) (list x z))
          (else (list y z)))))

(define pythagoras-triple-correct
  (lambda (x y z)
    (let ((m2 (min2 x y z)))
      (cons (apply pythagoras m2) m2))))

(define coord
  (lambda (x y)
    (lambda a
      (if (null? a)
        (cons x y)
        (let ((msg (car a)) (params (cdr a)))
          (case msg
            ((x) x)
            ((y) y)
            ((set-x!) (set! x (car params)))
            ((set-y!) (set! y (car params)))
            ((set!)
             (begin
               (set! x (car params))
               (set! y (cadr params))))
            ((display)
             (begin
               (display #\()
               (display x)
               (display #\,)
               (display y)
               (display #\))))))))))

(define coord2
  (lambda (x y)
    (lambda (id)
      (case id
        ((x) x)
        ((y) y)
        ((x'y) (cons x y))
        ((set-x!) (lambda (v) (set! x v)))
        ((set-y!) (lambda (v) (set! y v)))))))

(use-syntax (ice-9 syncase))

(define-syntax
  func
  (syntax-rules
    (with-return with-recursion)
    ((func args body) (lambda args body))
    ((func args with-return r body)
     (lambda args
       (call-with-current-continuation
         (lambda (r) body))))
    ((func args with-recursion n body)
     (letrec ((n (lambda args body))) n))
    ((func args with-recursion n with-return r body)
     (letrec ((n (lambda args
                   (call-with-current-continuation
                     (lambda (r) body)))))
       n))))

(define bla
  (func (x . y)
        with-recursion
        r
        (if (null? y) x (apply r y))))

Hab ich Scheme verstanden?

Daniel E.

Original erstellt von Mr. N:
**```
(define avg
...

Ich nehme an, Du willst alle Elemente einer Liste aufaddieren und das Resultat durch die Anzahl der Elemente dividieren?

(define avg                            ; (define (avg lst) ...
  (lambda (lst)
    (/ (apply + lst) (length lst))))

Was genau die coord-Funktionen machen sollen, hat sich mir nicht erschlossen. Könnte daran liegen, dass alle Variablen bei dir x oder y heißen (oder an meinem derzeitigen Zustand :)). Das ist generell ein Problem, bei so allgemeinen Funktionen.

(use-syntax (ice-9 syncase))

Was macht das?

Mr. N

Original erstellt von Daniel E.:
Ich nehme an, Du willst alle Elemente einer Liste aufaddieren und das Resultat durch die Anzahl der Elemente dividieren?
Jo.

**```
(define avg ; (define (avg lst) ...
(lambda (lst)
(/ (apply + lst) (length lst))))
Hätte noch sagen sollen, dass das ne Übung zur Benutzung von letrec war.  
  
**Was genau die coord-Funktionen machen sollen, hat sich mir nicht erschlossen. Könnte daran liegen, dass alle Variablen bei dir x oder y heißen (oder an meinem derzeitigen Zustand ). Das ist generell ein Problem, bei so allgemeinen Funktionen.[/b]**  
Coord macht folgendes: Es konstruiert ein Objekt mit 2 Membern: x und y. Also eine *Coord*inate...  
  
**(use-syntax (ice-9 syncase))  
Was macht das?**  
Das schaltet (ich benutz guile) define-syntax, syntax-rules etc. ein.