functional-programming - paradigmas - programacion funcional vs orientada a objetos

Programación funcional pura en D

Question

En mi opinión, el poder de la pureza funcional es cuando las rutas de código profundo pueden verificarse como libres de efectos secundarios. ¿Cuáles son las experiencias de las personas en la escala del árbol de código que puede estar dentro de un especificador puro, y cuál es el nivel de reutilización del código?

Algunas cosas que vi

std.algorithm no está marcado en su mayoría como pure , pero podría ser en gran parte puro, ya sea por una versión pura de algoritmos que exigen pureza de la función de creación de instancias o combinación, o bien porque el propio especificador de pureza es estáticamente polimórfico.
A los convertidores útiles les gusta to!string( someInt ) actualmente no son puros.

Las estructuras definidas por el usuario parecen tener problemas (como se ilustra a continuación) con:
1. destructores puros en una estructura anidada
2. una función postblit pura incluso en una estructura no anidada

El siguiente código actualmente da múltiples errores en DMD 2.052 y gana 32 bits

struct InnerStruct
{
    pure this(this) {}
    pure ~this() {}
}

struct OuterStruct
{
    InnerStruct innerStruct;
    pure this(this) {}
    pure ~this() {}
}

pure void somePureFunc()
{
    OuterStruct s1 = OuterStruct(); // pure nested destructor does not compile
    OuterStruct s2 = s1;
    InnerStruct is1 = InnerStruct(); // pure non-nested destructor seems to compile
    InnerStruct is2 = is1; // pure non-nested postblit does not compile
}

void main()
{
    somePureFunc();
}

pure_postblit.d(18): Error: pure function ''somePureFunc'' cannot call impure function ''__cpctor''  
pure_postblit.d(20): Error: pure function ''somePureFunc'' cannot call impure function ''__cpctor''  
pure_postblit.d(18): Error: pure function ''somePureFunc'' cannot call impure function ''~this''  
pure_postblit.d(17): Error: pure function ''somePureFunc'' cannot call impure function ''~this''  

Answer 1

En teoría, el punto de la pure en D es que se supone que debe permitir garantías de que una función está libre de efectos secundarios, independientemente de cómo se implementa esa función. Hay dos tipos de pureza en D:

• Todas las funciones marcadas pure son débilmente puras. No pueden acceder a ningún estado global mutable (variables globales, variables locales de subproceso, variables static , etc.) o realizar E / S. Pueden, sin embargo, mutar sus argumentos. El punto de estas funciones es que pueden llamarse desde funciones fuertemente puras (detalladas a continuación) sin violar las garantías de una pureza fuerte.

• Todas las funciones que son débilmente puras y que no tienen ningún argumento con direccionamiento mutable son fuertemente puras. Los const tipo const e immutable pueden usarse para garantizar esto. (Cuando se trata de estructuras y clases, this puntero se considera un parámetro). Las funciones muy puras tienen todas las propiedades agradables de las que habla la gente de programación funcional, incluso si se implementan utilizando un estado mutable. Una función fuertemente pura siempre devuelve el mismo valor para cualquier argumento dado y no tiene efectos secundarios observables. Las funciones fuertemente puras son referencialmente transparentes, lo que significa que su valor de retorno puede sustituirse por una llamada a ellas con un conjunto dado de parámetros sin afectar el comportamiento observable. Cualquier función fuertemente pura puede ejecutarse de manera segura en paralelo con cualquier otra función fuertemente pura.

Desafortunadamente, la interacción entre código genérico y pure (así como const e immutable ) es bastante pobre. Ha habido varias propuestas para solucionar esto, pero ninguna ha sido aceptada todavía.
/ std.algorithm está escrito para ser lo más genérico posible, por lo que no puede requerir que sus funciones lambda y los rangos que acepta sean puros. Además, las características del sistema de tipos que se agregaron en D2 son generalmente las características más defectuosas en el lenguaje, porque se han priorizado más cosas básicas antes de solucionar los problemas relevantes. En este momento, pure es básicamente utilizable, excepto en casos triviales como std.math.