qual è la definizione del tipo di nim per la procedura generica?

Question

Ho uno strategie espresse in farmaci generici in NIM:

proc fooStrategy[T](t: T, ...) 
proc barStrategy[T](t: T, ...) 

vorrei creare una tabella di ricerca per le strategie per nome ... così ho provato:

type 
    Strategy*[T] = proc[T](t: T, ...) 

let strategies* = toTable[string, Strategy[T]]([ 
    ("foo", fooStrategy), ("bar", barStrategy)]) 

Questo non lo fa lavoro: la dichiarazione del tipo fallisce. Se riuscissi a cavarmela potrei immaginare che il tavolo delle strategie avrebbe anche dei problemi. c'è un altro modo per fare ciò? "T" dovrebbe essere "qualche tipo di raccolta 1D" - potrebbe essere sequenza, matrice, vettore da blas, ecc. Potrei aggiungere strategie concrete alla tabella per le raccolte comuni, ma ho ancora il problema con il puntatore di funzione, come

type 
    Strategy* = proc(t: any, ...) 

let strategies* = toTable[string, Strategy]([ 
    ("foo-seq[int]", fooStrategy[int]), ...]) 

ha ancora problemi. Eventuali suggerimenti?

Answer 1

ci sono più problemi con il tuo codice:

In primo luogo, initTable non prende un elenco di elementi per la tavola. Richiede solo una dimensione iniziale. Si desidera utilizzare toTable invece.

In secondo luogo, è necessario impostare in modo esplicito un valore per il parametro generico T durante la creazione di una tabella, poiché durante il runtime tutti i parametri generici devono essere associati a un tipo.

In terzo luogo, i tipi di proc devono corrispondere esattamente, inclusi i pragmi sul proc. Questo è difficile.

Ecco un esempio di lavoro:

import tables 

type 
    Strategy*[T] = proc(t: T) {.gcsafe, locks: 0.} 

proc fooStrategy[T](t: T) = echo "foo" 
proc barStrategy[T](t: T) = echo "bar" 

let strategies* = toTable[string, Strategy[int]]([ 
    ("foo", fooStrategy[int]), ("bar", barStrategy[int]) 
]) 

Per questo esempio, creo una tabella con Strategy[int] valori (non si può avere una tabella con i valori Strategy[T] come questo non è un tipo concreto). Istanziare sia fooStrategy e barStrategy con [int] per abbinare il tipo di tabella. Ho aggiunto {.gcsafe, locks: 0.} alla definizione del tipo. Se questo viene omesso, si otterrà un errore di compilazione:

test.nim(9, 49) Error: type mismatch: got (Array constructor[0..1, (string, proc (t: int){.gcsafe, locks: 0.})]) 
but expected one of: 
proc (pairs: openarray[(string, Strategy[system.int])]): Table[system.string, Strategy[system.int]]{.gcsafe, locks: 0.} 

Come si vede, il compilatore ti dice nella prima riga ciò che vede e nella terza linea di quello che si aspetta. vede proc s con {.gcsafe, locks: 0.} poiché tali direttive sono assegnate implicitamente ai valori proc definiti sopra. La direttiva cambia il tipo, quindi per poter assegnare quelli proc a Strategy[T], è necessario definire lo stesso pragma a Strategy[T].