Etapa 2 își propune exploatarea faptului că funcțiile sunt valori de ordinul întâi. Veți defini funcții curry, veți abstractiza funcții cu implementări similare, și veți folosi funcționale - atât implementări proprii, cât și funcționalele predefinite în Racket. Vă încurajăm să valorificați oportunitățile de utilizare a funcțiilor anonime și funcționalelor, inclusiv când enunțul nu impune acest lucru.

În această etapă, numărul de case din magazin nu mai este fixat. Avem:

• o listă fast-counters de case care acceptă doar clienți care au cumpărat maxim ITEMS produse
• o listă slow-counters de case deschise tuturor clienților

Pentru ca în viitor să putem determina ordinea ieșirii clienților din magazin, introducem un nou câmp în structura counter:

(define-struct counter (index tt et queue))

• et
  • vine de la “exit time”, și reprezintă timpul rămas până când primul client din coadă va părăsi această casă
  • depinde de numărul de produse cumpărate de acest client (1 produs = 1 minut) și de eventualele întârzieri suferite de casă

Simulatorul trebuie să modeleze atât situațiile de la etapa anterioară, cât și două noi situații:

• când cel mai avansat client (din punct de vedere al exit time-ului) părăsește magazinul
• când este necesară deschiderea unor noi case, pentru a micșora media timpilor totali de așteptare

Inițial, veți adapta o serie de funcții de la etapa 1 la noua reprezentare (adică la numărul variabil de case și la prezența câmpului et în structură).

Apoi, funcțiile principale pe care va trebui să le implementați sunt:

(update f counters index)

• update aplică transformarea f casei din counters care are indexul index, și întoarce lista counters actualizată

Exemplu:

(update (λ (C) (struct-copy counter C [tt 0]))
        (list (counter 1 2 2 '()) (counter 2 5 5 '()))
        2)

⇒

(list (counter 1 2 2 '()) (counter 2 0 5 '()))

(remove-first-from-counter C)

• remove-first-from-counter scoate prima persoană din coada casei C
• tt-ul și et-ul casei C trebuie ajustate în consecință
  • orice întârziere avea casa, ea dispare
  • dispar produsele clientului care pleacă (și minutele asociate acestora)
  • nicio altă casă nu este afectată (este ca și cum ar fi trecut timpul doar pe la casa C; acest lucru se va schimba în etapa 3)

Exemplu:

(remove-first-from-counter (counter 1 50 5 '((ana . 3) (leo . 35) (mia . 10))))

⇒

(counter 1 45 35 '((leo . 35) (mia . 10)))

(serve requests fast-counters slow-counters)

• serve primește o listă de cereri (așezări la coadă, întârzieri, ieșiri de la casă, ajustări ale numărului de case) și le tratează în ordine, în sensul că actualizează casele din fast-counters și slow-counters pe măsură ce situația lor evoluează

Exemplu (pentru ITEMS = 5):

(serve '((ana 8) (mia 2) (mara 14) (ion 7) (remove-first) (ensure 5) (remove-first))
       (list (empty-counter 1) (empty-counter 2))
       (list (empty-counter 3) (empty-counter 4)))

• observăm că avem două case fast (pentru simplitate le numim C1 și C2) și două case slow (le numim C3 și C4)
• primele 4 cereri distribuie cei 4 clienți astfel:
  • ana la C3 (prima casă slow cu tt=0) ⇒ C3 = (counter 3 8 8 '((ana . 8)))
  • mia la C1 (prima casă fast cu tt=0) ⇒ C1 = (counter 1 2 2 '((mia . 2)))
  • mara la C4 (casa slow cu tt minim) ⇒ C4 = (counter 4 14 14 '((mara . 14)))
  • ion la C3 (casa slow cu tt minim) ⇒ C3 = (counter 3 15 8 '((ana . 8) (ion . 7)))
• remove-first scoate cel mai avansat client:
  • cel mai avansat client este mia (et=2)
  • ea este scoasă de la C1 ⇒ C1 = (counter 1 0 0 '()) (observați tt și et)
• ensure compară media timpilor totali cu 5:
  • tt1 + tt2 + tt3 + tt4 = 0 + 0 + 15 + 14 = 29 ⇒ ttmed = 29 / 4 > 5
  • se adaugă o casă slow goală (C5) ⇒ ttmed = 29 / 5 > 5
  • se adaugă o casă slow goală (C6) ⇒ ttmed = 29 / 6 ≤ 5 (deci putem trece la cererea următoare)
• remove-first scoate cel mai avansat client:
  • cel mai avansat client este ana (et=8)
  • ea este scoasă de la C3 ⇒ C3 = (counter 3 7 7 '((ion . 7))) (observați tt și et)