El estado del ecosistema del desarrollador 2019

Como en el 2018 la empresa jetbrains  compartido los resultados de su encuesta anual.

Sin más dejo el link: https://www.jetbrains.com/es-es/lp/devecosystem-2019/

Swift es como Kotlin

Quiero compartir una pagina que compara Swift con Kotlin.

Lo comparto porque hasta esta pagina, no me parecían similares pero son igualitos :D

Dejo link: http://nilhcem.com/swift-is-like-kotlin/

Libro gratuito de Scala

Quiero compartir el siguiente libro de Alvin Alexander que es gratuito y esta bueno. El libro tiene aproximadamente 225 páginas y proporciona una breve pero completa introducción al lenguaje Scala. Según el autor.

Sin más dejo el link: https://alvinalexander.com/scala/scala-book-free/

Ejemplo de pattern matching en Scala

La idea es que tenemos que saber si un string (en realidad lo hice con lista de caracteres) tiene sus paréntesis balanceados. Onda si abre uno lo tiene que cerrar y por supuesto, no puede comenzar cerrando.

Veamos como podemos solucionar esto en Scala:

def balance(palabra : List[Char]) : Boolean = {

  def balanceAux(palabra : List[Char], n : Int) : Int = palabra match {
    case List() => n
    case '('::tail => balanceAux(tail, n + 1)
    case ')'::tail => if (n == 0) -1 else balanceAux(tail, n - 1)
    case _::tail => balanceAux(tail, n)
  }

  balanceAux(palabra, 0) == 0
}

Se puede ver que el ultimo case tiene el valor que no es un paréntesis, cualquier otra letra y esto lo decimos con "_"

Es un ejemplo bastante pavo, pero podemos ver la potencia que tiene Pattern matching

Primer acercamiento a I/O en Haskell

Las funciones puras son el tipo de funciones toman valores como argumentos, procesan algunos de esos valores y luego devuelven un valor de resultado. Una función pura no depende del "estado del mundo". El cálculo es totalmente autónomo e independiente. Dados los mismos argumentos, una función pura siempre devolverá el mismo resultado.

I/O es impuro. Las operaciones de entrada y salida son impuras. Influyen e interactúan con el "mundo exterior". Esencialmente, esta es la única forma de hacer que las computadoras hagan cosas interesantes.

La función getLine lee la entrada del usuario y la devuelve como un tipo especial de valor de cadena: una cadena de I/O. La función putStrLn toma una entrada de cadena y la imprime en el terminal, devolviendo un valor de IO vacío, es decir, IO ().

Los tipos IO es lo que nos permite no mezclar funciones puras e impuras: el sistema de tipos nos mantiene honestos. Sabemos por el tipo de función si está involucrado con I/O.

Veamos esta simple función :

let greet() = do
    planet <- getLine
    home <- getLine
    putStrLn ("greetings " ++ planet ++ "ling.")
    putStrLn ("I am from " ++ home ++ ".")
    putStrLn "Take me to your leader."

Podemos escribirlo como una (¡muy larga!) Línea única:

do { planet <- getLine; home <- getLine; putStrLn ("greetings " ++ planet ++ "ling."); putStrLn ("I am from " ++ home ++ "."); putStrLn "Take me to your leader."}

Si ejecutamos esto, escribiendo "Earth" y "Mars". Entonces deberías ver:

greetings Earthling.
I am from Mars.
Take me to your leader.

Tenga en cuenta que el orden es importante aquí:

queremos que la primera llamada getLine obtenga el nombre del planeta en el que hemos aterrizado
queremos que la segunda llamada getLine obtenga el nombre de dónde somos.

El orden de evaluación de funciones no importa en código puro, por Ej.

let a = reverse "winston"
    b = reverse "churchill"
in "sir " ++ a ++ " " ++ b

No importa si hacemos el primer reverso antes del segundo; el resultado de la expresión sigue siendo el mismo. Sin embargo, este no es el caso de I/O. La secuencia es vital para las acciones de I/O.

La notación do nos permite secuenciar acciones. Esto se parece a una secuencia de comandos en un lenguaje de programación imperativo. Sin embargo, hacer es solo azúcar sintáctico. Debajo, se reescribe como una cadena de llamadas de función donde la salida de la primera función se convierte en la entrada de la segunda función. El operador de enlace realiza esta secuencia de funciones. Es una parte clave de la mónada IO. Estamos comenzando a arañar la superficie de Haskell IO y descubrimos que es muy complejo. Reservaremos la discusión de Mónadas y operadores de enlace para más adelante en el curso.

