In fact, ladies and for men to wear Christian Louboutin Sandals really do not care too much about. You know, Christian Louboutin Evening first originally designed for men. Early 16th century, people riding knight to solve the foot in the stirrup sliding problems, which padded the heel. French monarch Louis XIV's personal interest in this achievement was later popular inChristian Louboutin Pumps, but it was mainly all male wearing high heels.

    But the success of women seeking high heels toward the throne today, the men had wanted to take back the "throne" is not impossible. Cone with, and ankle boots, this year's men's high heels in no way inferior to women. Prada's design has taken the attitude of compromise than "Hentian high" in height and bizarre Christian Louboutin Wedges, shoes like normal people more likely to be accepted, with the Prada shoes of complex designs, for men high-heeled shoes decorated in simple style brings out the man's masculinity. If you're really not satisfied with height, then select pairs of high heels like a man now!

Turtle, es un lenguaje para generar recorridos. Basicamente turtle tiene un estado y comandos a ejecutar sobre el estado.

El estado es la posicion (x,y) del objeto, la distacia a recorrer y un angulo que guia la direccion.

Los comando son:
F  -> avanzar adelante y dibujar una linea entre el punto del estado y el nuevo generado por la distancia y angulo.
f  -> avanzar adelante pero sin dibujar ninguna linea.
+ -> incrementar el angulo de estado con otro angulo constante.
- -> decrementar el angulo del estado con otro angulo constante.

Entonces, la anterior version generaba el resultado de un sistema L, ahora en esta nueva version, genero elementos del lenguaje turtle. Y una ves generados estos elementos, los interpreto con una libreria grafica, wxhaskell.

Les dejo algunas imagenes de los resultados obtenidos:

L-System

Hoy por la noche, cuando navegaba por la red me encontre con algo interesante. Y decidi iniciar un proyecto pequeño, un L-System en Haskell.

Este proyecto me trae recuerdos cuando estaba en la materia de Interfaces de Usuario con el Lic. Boris Calancha, en la que desarrollamos fractales con Java, de una forma recursiva. En aquel entonces no tenia la menor idea de que existia una generalizacion en la forma de generar fractales, pues hoy aprendi que si hay una generalizacion muy interesante, me intereso mas que todo por que esta relacionado con el campo de estudio que sigo, gramaticas, compiladores y haskell.

Pues resulta que un L-System es una tri-tupla, (muy parecido a las gramaticas que estudiamos en automatas)

G (V, w, P)

donde:

V: Alfabeto o conjunto de Simbolos
w: Simbolo Inicial
P: Reglas de Produccion o de re-writing

Asi, esta tri-tupla es capaz de generar fractales. La forma de hacerlo es atraves de derivaciones empezando con el simbolo inicial (no olviden que para hacer una derivacion usamos las reglas de produccion). Entonces de acuerdo al fractal que queramos, podemos aplicar (derivar) varias veces.

Veamos un ejemplo de wikipedia,

Example 1: Algae
variables : A B => alfabeto

constants : none

start  : A                      => simbolo inicial

rules  : (A → AB), (B → A)      => 2 reglas de produccion

which produces:

n = 0 : A

n = 1 : AB

n = 2 : ABA

n = 3 : ABAAB

n = 4 : ABAABABA

n = 5 : ABAABABAABAAB

n = 6 : ABAABABAABAABABAABABA

n = 7 : ABAABABAABAABABAABABAABAABABAABAAB

Cuando vemos este ejemplo, no parece animar ni convencer para seguir con el proyecto, sin embargo, si vale la pena seguir cuando se ve las imagenes que se puede generar (fractales), y eso se logra con la ayuda de una libreria grafica y un sistema denominado turtle para interpretacion de strings. Si quieres convencerte al igual que yo, debes ver las imagenes de wikipedia.

Bueno, y esta oportunidad queria compartirles la implementacion de una parte basica de este sistema L,

la forma en que represento un sistema L es asi:

type L = (V, W, P)              -- Sistema L

type V = [String]

type W = String

type P = [(Char, String)]       -- simbolo -> resultado == (simbolo, resultado)

genero un parser de acuerdo a las producciones:

--genParser :: [(Char, String)] -> Parser ? ?

genParser lst = if null lst

                then usererror "GenParser: the argument my not be empty list."

                else foldr1 (<|>) (map fun lst)

    where fun (val, res) = (res <$ pSym val)

y genero las iteraciones enviandole el sistema L y un N que indica el numero de iteraciones, esta funcion imprime el resultado en la pantalla.

generate :: L -> Int -> IO ()

Veamos algunos ejemplos de sistemas L:

