language agnostic - ¿Cuáles son algunos otros lenguajes que apoyan la "especialización parcial"?

language-agnostic generics

Question

La especialización de plantilla parcial es uno de los conceptos más importantes para la programación genérica en C ++. Por ejemplo: para implementar una función de intercambio genérica:

template <typename T>
void swap(T &x, T &y) {
const T tmp = x;
y = x;
x = tmp;
}

Para especializarlo para que un vector sea compatible con O (1) swap:

template <typename T, class Alloc>
void swap(vector<T, Alloc> &x, vector<T, Alloc> &y) { x.swap(y); }

Por lo tanto, siempre puede obtener un rendimiento óptimo cuando llama a swap (x, y) en una función genérica;

Muy apreciado, si puede publicar el equivalente (o el ejemplo canónico de especialización parcial del idioma si el idioma no admite el concepto de intercambio) en idiomas alternativos.

EDITAR : por lo que parece que muchas personas que respondieron / comentaron realmente no sabían qué es la especialización parcial, y que el ejemplo genérico de intercambio parece interferir en la comprensión de algunas personas. Un ejemplo más general sería:

template <typename T>
void foo(T x) { generic_foo(x); }

Una especialización parcial sería:

template <typename T>
void foo(vector<T> x) { partially_specialized_algo_for_vector(x); }

Una especialización completa sería:

void foo(vector<bool> bitmap) { special_algo_for_bitmap(bitmap); }

¿Por qué esto es importante? porque puedes llamar a foo (cualquier cosa) en una función genérica:

template <typename T>
void bar(T x) {
// stuff...
foo(x);
// more stuff...
}

y obtenga la implementación más adecuada en tiempo de compilación. Esta es una forma de que C ++ logre la abstracción con una mínima penalización de rendimiento.

Espero que ayude a aclarar el concepto de "especialización parcial". En cierto modo, así es como C ++ escribe la coincidencia de patrones sin necesidad de la sintaxis de concordancia explícita de patrones (por ejemplo, la palabra clave de concordancia en Ocaml / F #), que a veces se interpone en el camino para la programación genérica.

Answer 1

DO#:

void Swap<T>(ref T a, ref T b) {
var c = a;
a = b;
b = c;
}

Supongo que la versión (pura) de Haskell sería:

swap :: a -> b -> (b,a)
swap a b = (b, a)

Answer 2

En realidad, puedes (no del todo, ver abajo) hacerlo en C # con métodos de extensión:

public Count (this IEnumerable<T> seq) {
int n = 0;
foreach (T t in seq)
n++;
return n;
}
public Count (this T[] arr) {
return arr.Length;
}

Luego, llamar a array.Count() usará la versión especializada. "No del todo" se debe a que la resolución depende del tipo de array estática, no del tipo de tiempo de ejecución. Es decir, usará la versión más general:

IEnumerable<int> array = SomethingThatReturnsAnArray();
return array.Count();

Answer 3

Haskell tiene instancias superpuestas como una extensión:

class Sizable a where
size :: a -> Int
instance Collection c => Sizable c where
size = length . toList

es una función para encontrar el tamaño de cualquier colección, que puede tener instancias más específicas:

instance Sizable (Seq a) where
size = Seq.length

Ver también Advanced Overlap en HaskellWiki .

Answer 4

Java tiene genéricos, que te permiten hacer tipos similares de cosas.

Answer 5

Me temo que C # no admite la especialización de plantillas parciales.

La especialización parcial de la plantilla significa:

Tienes una clase base con dos o más plantillas (genéricos / parámetros de tipo). Los parámetros de tipo serían <T, S>

En una clase derivada (especializada), indica el tipo de uno de los parámetros de tipo. Los parámetros de tipo podrían verse así <T, int>.

Entonces, cuando alguien usa (crea un objeto de) la clase donde el último parámetro de tipo es un int, se usa la clase derivada.

Answer 6

D admite especialización parcial:

• Descripción general del lenguaje
• Comparación de características de la plantilla (con C ++ 98 y 0x).

(busque "parcial" en los enlaces anteriores).

El segundo enlace en particular le dará un desglose muy detallado de lo que puede hacer con la especialización de plantillas, no solo en D sino también en C ++.

Aquí hay un ejemplo específico de D de swap . Debe imprimir el mensaje para el intercambio especializado para la clase Thing .

import std.stdio; // for writefln
// Class with swap method
class Thing(T)
{
public:
this(T thing)
{
this.thing = thing;
}
// Implementation is the same as generic swap, but it will be called instead.
void swap(Thing that)
{
const T tmp = this.thing;
this.thing = that.thing;
that.thing = tmp;
}
public:
T thing;
}
// Swap generic function
void swap(T)(ref T lhs, ref T rhs)
{
writefln("Generic swap.");
const T tmp = lhs;
lhs = rhs;
rhs = tmp;
}
void swap(T : Thing!(U))(ref T lhs, ref T rhs)
{
writefln("Specialized swap method for Things.");
lhs.swap(rhs);
}
// Test case
int main()
{
auto v1 = new Thing!(int)(10);
auto v2 = new Thing!(int)(20);
assert (v1.thing == 10);
assert (v2.thing == 20);
swap(v1, v2);
assert (v1.thing == 20);
assert (v2.thing == 10);
return 0;
}