Por ahora, todo lo que necesitamos entender es:

• Las operaciones de I/O son impuras
• Puede usar do para especificar una secuencia de acciones
• use <- dentro de un do para asociar valores de entrada con nombres
• cualquier valor o función que implique I/O tiene IO en su tipo
• una secuencia de acciones de  I/O se describe como estar en la Mónada de IO

Tail recursion

Cuando me tocaba enseñar recursibidad, hago el típico ejemplo de la Sucesión de Fibonacci la cual podríamos definir de este modo :

f(0) = 1
f(1)= 1
f(n) = f(n - 1) + f(n - 2)

Y listo! esto es muy fácil de programar en scala, sería:

def fibo(n: Int) : Long = if (n==0 || n==1) 1 else fibo(n-1) + fibo(n-2)

esto funciona si no pretendemos calcular el fibonacci en la posición  n = 55

El problema es que este algoritmo tiene una complejidad de dos a la n.

Podemos resolver este problema empezando desde el comienzo. Si lo pensamos de forma imperativo, sería algo así :

  def fibonacci(n: Int): Long = {
     var fa = 1l
     var faa = 1l
     var i = 1
    while (i < n) {
      var aux = fa
      fa = fa + faa
      faa = aux
      i = i + 1
    }
    faa
  }

Es decir si empezamos desde el principio ya tenemos los f(n-1) y f(n-2), pero no solo es solucionable de este modo de forma imperativa, tambien podemos utilizar recursividad de este modo :

  def fibonacci(n: Int): Long = {
     def fibonacciAux(n: Int, fa: Long, faa: Long) : Long =
       if (n == 3) fa + faa
       else fibonacciAux(n-1, fa + faa, fa)

    if (n<=2) 1
    else fibonacciAux(n,1,1)
  }


Tail recursion es un tipo específico de recursión. En particular, se dice que una función recursiva usa tail recursion si la llamada a sí misma ocurre como la última acción de la función.

Cuando una función recursiva se llama a sí misma varias veces, las llamadas van acumulándose en la pila de llamadas, que de por sí, no es muy eficiente porque consume memoria. Pero aun peor, si se acumulan demasiadas llamadas en esta pila, eventualmente se desborda la pila de llamadas y te lanza la excepción java.lang.StackOverflowError.

Esta ineficiencia es un problema serio para un lenguaje funcional como Scala que promueve el uso de funciones recursivas.

Sin embargo, cuando Scala detecta que la función recursiva usa tail recursion, entonces el compilador es capaz de efectuar una optimización al código de forma automática, efectivamente eliminando la recursividad enteramente y reemplazándolo con un simple bucle. Esta optimización es comúnmente conocida como tail call optimization.

Y listo! La función de fibonacci funciona rápido porque utilizamos tail recursion y porque bajamo su complejidad.

Dejo link :
https://es.stackoverflow.com/questions/121965/que-es-tail-recursion

Libros gratuitos de Haskell

Me gustaría recomendar estos libros gratuitos :

Real World Haskell
Real World Haskell es un típico libro de lenguaje de programación O’Reilly. El contenido está disponible en línea de forma gratuita : http://book.realworldhaskell.org/read/

Learn You a Haskell
Learn You a Haskell es una introducción muy informal, pero hace un gran trabajo al explicar conceptos complejos. Puedes leerlo : http://learnyouahaskell.com/chapters

Listas en Haskell

Una estructura de datos clave es la lista

Sintaxis: los elementos se escriben entre corchetes, separados por comas.

['3', 'a']
[2.718, 50.0, -1.0]

Una función solo puede devolver un resultado pero las listas le permiten agrupar varios valores en un objeto, que puede ser devuelto por una función.

Aquí hay una función (minmax) que devuelve el menor y el mayor de dos números:

minmax = \x y -> [min x y, max x y]
minmax 3 8  -- > [3,8]
minmax 8 3  -- > [3,8]

Ojo! se puede hacer pero no esta del todo bien...

Se puede escribir una lista constante, de la siguiente manera:

mylist = [2,4,6,8]

