functional-programming - patrones - pattern matching scala

coincidencia de patrones en D

Question

Recientemente me tropecé con el lenguaje de programación D y realmente me gusta. Puede programar un nivel muy alto al tener acceso completo al hardware como en C.

proveniente de un fondo bastante funcional (Haskell, scala) Estoy buscando una manera de hacer coincidir los patrones en D, pero no encontré nada en http://www.digitalmars.com/d/ . En Haskell, la coincidencia de patrones es compatible con el propio lenguaje. En Scala se logra por clases de casos o extractores (objetos normales con un método de no aplicación).

¿Es posible hacer esto en D?

el método de recepción en std.concurrency que se utiliza para hacer concurrencia en un estilo de actor como en erlang y scala tiene un montón de funciones y patrones de matemáticas en estos. Pero creo que no es tan flexible como en otros idiomas. ¿Puedes usar guardias? ¿Se pueden extraer los contenidos del Objeto como es posible en scala?

Answer 1

No hay una función dedicada de coincidencia de patrones tan potente como en Haskell o Scala.

Como ya ha descubierto, las funciones de sobrecarga y llamada (con plantilla) o delegados son una forma restringida de coincidencia de patrones. Puedes hacer coincidir solo en los tipos de argumento.

Puede hacer un patrón de coincidencia en los argumentos de la plantilla de compilación Tampoco es posible extraer el contenido de un objeto allí. Pero puedes extraer los contenidos de un tipo.

P.ej :

import std.stdio, std.conv;
template match(T...){
    enum match = "default case";
}
template match(string a : "x", int b : 1, int  c){
    enum match = "matched 1, b="~to!string(b);
}
template match(int a, string b, int c : 100){
    enum match = "matched 2, b="~b;
}
template match(T : T[]*[]){
    enum match = "matched 3, an array of pointers to an array of "~T.stringof;
}


void main(){
    int a=100;
    writeln(match!("x",1,5));        // "matched 1, b=1"                                                                                                     
    writeln(match!(12,"str"));       // "default case"                                                                                                       
    writeln(match!(12,"str",100));   // "matched 2, b=str"                                                                                                   
    writeln(match!(int*[]*[]));      // "matched 3, an array of pointers to an array of int*"                                                                
    //writeln(match!(12,"str",a));   // would be error, because ''a''                                                                                            
                                     // is not evaluable during compile time                                                                                 
}

Si está interesado, puede querer echar un vistazo a http://d-programming-language.org/template.html .

''is'': las expresiones son otra forma de hacer coincidir patrones en tipos, vea

http://d-programming-language.org/expression.html (busque "IsExpression").

Answer 2

Si no insiste en usar D2 y / o Phobos, puede usar la biblioteca de tango . Tiene un módulo de expresiones regulares que puede utilizar. [Editar] También hay un módulo de expresiones regulares en D2 / Fobos [/ Editar] Si insistes en usar D2 y / o Fobos, puedes intentar portarlo. No debería ser demasiado difícil.

El tango es una alternativa std lib. A muchos desarrolladores y usuarios de tango no les gusta la forma en que D2 va y la mayoría de los usuarios se quedan con D1. Es por eso que solo hay un port incompleto a D2 disponible.

También está el proyecto scregex que proporciona expresiones regulares compiladas estáticamente. Yo ya lo usé y funcionó. Pero creo que también es D1-solamente. Sin embargo, funciona tanto con phobos como con el tango.

Answer 3

No hay coincidencia de patrones, como se sabe por Haskell, está integrado en el lenguaje, pero D tiene capacidades de tiempo de compilación y reflexión muy genéricas que le permitirán combinar el tipo y su estructura en la biblioteca. Para los valores de tiempo de ejecución coincidentes, solo puede usar construcciones ordinarias if / switch ...; la evaluación perezosa de los argumentos de la función también podría ayudar con la implementación de algunas técnicas de coincidencia en el tiempo de ejecución.

Las restricciones de plantilla le permitirán crear sobrecargas de funciones (plantilla) basadas en cualquier expresión evaluada en el momento de la compilación (D le permite ejecutar casi todo el código normal durante la compilación). También puedes usar static if para efectos similares. Esto le permitirá prácticamente coincidir con la estructura de tipos. Esta técnica también es comúnmente utilizada en D.

Es posible que el código de std.algorithm interesante, busque isInputRange y funciones similares (realizan la coincidencia en la estructura de tipos) y restringen el tipo de argumento para que sea de cierta clase de tipos

Algunas instrucciones para la reflexión del tiempo de compilación:

• Es expresion
• Traits
• std.traits