{-

Example 1: Algae

variables : A B

constants : none

start  : A

rules  : (A → AB), (B → A)

-}
algae = (["A", "B"], "A", [('A', "AB"),('B',"A")])
{-

Example 2: Fibonacci numbers
variables : A B

constants : none

start  : A

rules  : (A → B), (B → AB)

-}
fib = (["A","B"], "A", [('A', "B"),('B',"AB")])
{-

Example 3: Cantor dust
variables : A B

constants : none

start  : A

rules  : (A → ABA), (B → BBB)

-}
cantor1 = (["A","B"], "A", [('A', "ABA"),('B',"BBB")])

cantor2 = (["-"," "], "-", [('-', "- -"),(' ',"   ")])

Ahora mostremos algunos ejemplos:

*Parser> generate fib 7
BABABBABABBABBABABBAB

*Parser> generate algae 7
ABAABABAABAABABAABABAABAABABAABAAB

*Parser> generate cantor1 4 ABABBBABABBBBBBBBBABABBBABABBBBBBBBBBBBBBBBBBBBBBBBBBBABABBBABABBBBBBBBBABABBBABA

*Parser> generate cantor2 4
- - - - - - - - - - - - - - - -
(Nota.- este utlimo no se grafico bien, pero se genera correctamente en consola)

Bueno eso es todo por hoy, si quieres ver el codigo y el proyecto, te invito que sigas este link.

Un Phantom Type, es una tecnica que nos permite hacer chequeo de tipos en tiempo de compilacion manteniendo una gramatica abstracta sencilla y comprensible.

Veamoslo con el ejemplo de la pagina fuente, tenemos un evaluador de expresiones, el cual es reescrito usando gramatica de attributos de esta manera:

DATA Expr
    | Val Int
    | Add le,lr : Expr
    | LE e1, e2 : Expr
    | Cond ex, iex, eex : Expr

DERIVING * : Show

ATTR Expr [ | | value : {Res}]

SEM Expr
    | Val lhs.value  = ResI @int
    | Add lhs.value  = case (@le.value, @lr.value) of
                               (ResI x, ResI y) -> ResI (x + y)
                               _                    -> error "Bad Arguments to Add"
    | LE lhs.value   = case (@e1.value, @e2.value) of
                               (ResI x, ResI y)  -> ResB (x <= y)
                               _                     -> error "Bad Arguments to LE"
    | Cond lhs.value = case (@ex.value) of
                               ResB b -> if b then @iex.value else @eex.value
                               _        -> error "Bad Arguments to Cond"

{
data Res = ResI Int | ResB Bool  deriving Show

main :: IO()
main = print e1
    where e1 = sem_Expr (Cond (LE (Val 3) (Val 5)) (Add (Val 1) (Val 2)) (Val 0)) t;br />             e2 = sem_Expr (Cond (Val 1) (Val 1) (Val 1))
}

Para probarlo, hacemos "uuagc -mdfcs AExpr.ag", y luego lo cargamos con "ghci AExpr.hs" y lo ejecutamos con "main", y el resultado sera "ResI 3".

Hasta aqui, todo anda bien, pero que pasa si en el ag cambiamos "e1", por "e2" en el "main"?despues ejecutarlo nos da un error de "Bad arguments to Cond", asi como lo esperabamos. Pero que pasaria si no queremos obtener estos errores, y que si quisieramos capturar estos errores en tiempo de compilacion?, una forma comun de hacerlo seria cambiando nuestro tipo algebraico y escribiendo una gramatica abstracta que tenga expresiones booleanas, enteras y demas cosas. Pero una forma es usando la tecnica de Phantom Type, como lo mensionamos mas antes, mantenemos una gramatica sencilla y nos permite usar el chequeo de tipos de Haskell.

Entonces, lo reescribimos de esta manera:

DATA Expr'
    | Val Int
    | Add le,lr : Expr'
    | LE e1, e2 : Expr'
    | Cond ex, iex, eex : Expr'

DERIVING * : Show

ATTR Expr' [ | | value : {Res}]
SEM Expr'
    | Val lhs.value  = ResI @int
    | Add lhs.value  = case (@le.value, @lr.value) of
                            (ResI x, ResI y) -> ResI (x + y)
                            _                    -> error "Bad Arguments to Add"
    | LE lhs.value   = case (@e1.value, @e2.value) of
                            (ResI x, ResI y)  -> ResB (x <= y)
                            _                     -> error "Bad Arguments to LE"
    | Cond lhs.value = case (@ex.value) of
                            ResB b -> if b then @iex.value else @eex.value
                            _        -> error "Bad Arguments to Cond"