A la vez los elementos pueden ser expresiones y se evalúan solo cuando se usan. Supongamos que se define:

answer = 42
yourlist = [7, answer+1, 7*8]

Entonces

yourlist -- > [7, 43, 56]

Pero mientras no acceda a la expresión, no se evalúa.

El operador (++) toma dos listas existentes y retorna una nueva que contiene todos los elementos de las listas pasadas por parámetro.

[23, 29] ++ [48, 41, 44] -- > [23, 29, 48, 41, 44]

Si xs es una lista, entonces [] ++ xs = xs = xs ++ [].

A veces es útil tener una secuencia de números.

En notación matemática estándar, puedes escribir 0,1, ..., n.

Haskell tiene una notación de secuencia para listas.

La secuencia se escribe entre corchetes, con el valor inicial, el operador ... y el valor final.

[0 .. 5] -> [0,1,2,3,4,5]
[100 .. 103] -> [100,101,102,103]

Las secuencias no están limitadas a números, hay muchos tipos enumerables donde hay una forma natural de incrementar un valor y se puede usar secuencias en cualquier de estos tipos.

Por ejemplo:

[’A’ .. ’z’] -> ['a', 'b', 'c', 'd', 'e', ​​'f', 'g', 'h', 'i', 'j', 'k', 'l', ' m ',' n ',' o ',' p ',' q ',' r ',' s ',' t ',' u ',' v ',' w ',' x ',' y ' , 'z']

['0' ... '9'] -> ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9' ']

es una lista de caracteres (que resultan ser los caracteres de dígitos);

[0 .. 9] -> [0,1,2,3,4,5,6,7,8,9]
Es una lista de números.

Una comprensión de lista es una notación de alto nivel para especificar el cálculo de una lista

El compilador transforma automáticamente las comprensiones de una lista en una expresión utilizando una familia de funciones básicas que operan en listas

Las comprensiones de listas se inspiraron en la comprensión del conjunto de notación matemática.

Ejemplos de comprensiones de conjuntos:

• Un conjunto obtenido multiplicando los elementos de otro conjunto por 3 es {3 × x | x ← {1, ..., 10}}.
• El conjunto de números pares es {2 × x | x ← N}.
• El conjunto de números impares es {2 × x + 1 | x ← N}.
• El producto cruzado de dos conjuntos A y B es {(a, b) | a ← A, b ← B}.

Ejemplos de listas por comprensión
[3 * x | x <- [1..10]]
->
[3,6,9,12,15,18,21,24,27,30]

[2 * x | x <- [0..10]]
->
[0,2,4,6,8,10,12,14,16,18,20]

[2 * x + 1 | x <- [0..10]]
->
[1,3,5,7,9,11,13,15,17,19,21]

[[a, b] | a <- [10,11,12], b <- [20,21]]
->
[[10,20], [10,21], [11,20], [11,21], [12,20], [12,21]]

Podemos indexar una lista numerando los elementos, comenzando por 0. Así, una forma canónica de una lista con n elementos es [x0, x1, .. xn − 1]. El operador !! toma una lista y un índice, y devuelve el elemento correspondiente.

[5,3,8,7] !! 2 -> 8
[0 .. 100] !! 81 -> 81
['a' .. 'z'] !! 13 -> 'n'

Si el índice es negativo o demasiado grande, se devuelve indefinido.

Hay funciones de la biblioteca estándar para acceder encabezado de una lista (su primer elemento) o la cola (todo el resto de la lista)

El resultado de aplicar head o tail a la lista vacía no está definido.

head :: [a] -> a
head [4,5,6] -- > 4
tail :: [a] -> [a]
tail [4,5,6] -- > [5,6]


Hemos mencionado antes que Haskell es "lazy", lo que significa que solo evalúa expresiones cuando son necesarias para la evaluación de otra expresión. Este comportamiento se extiende a las listas, por lo que podemos definir listas infinitas usando secuencias, por ejemplo [1 .. ] es la lista de todos los enteros positivos. Otro ejemplo es la función primos (del paquete Data.Numbers.Primes) que devuelve una lista infinita de números primos. Una consecuencia de lazy en las listas es que puede definir listas que contengan expresiones muy complejas y que requieren mucho tiempo, y no se evaluarán, si no son requeridas. Lo mismo es cierto para una expresión incorrecta, por ejemplo, definir xs = [1,2, xs !! 5,4] no generará un error siempre que no acceda al tercer elemento.

