http://blog.comunidadhaskell.org/pg/blog/carliros/read/107/estructuras-d

En esta oportunidad quiero compartir una traduccion de una de los subtitulos del libro: Purely Functional Data Structure [Chris Okasaki], que me parecio muy buena.

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.

http://blog.comunidadhaskell.org/pg/blog/darkben/read/104/hsplugins-por-

Eso de que pongan en diferentes lados este codigo pero en cada sitio versiones diferentes es grrrraaave!!

pero por fin encontre el bueno:

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

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

http://blog.comunidadhaskell.org/pg/blog/carliros/read/96/setters-and-ge

En Haskell podemos tambien hacer setters y getters de una forma sencilla.

Tenemos este codigo:

module Main where

data Persona = Persona { ci       :: CI
                      , nombre   :: Name
                      , apellido :: LastName
                      , edad     :: Edad
                      } deriving Show

type CI       = Int
type Name     = String
type LastName = String
type Edad     = Int

-- instancias
juan :: Persona
juan = Persona 14322 "juan" "block" 35

pepe :: Persona
pepe = Persona 44533 "pepe" "torrez" 15

Entonces podemos obtener los datos de cada instancia llamando a la funcion constructora de cada elemento de Persona.

Ejemplo:

*Main> ci pepe

nos retornaria el CI de 'pepe', tambien podemos usar nombre, apellido o edad.

Para setear un valor, podemos hacer

*Main> juan {nombre = "juanes"}
Persona {ci = 14322, nombre = "juanes", apellido = "block", edad = 35}

En la parte de modificar un valor de la instancia es diferente, porque lo que en realidad hace es modificar el valor en una nueva instancia sin tocar su parametro entrante. Solo toma de esté la informacion que no se modifica. Ejemplo:

*Main> juan {edad = 0}
Persona {ci = 14322, nombre = "juan", apellido = "block", edad = 0}
*Main> juan
Persona {ci = 14322, nombre = "juan", apellido = "block", edad = 35}

http://blog.comunidadhaskell.org/pg/blog/antonio/read/95/haskell-string-

Un problema muy interesante

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.

http://blog.comunidadhaskell.org/pg/blog/carliros/read/89/cabal-common-a

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.

http://blog.comunidadhaskell.org/pg/blog/antonio/read/88/hayoo-beta-04

Recientemente se lanzo Hayoo! beta 0.4.

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 

http://blog.comunidadhaskell.org/pg/blog/carliros/read/79/irc-channel-ha

Navegando por la Web encontre un Canal IRC.

No sabia que existia un lugar online en donde se puede chatear con otros haskelleros.

Segun ellos, este IRC puede ser usado para aprender mas acerca de haskell, enterarse de nuevas cosas de haskell, porque muchas nuevas cosas primero dice que aparecen en el irc.

Bueno, no quise esperar mucho para unirme.

Para unirte puedes usar cualquier chat que te permita unirte al irc, en lo particular yo use irssi, pero puedes usar pidgin u otro.

apt-get install irssi

luego, > irssi -c chat.freenode.net -n tunickname

puedes usar cualquier nick que no este repetido actualmente, pero si despues dela primera ves quieres mantenerte con ese nick deberas registrarte, como ?, puedes ver frenode-register

una ves adentro seleccionar el salon al que quieres ingresar, en nuestro caso

/join #haskell

y listo, a chatear con los cuates.

Para mas informacion puedes ver este enlace irc-haskell, en el cual encontraras otros salones de chat relacionados a haskell.

http://blog.comunidadhaskell.org/pg/blog/Grace/read/77/icfp-programming-

Que les parece ... ya se publico las fechas para el ICFP Programming Contest 2009

no falta mucho asi que a cargar pilas !! 

Donde y cuando  practicamos ? 

http://blog.comunidadhaskell.org/pg/blog/nelson/read/71/un-simple-servid

buscando informacion de como implementar un servidor web en haskell me encontre con este ejemplo basico usando lo q tiene haskell.

http://lstephen.wordpress.com/2008/02/14/a-simple-haskell-web-server/

http://blog.comunidadhaskell.org/pg/blog/andrea/read/59/inauguracin-del-

Gracias a todas las personas que asistieron apoyaron y apoyan de alguna forma las actividades de la comunidad Haskell, los invitamos a suscribirse a la lista, el blog, la wiki y formar parte de nuestros proyectos, pretendemos potenciar poco a poco esta idea, les pedimos nos ayuden a difundirla.