Getippter Racket-Fehler mit Check-Random

Question

Ich versuche, ein Projekt auf typisierte Schläger von Schläger zu konvertieren, und ich stoße Fehler mit funktionierenden Code wegen der Test-Engine.

Ich habe es auf das kleinste Stück Code reduziert ich schaffen kann, dass das Problem reproduziert:

#lang typed/racket 

; provides check-expect and others for testing 
(require typed/test-engine/racket-tests) 

(: bar (-> Positive-Integer Integer)) 

(check-random (bar 6) (random 6)) 

(define (bar x) 
    (random x)) 

(test) 

Und die Fehler sind:

. Type Checker: type mismatch 
    expected: Pseudo-Random-Generator 
    given: Any in: (check-random (bar 6) (random 6)) 

. Type Checker: type mismatch 
    expected: Positive-Integer 
    given: Any in: (check-random (bar 6) (random 6)) 

. Type Checker: Summary: 3 errors encountered in: 
    (check-random (bar 6) (random 6)) 
    (check-random (bar 6) (random 6)) 
    (check-random (bar 6) (random 6)) 

Hat jemand irgendwelche Ratschläge, wie man repariere das? Ich möchte wirklich, wenn möglich, die Typprüfungsfunktionen verwenden können.

Dank

Answer 1

Sicher, kann ich helfen, aber es hängt viel von was genau wollen Sie, und wo Sie mit dieser gehen.

Kurzer Überblick: Es gibt mehrere Test-Frameworks für Racket. Sie verwenden das, das für die Unterrichtssprachen gebaut wurde. Es hat einige nette Eigenschaften, aber im Allgemeinen ist rackunit das Testframework, das von anderen benutzt wird.

Es scheint mir, dass die typisierte Version des Teaching-Language-Test-Frameworks keine Unterstützung für Check-Random bietet. Ich werde das auf der Mailing-Liste überprüfen. Das würde dich in Richtung Rackeinheit führen.

Leider enthält rackunit das "check-random" -Formular nicht. Glücklicherweise ist es nicht schwer zu implementieren. Hier ist meine Implementierung, die an Ihren Code angehängt ist.

#lang typed/racket 

; provides check-expect and others for testing 
(require typed/rackunit) 

;; create a new prng, set the seed to the given number, run the thunk. 
(: run-with-seed (All (T) ((-> T) Positive-Integer -> T))) 
(define (run-with-seed thunk seed) 
    (parameterize ([current-pseudo-random-generator 
        (make-pseudo-random-generator)]) 
    (random-seed seed) 
    (thunk))) 

;; run a check-equal where both sides get the same PRNG seed 
(define-syntax check-random-equal? 
    (syntax-rules() 
    [(_ a b) (let ([seed (add1 (random (sub1 (expt 2 31))))]) 
       (check-equal? (run-with-seed (λ() a) seed) 
          (run-with-seed (λ() b) seed)))])) 

(: bar (-> Positive-Integer Integer)) 
(define (bar x) 
    (random x)) 

(check-random-equal? (bar 6) 
        (random 6))    

Ich sollte wahrscheinlich über einige wichtige Unterschiede zwischen den beiden Test-Frameworks erzählen.

• Sie müssen am Ende nicht "(test)" aufrufen; Die Tests laufen verschachtelt mit dem Rest des Codes.
• Da die Tests mit dem Code verschachtelt sind, müssen sie unter allen Definitionen erscheinen, die zum Ausführen des Tests erforderlich sind.
• Wenn ein Test erfolgreich ist, wird nichts gedruckt.