Otra cosa muy importante es que las listas también son inmutables. Como resultado, si define xs2 = xs ++ xs e intenta acceder al tercer elemento xs2 !! 2 aún generará un error porque xs no se ha modificado:

xs2 !! 2 -- > *** Exception: Prelude.(!!): index too large

Curiosamente, si cambiamos la definición de xs a xs = [1,2, xs2 !! 5,4], entonces ambas xs !! 2 y xs2 !! 2 devolverá 2:

xs = [1,2,xs2 !! 5,4]
xs2 = xs ++ xs
xs2 !! 2 -- > 2
xs !! 2 -- > 2

Esta es una consecuencia de la evaluación de expresiones de Haskell mediante la reducción: el orden de las expresiones no importa.

PD: la imagen es de http://learnyouahaskell.com/ con licencia Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License  porque no pudo encontrar una licencia con un nombre más largo.

DevOps: tecnología, herramientas y plan de carrera

DevOps se ha convertido en el nuevo paradigma de desarrollo. Su agilidad, una metodología de entrega continua y un sistema prueba-error que permite obtener feedback instantáneo, ha disparado la demanda de este tipo de profesionales en las empresas. ¿Quieres saber más? ¡Descárgate nuestro eBook gratuito "DevOps: "tecnología, herramientas y plan de carrera"!

Sito textual, la pagina que nos esta regalando un libro sobre esta tecnología.

Dejo link: https://landing.muypro.com/ebook-devops/

Funciones en Haskell

Haskell es un lenguaje funcional, por lo que el concepto de función es esencial para el lenguaje. Una función toma uno o más argumentos y calcula un resultado. Dados los mismos argumentos, el resultado siempre será el mismo. Esto es similar a una función matemática y significa que en Haskell no hay efectos secundarios. Hay dos operaciones fundamentales en las funciones: definición de función (crear una función) y aplicación de función (usar una función para calcular un resultado).

En Haskell, muchas funciones están predefinidas en una biblioteca estándar llamada preludio (prelude)

Una función se define mediante una ecuación.
f = \ x -> x + 1 - función lambda
- o
f x = x + 1 - función nombrada

Esto es equivalente a f (x) = x + 1 en notación matemática.

El lado izquierdo de la ecuación parece una variable, y eso es lo que es. El lado derecho es una expresión que usa las variables locales enumeradas entre paréntesis y define el resultado de la expresión.

Una aplicación es una expresión como f 31, donde 31 es el argumento. La aplicación se evalúa reemplazándola con el cuerpo de la función, donde los parámetros formales se reemplazan por los argumentos.

Veamos un ejemplo :

f = \ x -> x + 1
  f 3
-> {enlace x = 3}
  (x + 1) donde x = 3
-> {sustituir 3 por x}
  3 + 1
->
4

Una función con tres argumentos:

add3nums = \ x y z -> x + y + z

Y podemos usarlo :

10 + 4* add3nums 1 2 3
= {- put extra parentheses in to show structure -}
  10 + ( 4* (add3nums 1 2 3) )
  -- >
  10 + (4*(1+2+3) )
  -- >
  10 + (4*6)
  -- >
  10 + 24
  -- >
  34

Springer regala libros!!

En el contexto del Covid 19, Springer regala libros.

Hay libros muy interesantes de Java, Scala, programación en paralelo y ciencia de datos.

Dejo link : https://link.springer.com/search/page/1?facet-content-type=%22Book%22&package=mat-covid19_textbooks&fbclid=IwAR2dD_eYkJArztAjIwg501C7aa9sSA9FGh8ov0PCS6-eY3QFxz2NVqNanHs&facet-language=%22En%22&facet-discipline=%22Computer+Science%22

Reducción en Haskell

El mecanismo para ejecutar programas funcionales es la reducción. La reducción es el proceso de convertir una expresión a una forma más simple. Conceptualmente, una expresión se reduce simplificando una expresión reducible (llamada "redex") a la vez. Cada paso se denomina reducción y usaremos -> para mostrar el resultado.

  3 + (4*5)
--  >
  3 + 20
--  >
23

La reducción es importante porque es el único medio de ejecución de un programa funcional. No hay declaraciones, como en los lenguaje imperativos; todo el cómputo se logra únicamente mediante la reducción de expresiones.