{
data Res = ResI Int | ResB Bool  deriving Show

newtype Expr a = E Expr'
    deriving (Show)

-- wrappers
val :: Int -> Expr Int
val = E . Val

add :: Expr Int -> Expr Int -> Expr Int
add (E x) (E y) = E $ Add x y

le :: Expr Int -> Expr Int -> Expr Bool
le (E x) (E y) = E $ LE x y

cond :: Expr Bool -> Expr a -> Expr a -> Expr a
cond (E c) (E x) (E y) = E $ Cond c x y

eval :: Expr a -> Res
eval (E e) = sem_Expr' e

main :: IO()
main = print e1
    where e1 = eval (cond (le (val 3) (val 5)) (add (val 1) (val 2)) (val 0))
             --e2 = eval (cond (val 1) (val 1) (val 1))
}

Y ahora, ejecutamos lo mismo que la ultima ves y obtenemos el mismo resultado. Pero si cambiamos "e1" por "e2" en el "main", descomentamos "e2" e intentamos compilarlo, obtendremos un error de tipos en tiempo de compilacion, asi podremos contruir solo expresiones validas para nuestro evaluador.

Donde esta la tecnica de Phantom Type?, los hacemos atraves de "newtype Expr a = E Expr' ", el cual crea un nuevo tipo parametrizando el tipo deseado, el cual es controlado por el type chequer de Haskell. Este nuevo tipo, tiene en su contructor de datos algo asi como un tipo fantasma (Phantom Type), esto pienso asi porque:

-- el tipo del contructor de datos de Expr seria
E :: Expr' -> Expr a

-- por ejemplo el tipo de val, es
val :: Int -> Expr Int

Asi el tipo de "Expr a" no refleja el contenido que tiene empaquetado, por eso pienso que el tipo de adentro es el fantasma.

Volviendo al tema, el siguiente paso despues de crear el tipo fantasma, es escribir las funciones wrapper, los cuales se encargan de contruir el "Expr' " que queremos. Y tambien es aqui donde detallamos el chequeo de tipos para Haskell.

En el AG podemos borrar los casos erroneos de los expresiones case, sin afectar los resultados. Y para una mejor presentacion y cuidado, podemos exportar junto con el modulo, solo las funciones wrappers y tipos necesarios.

Bueno, esta es la manera en que implemente Phantom Types con AGs. Si ves el documento fuente, te preguntaras como implemetar GADTs con AGs, pues es algo que yo aun sigo preguntandome, y la verdad no se si habra una manera de hacerlo con AGs, pero como al autor de decia, Phantom Types es una solucion elegante, relativamente sencilla y estandard de Haskell en comparacion con GADTs.

Estructuras de Datos Funcionales vs. Imperativas

Los beneficios metodologicos de los lenguajes funcionales son bien conocidos, pero aun la mayoria de los programas son escritos en lenguajes imperativos como C. Esta aparente contradiccion es facilmente explicado por el hecho de que los lenguajes funcionales han sido historicamente mas lentos que sus mas tradicionales primos, pero esta brecha se esta reduciendo. Se han hecho impresionantes avances desde un amplio frente, desde tecnologias basicas de compiladores a analisis sofisticados y optimizaciones. Sin embargo, hay un aspecto de la programacion funcional que todo escritor de compiladores debe mitigar - el uso de estructuras de datos inapropiadas o inferiores.

Porque las estructuras de datos funcionales son mas dificultuosas para diseñar e implementar que las imperativas? Hay 2 problemas basicos. Primero, desde el punto de vista de diseño e implementacion de estructuras de datos eficientes, la estructura de la programacion funcional contra actualizaciones destructivas (ej. asignaciones) es una desventaja asombrosa, equivalente a confiscar los cuchillos de un chef master. Al igual que los cuchillos, las actualizaciones destructivas pueden ser dañinas cuando son mal usadas, pero tremendamente efectivas cuando son usadas apropiadamente. Las estructuras de datos imperativas a menudo confian en la asignacion de una forma crucial, y por eso se encuentran diferentes soluciones para los programas funcionales.

La segunda dificultad es que se espera que las estructuras de datos funcionales sean mas flexibles que sus contrapartes imperativas. En particular, cuando actualizamos una estructura de datos imperativa, tipicamente aceptamos que la version antigua de la estructura de datos ya no estara disponible, pero cuando actualizamos una estructura de datos funcional, esperamos que la antigua y nueva version de la estructura de datos estara disponible para futuros procesamientos. Una estructura de datos que soporta multiples versiones es llamado persistente [persistent], mientras que una estrutura de datos que permite solo una simple version en un tiempo es llamado efimera [ephemeral]. Los lenguajes de programacion funcional tienen la propiedad curiosa de que todas las estructuras de datos son auntomaticamente persistentes. 
Las estructuras de datos imperativas son tipicamente efimeras, pero cuando una estructura de datos persistente es requerida, los programadores imperativos no se sorprenden si la estructura de datos persistente es mas complicada y talves incluso asintoticamente menos eficiente que una equivalente estructura de datos efimera.

