Revision Intersect Mutable Object

Question

Ich habe versucht, eine veränderbare Funktion mit Schnittpunkt zu machen, aber ich denke, ich vermassle es mit der Implementierung von Schnittpunkt in die Funktion und bin mir nicht sicher über den besten Weg, um die Funktion zu reparieren.

>(intersection '(2 4 7 10) '(2 9 0 10)) 
(2 10) 
>(intersection '(1 4 10) '(83 1 48 2 4)) 
(1 4) 

Testfälle für den Einsatz:

(define (intersect-mutable) 
    (let ((lst '())) 
    (let ((lst2 '())) 
     (define (insert x) 
     (set! lst (cons x lst))) 
     (define (intersect) 
     (define (helper lst lst2) 
      (define contains member) 
      (cond ((null? set) '()) 
       ((contains (car lst) lst2) 
       (cons (car lst) (intersect (cdr lst) lst))) 
       (else 
       (intersect (cdr lst) lst2)))) 
     (helper lst lst2)) 
     (lambda (function) 
     (cond ((eq? function 'intersect) intersect) 
       ((eq? function 'insert) insert) 
       (else 
       'undefined)))))) 

Ein Testfall für die rekursive Funktion wäre

(define mut (intersect-mutable)) 
((mut 'insert) 'intersect) 
((mut 'insert) 'mutable) 

Um zu klären, ich versuche, zwei getrennte Listen in einer schneiden Liste. Ich habe eine Einfügefunktion hinzugefügt.

Answer 1

Verwenden Sie list->mlist, um eine Liste von unveränderlichen Cons-Zellen in eine Liste von Mutable-Cons (mcons-Zellen) umzuwandeln.

Sehen Sie hier mehr: docs

Answer 2

Wenn die Mutation nur die beiden Listen zu Housekeep ist:

(define (intersect-mutable (lst1 '()) (lst2 '())) 
    (define (method-insert lst1? value) 
    (if lst1? 
     (set! lst1 (cons value lst1)) 
     (set! lst2 (cons value lst2))) 
    message-handler) 

    (define (method-intersect) 
    ;; intersect is a working intersect without mutation 
    (intersect lst1 lst2)) 

    (define (message-handler msg) 
    (case msg 
     ((insert) method-insert) 
     ((insert1) (lambda (v) (method-insert #t v))) 
     ((insert2) (lambda (v) (method-insert #f v))) 
     ((lst1) lst1) 
     ((lst2) lst2) 
     ((intersect) method-intersect) 
     (else (error "No such method" msg)))) 

    message-handler) 

(define obj (intersect-mutable '(10) '(30))) 
((obj 'insert) #t 5) 
((obj 'insert2) 10) 
(obj 'lst1) ; ==> (5 10) 
(obj 'lst2) ; ==> (10 30) 
((obj 'intersect)) ; ==> (10) 

jedoch Ankündigung, die nicht wirklich etwas mutieren nicht schneidet. Ich denke, vielleicht der ganze Punkt mit dieser OO ist so ich vorstellen, dass wir auf eine Liste wie diese arbeiten machen:

(define (list-object (lst '())) 
    (define (method-insert . values) 
    (set! lst (foldl cons lst values)) 
    message-handler) 

    (define (method-intersect lst2) 
    ;; intersect is a working intersect without mutation 
    (set! lst (intersect lst lst2)) 
    message-handler) 

    (define (method-member? value) 
    (member value lst)) 

    (define (message-handler msg) 
    (case msg 
     ((insert) method-insert) 
     ((intersect) method-intersect) 
     ((member?) method-member?) 
     ((lst) lst)    
     (else (error "No such method" msg)))) 

    message-handler) 

(define obj (((list-object '(5)) 'insert) 10 20 30)) 
(obj 'lst) ; ==> (30 20 10 5) 
((obj 'intersect) '(10 30 60)) 
(obj 'lst) ; ==> (20 30) 

Stellen Sie viele Objekte wie diese machen, dann können Sie (winzige) CLOS Art generische Methoden machen:

;; generic. Works on any object that has 
;; member? method and lists 
(define (member? value obj) 
    (if (procedure? obj) 
     ((obj 'member?) value) 
     (member value obj))) 


;; Another object type that has member? 
;; only that it means the values binary bits 
;; are set on the object 
(define (number-object value) 
    (define (method-member? value2) 
    (= value2 (bitwise-and value value2))) 

    (define (message-handler msg) 
    (case msg 
     ((member?) method-member?))) 

    message-handler) 

;; test objects 
(define num1 (number-object 24)) 
(define lst1 (list-object '(1 8))) 

;; some test 
(member? 2 num1); ==> #f 
(member? 8 num1); ==> #t 
(member? 8 lst1); ==> (8) (true) 
(member? 9 lst1); ==> #f 
(member? 9 '(1 3 5 9 10)) ; ==> (9 10) 

;; map is the ultimate test 
(map (lambda (o) (member? 8 o)) (list num1 lst1)) 
; ==> (#t (8))