Cuando se realiza una reducción, solo hay una respuesta posible. En este ejemplo, el cálculo solo tiene una ruta posible:

  3 + (5 * (8-2))
--  >
  3 + (5 * 6)
--  >
  3 + 30
--  >
33

Solo hay una posible ruta de reducción en ese ejemplo, porque en cada paso la expresión actual contiene solo una redex.

Si una expresión contiene varios redexes, habrá varias rutas de reducción.

(3+4) * (15-9)
-- >
  7 * (15-9)
-- >
  7 * 6
-- >
 42

(3+4) * (15-9)
-- >
  (3+4) * 6
-- >
  7 * 6
-- >
  42

¡El resultado no depende de la ruta de reducción!
Cada ruta de reducción de terminación da el mismo resultado

Esto significa que :

• La corrección no depende del orden de evaluación.
• El compilador (o programador) puede cambiar el orden libremente para mejorar el rendimiento, sin afectar el resultado.
• Se pueden evaluar diferentes expresiones en paralelo, sin afectar el resultado. 

Libros de Java Code Geeks

Download IT Guides!   Java NIO Programming Cookbook java.nio (NIO stands for non-blocking I/O) is a collection of Java programming language APIs that offer features for intensive I/O operations. It was introduced with the J2SE 1.4 release...     IntelliJ IDEA Handbook IntelliJ IDEA is a Java integrated development environment (IDE) for developing computer software. It is developed by JetBrains, and is available as an Apache 2 Licensed community...     Amazon S3 Tutorial Amazon S3 (Simple Storage Service) is a web service offered by Amazon Web Services. Amazon S3 provides storage through web services interfaces (REST, SOAP, and BitTorrent). Amazon...     JUnit Programming Cookbook JUnit is a unit testing framework to write repeatable tests. JUnit has been important in the development of test-driven development, and is one of a family of unit testing frameworks...

Elementos básicos en Haskell, Parte 2

Veamos algunos elementos más básicos (y no tan básicos) de Haskell a través de la comparación con otros lenguajes. No entraremos en detalles sobre las construcciones de Haskell, solo mostraremos las similitudes con las construcciones de los lenguajes que podamos conocer.

En JavaScript, las funciones suelen ser bloques de código:

    function roots(a,b,c) {
        det2 = b*b-4*a*c;
        det  = sqrt(det2);
        rootp = (-b + det)/a/2;
        rootm = (-b - det)/a/2;
        return [rootm,rootp]
    }

En Haskell, escribiríamos esta función de la siguiente manera:

    roots a b c = 

        let

            det2 = b*b-4*a*c;

            det  = sqrt(det2);

            rootp = (-b + det)/a/2;

            rootm = (-b - det)/a/2;

        in

            [rootm,rootp]

Tenga en cuenta que la construcción let ... in ... es una expresión, por lo que devuelve un valor. Por eso no hay necesidad de una palabra clave de return.

En Python podríamos escribir una función con una condición como esta:

def max(x,y):

    if x > y:

        return x

    else:

        return y

Por supuesto, Haskell también tiene una construcción if-then:

    max x y = 

        if x > y

            then x

            else y

Una vez más, la construcción if ... then ... else ... es una expresión, por lo que devuelve un valor.

Muchos lenguajes proporcionan una declaración de caso para condiciones con más de dos opciones. Por ejemplo, Ruby proporciona una expresión de caso:

    Red = 1

    Blue = 2

    Yellow = 3

    color = set_color();

    action = case color 

        when Red then action1()

        when Blue then action2()

        when Yellow then action3()

    end

En Haskell, el caso funciona y se ve similar:

    data Color = Red | Blue | Yellow

    color = set_color

    action = case color of

        Red -> action1

        Blue -> action2

        Yellow -> action3

Sin embargo, tenga en cuenta cómo usamos el tipo como el valor para decidir el caso, donde en otros lenguajes necesitamos definir algún tipo de enumeración.

En Java y C ++ hay tipos de datos genéricos (también conocidos como tipos de plantillas, generic o template en ingles), como:

    Map<String,Integer> set = new HashMap<String,Integer>();

En Haskell, escribirías esto de la siguiente manera:

    set :: Data.Map.Map String Integer 

    set = Data.Map.empty

