sicp-ex-3.4

This solution won't work because when call-the-cops returns a string literal, there will be a object not applicable error since a parameter amount is provided to it. "Wrong password" has the same problem.

We should wrap these in a lambda function that accepts an input.

Besides what Shawn mentioned, this solution also has a logic error. It will actually invoke the "call-the-copes" function when there's more than 8 wrong inputs in a row, instead of 7.

  
  
  
 (define (make-accumulator acc) 
   (lambda (x)  
     (set! acc (+ acc x)) 
     acc)) 
  
  
 (define (make-account balance secret-password) 
   (define (call-the-cops) "The cops have been caled!") 
   (define attempts (make-accumulator 0)) 
   (define (attempts-made) (attempts 0)) 
   (define (reset-attempts) (attempts (- (attempts 0)))) 
    
   (define (is-correct-password? password) 
    (cond ((equal? secret-password password) 
           (reset-attempts) true) 
           (else (attempts 1)  
                 false))) 
    
   (define (withdraw amount) 
     (cond ((>= balance amount) 
            (set! balance (- balance amount)) 
            balance) 
           (else  
            "Insufficient funds"))) 
   
    
   (define (deposit amount) 
     (set! balance (+ balance amount)) 
     balance) 
    
   (define (dispatch password m) 
     (cond ((not (is-correct-password? password)) 
            (if (> (attempts-made) 7) 
                (lambda (x) (call-the-cops)) 
                (lambda (x) "Incorrect password"))) 
           ((equal? m 'withdraw) withdraw) 
           ((equal? m 'deposit) deposit) 
           (else (error "Unknown request: MAKE-ACCOUNT" m)))) 
   dispatch) 

I put all the password-checking functionality into a separate internal function called correct-password?. Unfortunately my implementation of scheme does not know how to (call-the-cops).

 (define (make-account balance password) 
   (define bad-password-count 0) 
   (define (correct-password? p) 
     (if (eq? p password) 
         (set! bad-password-count 0) 
         (begin 
           (if (= bad-password-count 7) 
               (call-the-cops) 
               (set! bad-password-count (+ bad-password-count 1))) 
           (display "Incorrect password") 
           #f))) 
   (define (withdraw amount) 
     (if (>= balance amount) 
         (begin (set! balance (- balance amount)) 
                balance) 
         "Insufficient funds")) 
   (define (deposit amount) 
     (set! balance (+ balance amount)) 
     balance) 
   (define (dispatch p m) 
     (if (correct-password? p) 
         (cond 
           ((eq? m 'withdraw) withdraw) 
           ((eq? m 'deposit) deposit) 
           (else (error "Unknown request -- MAKE-ACCOUNT" m))) 
         (lambda (x) (display "")))) 
   dispatch) 

I wrapped dispatch in a function that handles the password checking. It keeps dispatch much cleaner.

 (define (make-account password balance) 
   (define (withdraw amount) 
     (if (>= balance amount) 
         (begin (set! balance (- balance amount)) 
                balance) 
         "Insufficient funds")) 
   (define (deposit amount) 
     (set! balance (+ balance amount)) 
     balance) 
   (define (dispatch m) 
     (cond ((eq? m 'withdraw) withdraw) 
           ((eq? m 'deposit) deposit) 
           (else (error "Unknown request -- MAKE-ACCOUNT" 
                        m)))) 
   (password-protect password dispatch)) 
  
 (define (password-protect user-password f) 
   (define invalid-attempts 0) 
   (lambda (password m) 
     (cond [(= invalid-attempts 7) 
            (call-the-cops)] 
           [(eq? password user-password) 
            (set! invalid-attempts 0) 
            (f m)] 
           [else 
            (set! invalid-attempts (+ 1 invalid-attempts)) 
            (error "Incorrect password")]))) 
  
 (define (call-the-cops) 
   (error "The cops have been called!")) 
  

My implementation is much simpler. I just wrap the dispatch function with an "auth-layer" function, which will do the authentication. Then I wrap the "auth-layer" function with a "secure-layer", which will check the error counter and decide to call the cops or not.

 (define (secure-make-account balance password) 
  
   (define error-count 0) 
  
   (define (call-the-police) "Too much errors, we have called LAPD") 
    
   (define (withdraw amount) 
     (if (>= balance amount) 
         (begin (set! balance (- balance amount)) balance) 
         "Insufficient funds")) 
    
   (define (deposit amount) 
     (set! balance (+ balance amount)) balance) 
    
   (define (dispatch m) 
     (cond  ((eq? m 'withdraw) withdraw) 
            ((eq? m 'deposit) deposit) 
            (else (error "Unknown request -- MAKE-ACCOUNT" m))) 
     ) 
  
   (define (auth-layer pass m) 
     (if (eq? pass password) 
         (dispatch m) 
         (lambda (x) (begin (set! error-count (+ 1 error-count)) 
                            "Incorrect password")))) 
   (define (secure-layer pass m) 
     (if (= 2 error-count) 
         (lambda (x) (call-the-police)) 
         (auth-layer pass m))) 
    
   secure-layer) 

  
  
  
  
 (load "make-monitored.scm") 
  
 (define (make-account balance password) 
  
     (define (withdraw amount) 
         (if (>= balance amount) 
             (begin 
                 (set! balance (- balance amount)) 
                 balance) 
             "insufficient funds")) 
  
     (define (deposit amount) 
         (set! balance (+ balance amount)) 
         balance) 
  
     (define (call-the-cops) "We have already called the police for your actions.") 
  
     (define (password-errors-logic monitored) 
         (lambda (m) 
             (let ((wrong-times (monitored 'how-many-calls?))) 
                 (if (= wrong-times 6) 
                     (begin 
                         (monitored 'reset-count) 
                         (call-the-cops)) 
                     (monitored 
                         (if (eq? m 'reset-count) 
                             'reset-count 
                             (- 6 wrong-times))))))) 
  
     (define counter 
         (password-errors-logic 
             (make-monitored 
                 (lambda (m) 
                     (string-append 
                         "Incorrect password: " 
                         "You can still enter " 
                         (number->string m) 
                         " wrong times."))))) 
  
     (define (dispatch p m) 
         (if (eq? p password) 
             (begin 
                 (counter 'reset-count) 
                 (cond ((eq? m 'withdraw) withdraw) 
                     ((eq? m 'deposit) deposit) 
                     (else (error "unknown request -- MAKE-ACCOUNT" m)))) 
             counter)) 
      
     dispatch) 
  
  

My solution is not so original but it's plain and simple.

  
 (define (make-account balance password) 
  
   (define psswd password) 
  
   (define lock 0) 
    
   (define (count-incorrect-password amount) 
     (begin (set! lock (+ lock 1)) 
            (display "Incorrect password") 
            (newline))) 
  
   (define (call-the-cops amount) 
     (error "Bee-boo Bee-boo Bee-boo")) 
  
   (define (withdraw amount) 
     (if (>= balance amount) 
         (begin (set! balance  
                      (- balance amount)) 
                balance) 
         "Insufficient funds")) 
   (define (deposit amount) 
     (set! balance (+ balance amount)) 
     balance) 
    
   (define (dispatch pw m) 
     (cond [(eq? pw psswd) 
            (cond ((eq? m 'withdraw) withdraw) 
                  ((eq? m 'deposit) deposit) 
                  (else (error "Unknown request:  
                  MAKE-ACCOUNT" m)))] 
           [else 
            (cond [(>= lock 6) call-the-cops] 
                  [else count-incorrect-password])])) 
    
   dispatch)