Esiste un modo per limitare la firma di un parametro del funtore in modo che il parametro possa fornire tipi di uguaglianza non specificati a una struttura?

Question

Se provo a scrivere un modulo parametrizzato che chiama = su un tipo non specificato fornito dal parametro, SML/NJ genera un errore di tipo. Ad esempio, se ho una firma

signature SIG = 
sig 
    type t 
end 

e cerco di parametrizzare un modulo F su un modulo S con la firma SIG

functor F (S : SIG) = 
struct 
    fun f (x:S.t) (y:S.t) = (x = y) 
end 

mi farà scattare il seguente errore di compilazione:

Error: operator and operand don't agree [equality type required] 
    operator domain: ''Z * ''Z 
    operand:   S.t * S.t 
    in expression: 
    x = y 

Come posso specificare che S.t dovrebbe essere un tipo di uguaglianza?

L'unica soluzione che ho potuto capire finora è quello di fornire anche la funzione uguaglianza nella struttura sulla quale il funtore è parametrizzato cioè:

signature SIG' = 
sig 
    type t 
    val eq : (''a * ''a) -> bool 
end 

functor F' (S' : SIG') = 
struct 
    fun f' x y = S'.eq (x, y) 
end 


structure A = F'(struct 
        type t = int 
        val eq = (op =) 
        end) 

Sembra che ci deve essere un modo migliore , anche se potrei anche fraintendere qualcosa di fondamentale e importante su come i funtori debbano funzionare.

Answer 1

Hai solo bisogno di specificare che t è un eqtype:

signature SIG = 
sig 
    eqtype t 
end