La principal diferencia es, por supuesto, que el conjunto en Haskell no es un objeto sino una variable inmutable, por lo que en Java haríamos :

    set.put("Answer",42)

En Haskell haríamos :

    set' = Data.Map.insert "Answer" 42 set

Debido a que en Haskell las variables son inmutables, el valor de retorno de la llamada de inserción está vinculado a una nueva variable en lugar de actualizar la variable en su lugar como en Java.

MiniKanren

Si hablamos de programación lógica siempre pensamos en Prolog. Pero existen otros lengujes lógicos, como  MiniKanren que es un lenguaje embebido en Clojure.

miniKanren es un DSL (Domain Specific Language) para la programación logica.

miniKanren es muy simple, con sólo tres operadores lógicos y un operador de interfaz.

La primera implementación fue en scheme, pero ahora existen implementaciones en diferentes lenguajes y tecnologías como Racket, Clojure, Haskell, Python, JavaScript, Scala, Ruby, OCaml, PHP y algunos más.

De igual manera que prolog, esta centrado en reglas y constraits.

En este post vamos a utilizar la implementación de Clojure, MiniKanren se encuentra en core.logic, para poder usarlo debemos tener una jdk y Leiningen.

Para crear un proyecto debemos utilizar Leiningen de la siguiente manera:

lein new logical

Con esta instrucción podemos crear un proyecto.

Ahora debemos agregar las dependencias:

(defproject logical "0.1.0-SNAPSHOT"
          :dependencies [[org.clojure/clojure "1.5.1"]
          [org.clojure/core.logic "0.8.5"]])

core.logic es donde se encuentra MiniKanren.

Ahora cuando lancemos el relp se levantará miniKanren:

$ lein repl
nREPL server started on port 48235 on host 127.0.0.1
REPL-y 0.3.0
Clojure 1.5.1
Docs: (doc function-name-here)
(find-doc "part-of-name-here")
Source: (source function-name-here)
Javadoc: (javadoc java-object-or-class-here)
Exit: Control+D or (exit) or (quit)
Results: Stored in vars *1, *2, *3, an exception in *e
user=> (use 'clojure.core.logic)
WARNING: == already refers to: #'clojure.core/== in namespace: user, being
replaced by: #'clojure.core.logic/==
nil
user=>

Ahora podemos empezar con el relp de MiniKanren, veamos un ejemplo :

user=> (run* [q] (== q 1))
(1)

En el ejemplo corremos el programa con run* que permite correr programas logicos y retorna un conjunto de soluciones.  q es una variable logica. Y el programa contiene la siguiente expresión :
 (== q 1)

Dicha expresión es unification, que se puede ver como pattern matching. Este programa devuelve 1 dado que q va valer 1 para que esto sea verdadero.

Le está pidiendo al lenguaje que intente hacer que los lados izquierdo y derecho sean iguales, suponiendo que eso sea posible. Los lados izquierdo y derecho se comparan como en las pruebas de igualdad normales, y cualquier variable lógica no vinculada está vinculada a valores que harían coincidir los dos lados. En este ejemplo, q está vinculado a 1, que es una solución porque no hay otras reglas.

Las expresiones en un programa lógico son objetivos. No devuelven verdadero o falso, pero tienen éxito o fracasan. Es posible que el éxito se logre varias veces de diferentes maneras o en absoluto. Esto nos lleva al último bit de nuestro ejemplo: el resultado.

Nuestro ejemplo devuelto (1). run * devuelve los valores de q que resultan en éxito.

En nuestro ejemplo, unificar q con 1 une q al número 1 y tiene éxito. Nuestro resultado es la lista que contiene el enlace único para q.

Veamos un objetivo fallido:

user=> (run* [q] (== q 1) (== q 2))
()

Este programa tiene dos expresiones, cada una un objetivo. Un programa con múltiples objetivos tendrá éxito solo si todos los objetivos tienen éxito, de manera similar a && u operadores en otros lenguajes. Aquí, la primera unificación unirá q al número 1 como antes y tendrá éxito. La segunda unificación fallará, ya que q está unido a 1 y 1 no se unifica con 2. Debido a que ningún enlace de q puede hacer que ambos objetivos tengan éxito, la lista resultante está vacía. Es decir, no hay solución. 

En proximos post seguiremos con este particular lenguaje,  por ahora dejo link: http://minikanren.org/