Fizzbuzz x Monoïd

fizzbuzzoid.rkt

(require rackunit)

;;;
;; Problème avec notre définition actuelle :
 
(check-equal? (plus "fizz" 1) ;; définition de 'plus pour "fizz"
              4)

(check-equal? (plus 8 1) ;; résultat qui donne "fizz"
              "fizz")
 
;; Le pb : associativité, en contradiction avec les définitions ci-dessus
(check-equal? (plus (plus 8 1) 1)  ;; => (plus "fizz" 1) => 4 ?
              (plus 8 (plus 1 1))) ;; => (plus 8 2) => "buzz" ?

;;;
;; Proposition : changer l'ensemble d'application (et donc la loi de composition).

;; Si on appelle "Entiezz" l'ensemble {N U "fizz" U "buzz" U "fizzbuzz"} qu'on a choisi.
;; Au lieu de Entiezz, utiliser un sous ensemble S de N x Entiezz, ensemble des paires '(x . y)
;; telles que x soit un entier, et y soit égal à :
;; - "fizzbuzz" si x est multiple de 3 et 5,
;; - "fizz" si x est multiple de 3,
;; - "buzz" si x est multiple de 5,
;; - x dans tous les autres cas.

;; Exemples d'éléments de S :
;; - '(0 . "fizzbuzz"),
;; - '(1 . 1),
;; - '(2 . 2),
;; - '(3 . "fizz"),
;; - ...

;; Ensuite, définir la loi de composition interne 'plizz, qui prend comme arguments deux paires de S définit
;; ci-dessus et qui renvoit une paire de S.

;; Element neutre de 'plizz : '(0 . "fizzbuzz")

;; Exemples de tests :

(check-equal? (plizz '(0 . "fizzbuzz") '(0 . "fizzbuzz"))
              '(0 . "fizzbuzz"))

(check-equal? (plizz '(0 . "fizzbuzz") '(1 . 1))
              '(1 . 1))

(check-equal? (plizz '(1 . 1) '(1 . 1))
              '(2 . 2))

(check-equal? (plizz '(1 . 1) '(2 . 2))
              '(3 . "fizz"))

;; Et la contradiction initiale devient solvable :

(check-equal? (plizz '(3 . "fizz") '(1 . 1)) ;; définition de 'plizz pour '(3 . "fizz")
              '(4 . 4))

(check-equal? (plus '(8 . 8) '(1 . 1)) ;; résultat qui donne '(9 . "fizz")
              '(9 . "fizz"))

;; Associativité :
(check-equal? (plizz (plizz '(8 . 8) '(1 . 1)) '(1 . 1))  ;; => (plizz '(9 . "fizz") '(1 . 1)) => (10 . "buzz")
              (plizz '(8 . 8) (plizz '(1 . 1) '(1 . 1)))) ;; => (plizz '(8 . 8) '(2 . 2))      => (10 . "buzz")

Note : je crois que c'est ce que proposait Cyrille (travailler avec des tuples).

Voir https://gist.github.com/BernardNotarianni/c435b225d7a6861baf0e.