Lenguaje D: ¿Se consideran iguales las firmas de funciones con restricciones si se refieren al tipo directamente oa los nombres de los parámetros?

Dadas las firmas de funciones a continuación (y sus restricciones), ¿se considerarían iguales? Ambos pasan mis pruebas unitarias, por lo que me hacen creer que pueden serlo, pero me gustaría saber si son realmente idénticos o si son diferentes (pero se comportan de la misma manera):

Aquí, la restricción de firma se refiere a los nombres de los parámetros (me doy cuenta de que la información de tiempo de ejecución no está disponible, mi suposición es que el compilador los usa para referirse a los tipos de pajar y aguja):

T[] find(T, E)(T[] haystack, E needle) 
  if(is(typeof(haystack[0] != needle) == bool)) 
{
  // ...
}

Ahora, si actualizo para referirme a los tipos T y E, todavía funciona. Me gusta más este formulario porque es explícito que mi restricción de firma busca los tipos (y no la información de tiempo de ejecución) ... y bueno, es más conciso:

T[] find(T, E)(T[] haystack, E needle) 
  if(is(typeof(T != E) == bool)) 
{
  // ...
}

¿Son correctas mis suposiciones o me falta algo?

preguntado el 16 de mayo de 11 a las 17:05

2 Respuestas

personalmente usaría if(is(typeof(T.init != E.init) == bool)) para asegurarse de que se trata de las vars del tipo

(y luego, cuando quieras que T sea un rango (y perder la notación de matriz sería if(isInputRange(T) && is(typeof(T.init.front != E.init) == bool)))


editar: la mejor manera de probar cosas como esta es expandiendo el caso de prueba:

si tomamos una función diferente:

int binarySearch(T,E)(T[] haystack, E needle)
    if(is(typeof(haystack[0] < needle) == bool)) {
//...
   return -1;
}

esto se compila y funciona como cabría esperar (salvo los detalles de implementación ...)

, pero

int binarySearch(T,E)(T[] haystack, E needle)
    if(is(typeof(T < E) == bool)) {
//...
   return -1;
}

no (llamando binarySearch([1,2,3],0); en él no se compila)

sin embargo, como mi respuesta original:

int binarySearch(T,E)(T[] haystack, E needle)
   if(is(typeof(T.init > E.init) == bool)) {
    //...
    return -1;
}

esto funciona como se esperaba

contestado el 17 de mayo de 11 a las 04:05

Gracias por tu respuesta, ¿estás diciendo que los dos ejemplos de lo que publiqué arriba son iguales o simplemente se comportan igual? (¿Y cómo se compara eso con el ejemplo que publicaste)? Gracias @ratchetfreak - Zach Dennis

Gracias por su respuesta y la respuesta ampliada. Me ayuda a ver que no son del todo equivalentes. - Zach Dennis

Mi primera idea es que la firma de la función no está relacionada con restricciones estáticas. Cuando se usa, su función es generado, y también lo es su firma, creo. Las restricciones son solo para eliminar la ambigüedad y / o generar errores de tiempo de compilación, mi suposición es que no se puede hablar sobre la firma de una función de plantilla, pero tal vez, como plantilla de firma :)

En su ejemplo, creo que desea verificar la convertibilidad de un tipo a otro, digamos E a T, (Es esto int en la matriz de double), que está escrito con is(E : T) o usando una plantilla conveniente isImplicitlyConvertible en rasgos estándar.

En su primer ejemplo, comprueba esa comparación de valores haystack[0] y needle es posible, pero no hay posibilidad de que pueda encontrar 3.14 en una variedad de int, sin embargo, puede comparar un int con un float, por lo que este static if parece ser demasiado permisivo.

contestado el 18 de mayo de 11 a las 02:05

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.