Flix (lenguaje de programación)

El siguiente programa imprime " ¡Hola Mundo! " cuando se compila y ejecuta:

def main (): Unidad \ IO = println ( "¡Hola Mundo!" )

La firma de tipo y efecto de la mainfunción especifica que no tiene parámetros, devuelve un valor de tipo Unity que la función tiene el efecto IO, es decir, es impura. La mainfunción es impura porque invoca a , printLineque es impura.

El siguiente fragmento de programa declara un tipo de datos algebraico (TDA) llamado Shape:

enum Shape { case Circle ( Int32 ), // tiene radio de círculo case Square ( Int32 ), // tiene longitud de lado case Rectangle ( Int32 , Int32 ) // tiene altura y anchura }

El TAD tiene tres constructores: Circle, Square, y Rectangle.

El siguiente fragmento de programa utiliza la coincidencia de patrones para destruir un Shapevalor:

def área ( s : Forma ): Int32 = coincidir s { case Círculo ( r ) => 3 * ( r * r ) case Cuadrado ( w ) => w * w case Rectángulo ( h , w ) => h * w }

El siguiente fragmento de programa define una función de orden superior llamada twiceque, al recibir una función fde Inta, Intdevuelve una función que se aplica fa su entrada dos veces:

def twice ( f : Int32 -> Int32 ): Int32 -> Int32 = x -> f ( f ( x ))

Podemos utilizar la función twicede la siguiente manera:

dos veces ( x -> x + 1 )( 0 )

Aquí la llamada twice(x -> x + 1)devuelve una función que incrementará su argumento dos veces. Por lo tanto, el resultado de toda la expresión es 0 + 1 + 1 = 2.

El siguiente fragmento de programa ilustra una función polimórfica que aplica una función f: a -> bsobre una lista de elementos de tipo ay devuelve una lista de elementos de tipo b:

def map ( f : a -> b , l : List [ a ]): List [ b ] = match l { case Nil => Nil case x :: xs => f ( x ) :: map ( f , xs ) }

La mapfunción recorre la lista de forma recursiva ly aplica un método fa cada elemento, construyendo una nueva lista.

Flix admite la elisión de parámetros de tipo, por lo que no es necesario que los parámetros de tipo ase bintroduzcan explícitamente.

El siguiente fragmento de programa muestra cómo construir un registro con dos campos xy y:

def point2d (): { x : Int32 , y : Int32 } = { x = 1 , y = 2 }

Flix utiliza polimorfismo de filas para tipificar los registros. La sumsiguiente función toma un registro que tiene los campos xy y(y posiblemente otros campos) y devuelve la suma de los dos campos:

def sum ( r : { x : Int32 , y : Int32 | rest }): Int = r . x + r . y

Las siguientes son todas llamadas válidas a la sumfunción:

suma ({ x = 1 , y = 2 }) suma ({ y = 2 , x = 1 }) suma ({ x = 1 , y = 2 , z = 3 })

El sistema de tipos y efectos de Flix separa las expresiones puras de las impuras. ^{[ 5 ] [ 22 ] [ 23 ]} Se garantiza que una expresión pura sea referencialmente transparente . Una función pura siempre devuelve el mismo valor cuando se le dan los mismos argumentos y no puede tener ningún efecto secundario (observable).

Por ejemplo, la siguiente expresión es de tipo Int32y tiene el conjunto de efectos vacío {}, es decir, es pura:

1 + 2 : Int32 \ {}

mientras que la siguiente expresión tiene el IOefecto, es decir, es impura:

println ( "Hola Mundo" ) : Unidad \ IO

Una función de orden superior puede especificar que un argumento de la función debe ser puro, impuro o que es polimórfico en cuanto a sus efectos.

Por ejemplo, la definición de Set.existsrequiere que su argumento de función fsea puro:

// La sintaxis a -> Bool es una forma abreviada de a -> Bool \ {} def exists ( f : a -> Bool , xs : Set [ a ]): Bool = ...

El requisito de que fsea puro garantiza que no se filtren detalles de implementación . Por ejemplo, dado que fes puro, no se puede utilizar para determinar en qué orden se recorren los elementos del conjunto. Si ffuera impuro, tales detalles podrían filtrarse, por ejemplo, al pasar una función que también imprima el elemento actual, revelando así el orden interno de los elementos dentro del conjunto.

Una función de orden superior también puede requerir que una función sea impura.

Por ejemplo, la definición de List.foreachrequiere que su argumento de función fsea impuro:

def foreach ( f : a -> Unit \ IO , xs : List [ a ]): Unit \ IO

El requisito de que fdebe ser impuro garantiza que el código tenga sentido: no tendría sentido llamar List.foreachcon una función pura ya que siempre devuelve Unit.

El tipo y el efecto son correctos, pero no completos. Es decir, si una función es pura, no puede causar un efecto, mientras que si es impura , puede causarlo, pero no necesariamente. Por ejemplo, la siguiente expresión es impura aunque no pueda producir un efecto en tiempo de ejecución:

if ( 1 == 2 ) println ( "Hola Mundo!" ) else ()

Una función de orden superior también puede ser polimórfica en cuanto a sus efectos: sus efectos pueden depender de sus argumentos.

Por ejemplo, la definición de la biblioteca estándar List.mapes polimórfica en cuanto a efectos: ^{[ 24 ]}

def map ( f : a -> b \ e , xs : List [ a ]): List [ b ] \ e

La List.mapfunción toma una función fde elementos de tipo aa bcon efecto e. El efecto de la función map es en sí mismo e. Por consiguiente, si List.mapse invoca con una función pura, entonces toda la expresión es pura, mientras que si se invoca con una función impura, entonces toda la expresión es impura. Es polimórfica en cuanto a sus efectos.

Una función de orden superior que acepta múltiples argumentos puede combinar sus efectos.

Por ejemplo, la definición de la biblioteca estándar de composición de funciones hacia adelante es pura si ambos argumentos de su función son puros: ^{[ 25 ]}>>

def >> ( f : a -> b \ e1 , g : b -> c \ e2 ): a -> c \ e1 + e2 = x -> g ( f ( x ))

La firma de tipo y efecto se puede entender de la siguiente manera: La función toma dos argumentos de función: con efecto y con efecto . El efecto de es polimórfico en la conjunción de y . Si ambos son puros, entonces la expresión general es pura.>>fe1ge2>>e1e2

El sistema de tipos y efectos permite que expresiones de conjuntos arbitrarias controlen la pureza de los argumentos de las funciones.

Por ejemplo, es posible expresar una función de orden superior hque acepte dos argumentos de función fy gdonde los efectos de fson disjuntos de los de g:

def h ( f : a -> b \ e1 , g : b -> c \ e2 - e1 ): Unidad

Si hse llama con un argumento de función fque tiene el IOefecto, entonces gno puede tener el IOefecto.

El sistema de tipos y efectos se puede utilizar para garantizar que las expresiones de las sentencias sean útiles; es decir, que si una expresión o función se evalúa y su resultado se descarta, entonces debe tener un efecto secundario. Por ejemplo, compilando el siguiente fragmento de programa:

def main ( ): Unit \ IO = List.map ( x -> 2 * x , 1 :: 2 :: Nil ) ; println ( "Hola Mundo" );

provoca un error de compilación:

-- Error de redundancia -------------------------------------------------->> Expresión inútil: No tiene efectos secundarios y su resultado se descarta.2 | List.map(x -> 2 * x, 1 :: 2 :: Nil);  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  expresión inútil.

Porque no tiene sentido evaluar la expresión pura y luego descartar su resultado. Lo más probable es que el programador quisiera usar el resultado (o, alternativamente, la expresión es redundante y podría eliminarse). Por consiguiente, Flix rechaza este tipo de programas.List.map(x -> 2 * x, 1 :: 2 :: Nil)

Flix admite programas Datalog como valores de primera clase. ^{[ 6 ] [ 9 ] [ 26 ]} Un programa Datalog es un programa lógico que consiste en una colección de hechos y reglas no ordenados . Juntos, los hechos y las reglas implican un modelo mínimo , una solución única para cualquier programa Datalog. En Flix, los valores de los programas Datalog se pueden pasar a funciones y devolver desde ellas, almacenar en estructuras de datos, combinar con otros valores de programas Datalog y resolver. La solución a un programa Datalog (el modelo mínimo) es en sí misma un programa Datalog. Por lo tanto, es posible construir secuencias de programas Datalog donde la solución, es decir, la "salida", de un programa Datalog se convierte en la "entrada" de otro programa Datalog.

Los siguientes hechos de arista definen un grafo:

Borde ( 1 , 2 ) . Borde ( 2 , 3 ) . Borde ( 3 , 4 ) .

Las siguientes reglas de Datalog calculan el cierre transitivo de la relación de arista:

Ruta ( x , y ) :- Arista ( x , y ). Ruta ( x , z ) :- Ruta ( x , y ), Arista ( y , z ).

El modelo mínimo de los hechos y las reglas es:

Borde ( 1 , 2 ) . Borde ( 2 , 3 ) . Borde ( 3 , 4 ) . Camino ( 1 , 2 ) . Camino ( 2 , 3 ) . Camino ( 3 , 4 ) . Camino ( 1 , 3 ) . Camino ( 1 , 4 ) . Camino ( 2 , 4 ) .

En Flix, los programas Datalog son valores. El programa anterior se puede integrar en Flix de la siguiente manera:

def main (): #{Edge(Int32, Int32), Path(Int32, Int32)} = let f = #{ Edge ( 1 , 2 ) . Edge ( 2 , 3 ) . Edge ( 3 , 4 ) . }; let p = #{ Path ( x , y ) : - Edge ( x , y ) . ​​Path ( x , z ) : - Path ( x , y ), Edge ( y , z ) . }; solve f <+> p

La variable local fcontiene un valor de programa Datalog que consta de los hechos de arista. De manera similar, la variable local pes un valor de programa Datalog que consta de las dos reglas. La f <+> pexpresión calcula la composición (es decir, la unión) de los dos programas Datalog fy p. La solveexpresión calcula el modelo mínimo del programa Datalog combinado, devolviendo los hechos de arista y ruta mostrados anteriormente.

Dado que los programas Datalog son valores de primera clase, podemos refactorizar el programa anterior en varias funciones. Por ejemplo:

def edges (): #{Edge(Int32, Int32), Path(Int32, Int32)} = #{ Edge ( 1 , 2 ) . Edge ( 2 , 3 ) . Edge ( 3 , 4 ) . }def cierre (): #{Edge(Int32, Int32), Path(Int32, Int32)} = #{ Path ( x , y ) : - Edge ( x , y ) . Path ( x , z ) : - Path ( x , y ), Edge ( y , z ) . }def run (): #{Edge(Int32, Int32), Path(Int32, Int32)} = resolver edges() <+> closure()

El cierre no dirigido del grafo se puede calcular añadiendo la regla:

Ruta ( x , y ) :- Ruta ( y , x ).

Podemos modificar la closurefunción para que acepte un argumento booleano que determine si queremos calcular el cierre dirigido o no dirigido:

def cierre ( dirigido : Bool ): #{Edge(Int32, Int32), Path(Int32, Int32)} = let p1 = #{ Path ( x , y ) : - Edge ( x , y ) . Path ( x , z ) : - Path ( x , y ), Edge ( y , z ) . }; let p2 = #{ Path ( y , x ) : - Path ( x , y ) . }; if ( dirigido ) p1 else ( p1 <+> p2 )

let p1 = Edge ( 123 , 456 ) . ; let p2 = Edge ( "a" , "b" ) . ; p1 <+> p2 ;

def main (): #{Male(String), Husband(String), Bachelor(String)} = let p1 = Husband ( x ) : - Male ( x ), not Bachelor ( x ) . ; let p2 = Bachelor ( x ) : - Male ( x ), not Husband ( x ) . ; p1 <+> p2 // ilegal, no estratificado.

def main (): #{A(Int32), B(Int32)} = if ( true ) A ( x ) : - A ( x ), not B ( x ) . else B ( x ) : - B ( x ), not A ( x ) .