Ademas, los teoricos han establecido limites inferiores sugeriendo que los lenguajes de programacion funcional podrian ser fundamentalmente menos eficientes que los lenguajes imperativos en algunas situaciones. En vista de todos estos puntos, las estructuras de datos funcionales se parecen algunas veces al oso que baila, de quien se dice, "lo maravilloso no es que el danza muy bien, sino de que el danza de alguna manera!". En la practica, sin embargo, la situacion no es tan triste. Como podremos ver, es a menudo posible eleborar estructuras de datos funcionales que son asintoticamente tan eficientes como las mejores soluciones imperativas.

pero por fin encontre el bueno:

http://code.haskell.org/~dons/code/hs-plugins/

http://hackage.haskell.org/package/plugins

Nota.- Para su mejor comprencion he hecho varios cambios aqui, uno de ellos es el nombre del contructor de datos, de Persona a Per.

Ahora, Como definimos los setters y getters de una estructura de datos Persona?

Responderemos a esta pregunta, en el resto de este blog, asi nuestra estructura de datos es Persona con los datos de ci, nombre, apellido y edad.

s = "λ"

main = do

    writeFile "test.txt" s

    s2 <- readFile "test.txt"

    print (s == s2)

Si analizamos y hacemos correr este pequeño programa el resultado deberia ser True por logica, pero el resultado real es False.

Segun Christian creador del blog Luke Plant's

El problema es con la biblioteca estándar Haskell - muchas de las funciones previstas por el Prelud, System.IO, System.Posix y muchos otros son completamente roto (por diseño).  leer mas

Don Stewart dio la siguiente solucion para este problema

    import Prelude hiding (writeFile, readFile, print)

    import System.IO.UTF8

    s = "λ"

    main = do

        writeFile "test.txt" s

        s2 <- readFile "test.txt"

        print (s == s2)

Si hacemos correr este ejemplo el resultado sera True.

Hoy revizaremos una forma de instalar Cabal, una herramienta muy comoda para instalar y construir aplicaciones y librerias de haskell.

Para una informacion mas detallada puedes ver Biliotecas adicionales con Cabal.

Pero hagamos lo nuestro:

La forma que abordaremos es instalar cabal atraves de un bootstrap, el cual se encargara de descargar las fuentes, configurarlas e instalarlas.

Antes de continuar debemos preveer que disponemos de 3 cosas basicas (Doy por supuesto que tienen instalado ghc 8 o superior):

Nota.- Los siguientes comandos son para un sis ope basado en Debian (esto incluye a ubuntu).

1.- parsec library of ghc.
     Si no tienes instalado, puedes instalarlo con:
        apt-get install libghc6-parsec-dev libghc6-parsec-doc

2.- network library of ghc.
     Si no tienes instalado, puedes instalarlo con:
        apt-get install libghc6-network-dev libghc6-network-doc libghc6-network-prof

3.- zlib.h header of C.
        Podemos encontrar el header zlib.h en la libreria zlib1g-dev.
        Comandos para instalarlo:
        apt-get install zlib1g-dev

Despues de preever las anteriores cosas podemos descargar el Cabal Install Tool de la pagina http://www.haskell.org/cabal/download.html.

Descargar Cabal Install Tool 0.6.2.tar.gz, y ejecutamos el bootstrap.sh

Ejecutando ./bootstrap.sh se descargara las fuentes de cabal de la web, luego se configuran y finalmente se instalaran en tu sistema (Debes notar que necesitaras una coneccion a internet cuando estes ejecutando el bootstrap).

Ahora que ya esta instalado cabal, debemos publicar el comando cabal ubicado en /root_or_user_/.cabal/bin. Podriamos crear un enlace a este comando en /usr/bin con
         ln -s /root/.cabal/cabal cabal

Antes de usarlo debemos actualizar la lista de paquetes con
       cabal update

Ahora podremos disfrutar de Cabal, e instalar otras aplicaciones.

Hayoo! es un motor de búsqueda especializado en documentación del  API Haskell. El objetivo de Hayoo! es proporcionar una forma interactiva, fácil de usar la interfaz de búsqueda de la documenation de Haskell para los diversos paquetes y bibliotecas.

Seria super que lo testen, ya que si falta alguna documentacion solo hay que escribirles a los desarrolladores al siguiente correo hayoo@holumbus.org para que lo puedan agregar.

Para mi es mejor que hoogle