mixin: méthode a été référencé dans la définition, mais pas dans l'une des interfaces de-

Question

J'ai lu le guide de Racket 13.7.3 paramétrées Mixins

J'utilise paramétrées Mixins pour créer une classe good-eat-fish% de fish%

(define fish-interface 
    (interface() eat get-size)) 

(define fish% 
    (class* object% (fish-interface) 
    (init size) 
    (super-new) 
    (define current-size size) 
    (define/public (get-size) current-size) 
    (define/public (eat other) 
     (set! current-size (+ current-size (send other get-size)))))) 

(define (good-eat-mixin member-name) 
    (define eat member-name) 
    (mixin()() 
    (inherit eat) 
    (define/public (good-eat y) 
     (eat y) (eat y)))) 

(define good-eat-fish% 
    ((good-eat-mixin (member-name-key eat)) fish%)) 

Quand je lance le code l'erreur suivante est soulevée:

"mixin: method was referenced in definition, but is not in any of the from-interfaces 
    method name: eat 
    from-interfaces:" 

est-ce que ce message d'erreur indique qu'il n'y a pas eat méthode?

Si je change le code pour

(define (good-eat-mixin member-name) 
    (define eat member-name) 
    (mixin (interface() eat) (interface() eat good-eat) 
    (inherit eat) 
    (define/public (good-eat y) 
     (eat y) (eat y)))) 

Je reçois cette erreur:

interface: bad syntax in: interface 

Malheureusement, je ne sais pas pourquoi

interface() eat) 

est mauvaise syntaxe.

Answer 1

Pour le premier problème: les mixins appliquent quelques contrôles pour une mauvaise utilisation, et vous les traversez. Par exemple, si vous faites juste:

(mixin()() 
    (inherit eat) 
    (define/public (good-eat y) 
    (eat y) (eat y))) 

le système détecte que le code tente de dépendre d'une méthode eat qui ne fait pas partie de l'interface déclarée du mixin. Votre deuxième tentative est plus proche, mais vous avez besoin de parens supplémentaires. par exemple, de

(mixin (interface() eat) (interface() eat good-eat) 
    (inherit eat) 
    (define/public (good-eat y) 
    (eat y) (eat y))) 

à:

(mixin ((interface() eat)) ((interface() eat good-eat)) 
    (inherit eat) 
    (define/public (good-eat y) 
    (eat y) (eat y))) 

donner des noms aux interfaces pour que ce soit plus facile à voir:

(define eater<%> (interface() eat)) 
(define good-eater<%> (interface() good-eat)) 
... 
(mixin (eater<%>) (good-eater<%>) 
    ...) 

Voici un exemple:

#lang racket 

(define eater<%> (interface() eat)) 
(define good-eater<%> (interface() good-eat)) 

(define fish% 
    (class* object% (eater<%>) 
    (init size) 
    (super-new) 
    (define current-size size) 
    (define/public (get-size) current-size) 
    (define/public (eat other) 
     (set! current-size (+ current-size (send other get-size)))))) 

(define fish-interface 
    (interface() eat get-size)) 

(define good-eat-mixin 
    (mixin (eater<%>) (good-eater<%>) 
    (inherit eat) 
    (super-new) 
    (define/public (good-eat y) 
     (eat y) (eat y)))) 

(define good-eat-fish% 
    (good-eat-mixin fish%)) 

(define f1 (new good-eat-fish% [size 42])) 
(define f2 (new good-eat-fish% [size 16])) 
(send f1 eat f2) 
(send f1 good-eat f2) 
(send f1 get-size) 

(J'ai retiré les éléments clés des membres de votre exemple e, juste pour simplifier.)

Je crois que le système de classe dans racket/class est nominal plutôt que structurel.