Libros para comenzar con Haskell

Encontre un post sobre Libros para aprender Haskell desde cero. Nombra a varios :

1. Real World Haskell : Esta puede ser la mejor guía para aprender Haskell. Publicado por primera vez en 2008, este libro todavía se mantiene hoy con más de 700 páginas de tutoriales introductorios y guías para principiantes.
2. Learn Haskell for a great good! : muy bueno!! La verdad muy divertido y fácil de leer. 
3. Haskell: The Functional Programming Profession : La programación funcional no es un tema fácil de entender. Y comenzar con Haskell puede ser aún más complejo, a menos que, por supuesto, tenga el material de estudio adecuado. Haskell: The Functional Programming Profession es una colección de 600 páginas actualmente en su 3ª edición. Creo que este es uno de los mejores iniciadores de la programación funcional. Recorre los principios básicos en temas más avanzados.
4. Beginning Haskell: A Project-Oriented Approach : El estudio se basa en el trabajo que un proyecto le permite ver cómo se comporta Haskell en el mundo real. Beginning Haskell: A Project-Oriented Approach es un proceso de aprendizaje paso a paso que tiene perfecto sentido. Aún aprenderá todos los conceptos teóricos, como flechas y monoides. Pero aprendes pragmáticamente. Puede obtener este libro con cero experiencia Haskell y siempre caminar con una buena comprensión de la programación funcional.
5. Thinking with Haskell Functionally : Think Functionally Haskell es otro libro que inicia a los estudiantes ansiosos de programación funcional en el mundo de Haskell. Aprenderá a escribir código funcional en el camino correcto, centrándose en modelos matemáticos.
6. Web application development with Haskell and Yesod : Cuando piensas en desarrollar aplicaciones web, rara vez piensas en Haskell. Pero con el framework Yesod puede crear aplicaciones web RESTful Haskell desde cero.
7. Haskell Design Standards : Las plantillas de desarrollo y diseño son una gran razón por la que muchos desarrolladores se unen en lenguajes funcionales como Haskell. Puede lograr mucho y el flujo de trabajo puede estudiarse y aplicarse de manera consistente en muchos modelos de diseño domínios. Haskell lo lleva más allá de la lógica funcional para ayudarlo a comprender cómo diseñar mejor sus proyectos Haskell. Este es un libro avanzado que cubre varias técnicas de desarrollo como Haskell Imperative, Lazy e Iteratee para I/O Channels

Dejo link:
https://www.freelancinggig.com/blog/2017/05/24/best-haskell-programming-books-beginners-2017/

Aprende Haskell por amor a vos!!

Como ustedes sabrán estoy estudiando Scala, Elixir y otros lenguajes pero por un revés de la vida me ha llevado a retomar mis estudios de Haskell.

Porque es buena idea estudiar Haskell y no solo programación funcional? Bueno se me ocurren las siguientes razones:

1. Es un lenguaje funcional puro, es como aprender objetos con Smalltalk, la mejor opción para aprender un paradigma es utilizar el lenguaje más puro que aplique este paradigma.
2. Es de tipado estático: Cuando compilamos un programa, el compilador sabe que una función es entera, cuales son cadenas de texto, etc. Gracias a esto un montón de posibles errores son capturados en tiempo de compilación. Si intentamos sumar un número y una cadena de texto, el compilador lanzara un error. Haskell usa un fantástico sistema de tipos que posee inferencia de tipos. Esto significa que no tenemos que etiquetar cada trozo de código explícitamente con un tipo porque el sistema de tipos lo puede deducir de forma inteligente. La inferencia de tipos también permite que nuestro código sea más general, si hemos creado una función que toma dos números y los suma y no establecemos explícitamente sus tipos, la función aceptará cualquier par de parámetros que actúen como números.
3. Haskell es elegante y conciso. Básicamente tenemos toda las ventajas de la programación funcional, por lo tanto los programas Haskell son normalmente más cortos que los equivalentes imperativos. Y los programas cortos son más fáciles de mantener que los largos, además de que poseen menos errores. 
4. Haskell es un lenguaje codicioso, no el lenguaje, los que lo diseñaron. Ellos hicieron que haskell sea puro y que siempre tome el camino más puro para resolver los problemas. Haskell implementa un montón de conceptos lo cual trae con sigo que aprendamos mucho. Y esos conceptos sean interpolables a otros lenguajes. 
5. Haskell fue creado por unos tipos muy inteligentes (todos ellos con sus respectivos doctorados). El proyecto de crear Haskell comenzó en 1987 cuando un comité de investigadores se pusieron de acuerdo para diseñar un lenguaje revolucionario. En el 2003 el informe Haskell fue publicado, definiendo así una versión estable del lenguaje.
6. Es divertido! Si te gusta aprender y resolver problemas, este lenguaje es para vos!

Un lugar muy bueno para empezar es : http://aprendehaskell.es/

Prueba Haskell!

Probar Haskell es fácil.

Primero podemos usar nuestro navegador :  https://www.haskellmooc.co.uk , es un entorno interactivo de Haskell, ¡listo para usar!

Puede instalar el compilador / intérprete Haskell.

Vayamos a https://www.haskell.org/platform para obtener la plataforma Haskell, es muy fácil de instalar.

Luego de instalar haskell podemos utilizar el intérprete de Haskell ghci

Para iniciar el intérprete interactivo Haskell ghci, simplemente escriba ghci en su terminal:

[wim @ fp4 ~] $ ghci
GHCi, versión 7.8.3: http://www.haskell.org/ghc/:? por ayuda
Cargando paquete ghc-prim ... enlace ... hecho.
Cargando paquete integer-gmp ... enlace ... hecho.
Cargando la base del paquete ... enlazando ... hecho.
Preludio>
 - Evaluar una expresión -
Preludio> 3 + 4
7

Y Listo!!

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.

¡Aprende Haskell por el bien de todos!

Bienvenido a ¡Aprende Haskell por el bien de todos! Si estás leyendo esto probablemente quieras aprender Haskell. Pues bien, has venido al sitio adecuado, pero primero vamos a hablar un poco sobre esta guía.

Decidí escribir esta guía porque quería arraigar mi propio conocimiento de Haskell y porque pensé que podía ayudar a la gente que empezaba con Haskell. Existen bastantes manuales y guías sobre Haskell por la red. Cuando empecé con Haskell no lo leí un único documento. La forma en la que aprendí Haskell fue leyendo varios artículos y guías, porque explicaban el mismo concepto de diferentes formas. Así, yendo a través de varios documentos, fui capaz de juntar todas las piezas y entonces todo encajó. De modo que, esto es un intento más de añadir otro útil documento para aprender Haskell de forma que tengas más oportunidades de encontrar uno que te guste.

Así comienza el sitio que tiene como objetivo enseñarnos haskell, es muy recomendable.

Dejo el link:
http://aprendehaskell.es/

Por que deberías aprender Haskell?

He escrito bastante de Haskell, porque me parece importante; y esto por que? Porque es un lenguaje funcional puro que gano terreno gracias a la innovación, Scala por ejemplo toma muchos conceptos de Haskell. Que sea un lenguaje funcional puro trae consigo muchas ventajas. Por ejemplo no lidiar con estados.

Haskell es lazy. En castellano perezoso lo que significa que el espera que necesites un valor para ejecutar código. Esto en ciertos casos es más eficiente. En Haskell lo que se guarda una variable por ejemplo, son funciones no valores, y cuando necesitamos valores se ejecuta la función.

Haskell es de tipado estático, aunque no necesitemos especificar el tipo. El lo infiere y luego trabaja siempre con ese tipo. Esto es muy útil para minimizar errores.

Haskell es conciso y elegante. Dado que es un lenguaje de programación declarativo, se puede hacer mucho con muy poco código.

Haskell fue creado por un grupo de investigación. El proyecto de crear Haskell comenzó en 1987 cuando un comité de investigadores se pusieron de acuerdo para diseñar un lenguaje revolucionario. En el 2003 el informe Haskell fue publicado, definiendo así una versión estable del lenguaje.

Quien utiliza Haskell??

La programación funcional (en particular Haskell) es utilizada por un número creciente de empresas en la actualidad, incluidas algunas grandes multinacionales.

Hay listas de empresas que utilizan Haskell en el sitio web de Haskell y en Quora. Algunas companias destacadas son Facebook, IBM, Twitter, AT&T, Bank of America, Barclays Capital, NVIDIA y Microsoft.

Facebook utiliza Haskell en varios proyectos, por ejemplo Lucha contra el spam con Haskell.

Galois ha sido un usuario y promotor activo de Haskell durante más de una década. Esta charla presenta tres estudios de caso de algunos de sus proyectos.

The New York Times tiene una agradable charla sobre Haskell en la sala de redacción.

Elementos básicos en Haskell

En casi todos los lenguajes de programación puede crear expresiones como:

    (b * b-4 * a * c) / 2 * a

y puedes asignar estas expresiones a variables:

    v = (b * b-4 * a * c) / 2 * a

En Haskell, también puedes hacer esto, y lo que es más: las expresiones son realmente todo lo que hay, no hay declaraciones.


En Python, puede definir una función como

    def hello(name):
        return "Hello, "+name

En Haskell puedes escribir esto simplemente como:

    hello name = "Hello, "++name

C tiene tipos, por ejemplo:

    int f (int x, int y) {
        return x*y+x+y;
    }

Haskell tiene un sistema de tipos mucho más poderosos que C, y hablaremos mucho sobre los tipos:

    f :: Int -> Int -> Int
    f x y =  x*y+x+y

En muchos lenguajes, como Python, JavaScript, Ruby, ... puedes crear listas como:

    lst = ["A", "lista", "de", "cadenas"]

Haskell también usa esta sintaxis para las listas.

Para unir listas, en Python podrías escribir

    lst = [1,2] + [3,4]

En Haskell esto sería muy similar:

    lst = [1,2] ++ [3,4]

En JavaScript puede definir funciones anónimas (funciones sin nombre) como:

    var f = función (x, y) {return x * y + x + y};

En Haskell, estas funciones anónimas se denominan funciones lambda y en realidad son la base del lenguaje. Nuevamente, la sintaxis es muy compacta:

    f = \ x y -> x * y + x + y

Finalmente, en muchos lenguaje, las funciones pueden operar en funciones. Por ejemplo, en Perl puede modificar los elementos en una lista usando:

    map sub ($x){$x*2+1}, [1..10]

Haskell proporciona muchas de estas llamadas funciones de orden superior y le permite definir las suyas propias.

    map (\x -> x*2+1) [1..10]

Elementos básicos en Haskell

Expresiones: En casi todos los lenguajes de programación puedes crear expresiones como:

    (b * b-4 * a * c) / 2 * a

y puede asignar estas expresiones a variables:

  v = (b*b-4*a*c)/2*a

En Haskell, también puede hacer esto, y lo que es más: las expresiones son realmente todo lo que hay, no hay declaraciones.

Funciones: En Python, puede definir una función como

    def hello(name):

        return "Hello, "+name

En Haskell puedes escribir esto simplemente como:

   hello name = "Hello, "++name

Tipos : C tiene tipos, por ejemplo:

    int f (int x, int y) {

        return x*y+x+y;

    }

Haskell tiene tipos mucho más poderosos que C, y se definen en una linea diferente de la función :

    f :: Int -> Int -> Int

    f x y =  x*y+x+y

Listas : En muchos lenguajes, p. Ej. Python, JavaScript, Ruby,… puedes crear listas como:

    lst = ["A", "lista", "de", "cadenas"]

Haskell también usa esta sintaxis para listas.

Para unirse a listas, en Python puede escribir

    lst = [1,2] + [3,4]

En Haskell esto sería muy similar:

    lst = [1,2] ++ [3,4]

Funciones anónimas : En JavaScript puede definir funciones anónimas (funciones sin nombre) como:

var f = function (x, y) {return x * y + x + y};

En Haskell, estas funciones anónimas se denominan funciones lambda y en realidad son la base del lenguaje. Nuevamente, la sintaxis es muy compacta:

f = \x y -> x*y+x+y

\ representa el símbolo lambda. 

Funciones de orden superior : Finalmente, en muchos lengujes, las funciones pueden operar sobre funciones. Por ejemplo, en Perl puede modificar los elementos en una lista usando:

    map sub ($x){$x*2+1}, [1..10]

Haskell proporciona muchas de las llamadas funciones de orden superior y le permite definir las suyas propias.

    map (\x -> x*2+1) [1..10]

Primeros pasos en Haskell

Haskell es un lenguaje funcional que les aconsejo que aprendan. Antes que nada vamos a instalar el compilador GHC o Hugs. Yo voy a usar GHC, si usamos una distro basada en Debian, podemos hacer lo  siguiente:

apt-get install ghc6 libghc6-mtl-dev

y si tenemos un RHEL podemos hacer:

yum install ghc6 libghc6-mtl-dev

GHC puede tomar un script Haskell y compilar pero también puede trabajar de modo interactivo; lo que se conoce como RELP. Luego de instalar estos paquete ejecutamos ghci en una consola:

[emanuel@localhost ~]$ ghci
GHCi, version 7.4.1: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> 2 +2
4
Prelude> 5 + 5
10
Prelude> 2 * 2
4
Prelude> 5 / 2
2.5
Prelude> True  && False
False
Prelude> 5 == 5
True
Prelude> 5 /= 4
True
Prelude> 5 + "hola"

<interactive>:9:3:
    No instance for (Num [Char])
      arising from a use of `+'
    Possible fix: add an instance declaration for (Num [Char])
    In the expression: 5 + "hola"
    In an equation for `it': it = 5 + "hola"
Prelude>

Como podemos ver podemos utilizar Haskell como calculadora, pero en la ultima linea, que sucedió? El error que fue lanzado fue porque quise sumar 5 de tipo numero con una palabra o String "hola" y como Haskell es de tipado estático, no puede sumar estas cosas. 

También podemos llamar funciones de la siguiente forma:

Prelude> min 3 5

3

Prelude> max 100 100

100

Prelude> max 3000 3 

3000

Como pueden ver el llamado de funciones no necesita los paréntesis como java o C++ o C. 

Por este post hemos avanzado bastante, en próximos post vamos a seguir aprendiendo Haskell!

Introducción a las expresiones y ecuaciones en Haskell

¡Haskell no tiene declaraciones, solo expresiones!

En un lenguaje imperativo como C o Java, hay expresiones que denotan cálculos a pequeña escala (2 * x), y declaraciones que manejan secuenciación, bucles, condicionales y toda la operación a gran escala del programa.

Los lenguajes de programación funcionales puros no tienen ningún enunciado: no hay asignaciones ni saltos. En cambio, todo el cálculo se realiza evaluando expresiones

Una expresión se evalúa como un resultado (generalmente escrito e⇝r pero usaremos e -> r). Haskell usa una notación similar para números y operadores como la mayoría de los lenguajes :

    2 -> 2
    3 + 4 -> 7
    3 + 4 * 5 {equivalente a 3+ (4 * 5)} -> 23
    (3 + 4) * 5 {equivalente a 7 * 5} -> 35

Los paréntesis se usan para agrupar, al igual que en matemáticas.

Los operadores tienen prioridad, p. ∗ tiene una precedencia "más estricta" que +, entonces 2 + 3 ∗ 4 significa 2 + (3 ∗ 4).

Las expresiones pueden contener llamadas a funciones.

Una función toma argumentos, realiza algunos cálculos y produce resultados.

La función abs da el valor absoluto de un número. Para usar una función, se aplica a un argumento. Escribe la función seguida del argumento, separada por un espacio.

  abs 5 -> 5
  abs (-6) -> 6

Los paréntesis son para agrupar

  2 + 3 * 5
  2+ (3 * 5): puede ser más claro para algunos lectores
  abs 7

Por ejemplo, min y max son funciones que toman dos argumentos. Los argumentos se dan después de la función, separados por espacios en blanco.

Escriba min 3 8, no escriba min (3, 8);

    min 3 8 -> 3
    max 3 8 -> 8

La aplicación de funciones se une más fuerte que cualquier otra cosa. Entonces f x + 3 significa (f x) + 3 y no f (x + 3). Si un argumento para una función es una expresión, se deberá poner entre paréntesis.

Las ecuaciones se usan para dar nombres a los valores. Por ejemplo:

respuesta = 42

Una ecuación en Haskell es una ecuación matemática: dice que el lado izquierdo y el lado derecho denotan el mismo valor. El lado izquierdo debe ser un nombre al que le estás dando un valor.

Correcto: x = 5 * y
Incorrecto: 2 * x = (3 * x) ** 2 - La reasignación no está permitida en un FPL puro

A un nombre solo se le puede dar un valor. Los nombres a menudo se denominan "variables", pero no varían.

En Haskell las variables son constantes!

    n = 1 - ¡bien!
    x = 3 * n - bien
    n = x - Incorrecto: solo puede tener una definición de n

Una vez que le da un valor a un nombre, ¡nunca podrá cambiarlo!

Esto es parte del significado de "puro" y "sin efectos secundarios"

¿Qué pasa con n = n + 1?

En idiomas imperativos, decimos con frecuencia n: = n + 1 ¡Esta es una tarea, no una ecuación! Significa (1) calcular el lado derecho, utilizando el antiguo valor de n; luego (2) descarte el antiguo valor de n y sobrescríbalo con el nuevo valor. No hay ecuaciones en lenguajes imperativos como C y Java.

En Haskell, es válido escribir n = n + 1. ¡Esta es una ecuación, no una tarea! Significa: calcular el valor de n que tiene la propiedad de que n = n + 1. Haskell lo intentará y fallará.

¿Cómo puedes calcular sin asignaciones?

Piense en una declaración de asignación como hacer tres cosas:
Evalúa el lado derecho: calcular un valor útil.
Descarta el valor de la variable en el lado izquierdo: destruye un valor que podría o no ser útil.
Guarda el valor útil del RHS en la variable.

En un lenguaje funcional puro Nunca destruimos viejos valores. Simplemente calculamos nuevos útiles.

Si el valor anterior era realmente inútil, el recolector de basura recuperará su almacenamiento.

¿Que es Haskell?

Haskell es un lenguaje de programación. En particular, es un lenguaje de tipos polimórficos, de
evaluación perezosa, puramente funcional, muy diferente de la mayoría de los otros lenguajes de
programación. El nombre del lenguaje se debe a Haskell Brooks Curry. Haskell se basa en el lambda cálculo, por eso se usa lambda como un logo.

Haskell es un lenguaje de programación moderno, estándar, no estricto, puramente funcional. Posee todas las características avanzadas, incluyendo polimorfismo de tipos, evaluación perezosa y
funciones de alto orden. También es un tipo de sistema que soporta una forma sistemática de sobrecarga y un sistema modular.

Está específicamente diseñado para manejar un ancho rango de aplicaciones, tanto numéricas como
simbólicas. Para este fin, Haskell tiene una sintaxis expresiva y una gran variedad de constructores de
tipos, a parte de los tipos convencionales (enteros, punto flotante y booleanos). Hay disponible un gran número de implementaciones. Todas son gratis. Los primeros usuarios, tal vez, deban empezar con Hugs, un intérprete pequeño y portable de Haskell.

Tipos en Haskell

Haskell es un lenguaje de programación fuertemente tipado. Los tipos son penetrantes (pervasive), y presenta además un potente y complejo sistema de tipos. Si están familiarizados con Java, C, Modula, o incluso ML, el sistema de tipos de Haskell es diferente y algo más rico.

Una parte importante del lenguaje Haskell lo forma el sistema de tipos que es utilizado para detectar
errores en expresiones y definiciones de función.

El universo de valores es particionado en colecciones organizadas, denominadas tipos. Cada tipo tiene asociadas un conjunto de operaciones que no tienen significado para otros tipos, por ejemplo, se puede aplicar la función (+) entre enteros pero no entre caracteres o funciones.

Una propiedad importante del Haskell es que es posible asociar un único tipo a toda expresión bien
formada. Esta propiedad hace que el Haskell sea un lenguaje fuertemente tipado. Como consecuencia, cualquier expresión a la que no se le pueda asociar un tipo es rechazada como incorrecta antes de la evaluación.

Por ejemplo:
f x = 'A'
g x = x + f x

La expresión 'A' denota el carácter A . Para cualquier valor de x , el valor de f x es igual al caracter 'A' , por tanto es de tipo Char . Puesto que el (+) es la operación suma entre números, la parte derecha de la definición de g no está bien formada, ya que no es posible aplicar (+) sobre un carácter.

El análisis de los escritos puede dividirse en dos fases: Análisis sintáctico, para chequear la corrección sintáctica de las expresiones y análisis de tipo, para chequear que todas las expresiones tienen un tipo correcto.

Breve historia de Haskell

Había una vez un matemático llamado Alonzo Church en la Universidad de Princeton. Church era el supervisor de doctorado de Alan Turing. Church ideó un modelo matemático de funciones llamado cálculo lambda. 

El cálculo lambda captura la esencia de la computación. Implica abstracción de funciones (como definir funciones en Haskell) y aplicaciones (como llamar a funciones en Haskell).

A Uno de los primeros lenguajes de programación de alto nivel fue LISP (que significa procesamiento de lista). LISP adoptó un estilo funcional. Permitía que las funciones del usuario fueran definidas y pasadas como valores. 

Durante la década de 1980, muchos investigadores inventaron y ampliaron varios lenguajes de programación funcionales. Los lenguajes como ML, Hope y Miranda. Sin embargo, la investigación estaba fragmentada en varios lenguajes, y muchos de ellos no eran de "código abierto". Entonces, un grupo de académicos formó un comité para diseñar e implementar un nuevo lenguaje, que se utilizaría como vehículo para la investigación, así como para la enseñanza de la programación funcional.

Después de varios años de trabajo y argumentos, el comité publicó el primer Informe del lenguaje Haskell en 1990. Este fue un hito importante: al fin hubo un lenguaje funcional común en torno al cual la comunidad de investigación podía unirse.

El lenguaje ha crecido en popularidad desde entonces, a pesar del objetivo declarado de evitar el éxito a toda costa. Hay varias implementaciones disponibles gratuitamente. El más utilizado es el Glasgow Haskell Compiler, que tiene un intérprete (ghci) y un compilador (ghc). Estos forman parte integral de la plataforma Haskell. Mucha gente contribuyó a este ecosistema de software. 

Esta historia puede estar mejor contada en este video: 

Let y where en Haskell

El alcance o Scoping es una forma de mantener sus programas ordenados. Implica limitar la región del programa en la que los nombres "existen" y se pueden usar.

En Haskell, una expresión let proporciona un alcance local. Una expresión let tiene una serie de ecuaciones que definen valores variables y una expresión final (después de la palabra clave in) que calcula un valor con esas variables en el alcance.

Aquí hay un ejemplo:

let x = 2

in x*x

Se pueden definir múltiples variables en un solo let

let x = 2

     y = 3

in x+y

Tenga en cuenta que los nombres de las variables se alinean uno debajo del otro. Esta es una buena práctica de formateo, pero también es necesaria para que Haskell interprete el código correctamente. Al igual que Python, el espacio en blanco es importante en Haskell.

A veces, en let, una de las variables puede depender de otra: en la función a continuación, los galones dependen de milespergallon:

journeycost :: Float -> Float -> Float

journeycost miles fuelcostperlitre = 

 let milespergallon = 35

     litrespergallon = 4.55

     gallons = miles/milespergallon

 in (gallons*litrespergallon*fuelcostperlitre)

Aquí hay un ejemplo geométrico:

let diameter = 2*radius

     circumference = pi*diameter

in (diameter, circumference)

Por cierto, pi es una constante definida en el "prelude" de Haskell.

Hay otra sintaxis para introducir variables locales, la cláusula where. Como hemos visto, Haskell es la navaja suiza de los lenguajes de programación: hay muchas formas de hacer las cosas.

La palabra clave where, dentro de una ecuación, proporciona definiciones para las variables que se usan en la ecuación.

Aquí hay un par de ejemplos

squareplusone :: Int -> Int

squareplusone x = xsquared + 1

 where xsquared = x*x

Tengan en cuenta que es necesaria la sangría. 

Como let, podemos tener múltiples variables dentro de una cláusula where:

cel2fahr :: Float -> Float

cel2fahr x = (x*scalingfactor) + freezingpoint

 where scalingfactor = 9.0/5.0

           freezingpoint = 32

Las variables definidas en la cláusula where se alinean una debajo de la otra.

let y where son muy similares:

• Ambos introducen un alcance local.
• Ambas permiten escribir cualquier cantidad de ecuaciones.
• Ambos permiten que las ecuaciones se escriban en cualquier orden, y las variables definidas en cualquier ecuación se pueden usar ("están dentro del alcance") en las otras ecuaciones.

Sin embargo, hay algunas diferencias importantes:

• let se puede usar en cualquier lugar donde se permita una expresión.
• where en clasuras que no son expresiones; 
• let se pueden usar para proporcionar algunas variables locales para una ecuación de nivel superior.

Tipos en Haskell parte 2

Seguimos con los tipos en Haskell : https://emanuelpeg.blogspot.com/2020/04/tipos-en-haskell.html

Me quedaron 2 post cortitos, medio que podría haber hecho 1, cosas que pasan.

En la definición de una función se puede incluir información de tipo mediante una expresión de la forma A::B para indicar al sistema que “A es de tipo B”. Por ejemplo:

cuadrado:: Int -> Int //no es necesario, pero es buena práctica
cuadrado x = x * x

La primera línea indica que la función cuadrado es del tipo "función que toma un entero y devuelve un entero".

Esto no es obligatorio dado que con la inferencia de tipos, haskell puede inferir esto. Pero, sí es una buena práctica, ya que el Haskell chequea que el tipo declarado coincide que el tipo inferido por el sistema a partir de la definición, permitiendo detectar errores de tipos.

Existen varios “tipos” predefinidos del sistema Haskell, éstos se podrían clasificar en: tipos básicos,
cuyos valores se toman como primitivos, por ejemplo, Enteros, Flotantes, Caracteres y Booleanos; y
tipos compuestos, cuyos valores se construyen utilizando otros tipos, por ejemplo, listas, funciones y
tuplas.

Funciones en Haskell

En Haskell las funciones se definen usualmente a través de una colección de ecuaciones. Por ejemplo, la función inc puede definirse por una única ecuación:

inc n = n+1

Una ecuación es un ejemplo de declaración. Otra forma de declaración es la declaración de tipo de una función o type signature declaration, con la cual podemos dar de forma explícita el tipo de una función; por ejemplo, el tipo de la función inc:

inc :: Integer -> Integer

Si a y b son dos tipos, entonces a->b es el tipo de una función que toma como argumento un elemento de tipo a y devuelve un valor de tipo b.

Las funciones en Haskell son ciudadanos de primera clase. Pueden ser argumentos o resultados de otras funciones o ser componentes de estructuras de datos. Esto permite simular mediante funciones de un único argumento, funciones con múltiples argumentos.

Por ejemplo, la función de suma (+) . En matemáticas se toma la suma como una función que toma una pareja de enteros y devuelve un entero. Sin embargo, en Haskell, la función suma tiene el tipo:

(+)::Int->(Int->Int)

(+) es una función de un argumento de tipo Int que devuelve una función de tipo Int->Int . De hecho "(+) 5" denota una función que toma un entero y devuelve dicho entero más 5. Este proceso se denomina currificación (en honor a Haskell B.Curry ) y permite reducir el número de paréntesis necesarios para escribir expresiones. De hecho, no es necesario escribir f(x) para denotar la aplicación del argumento x a la función x , sino simplemente f x .

Se podría escribir simplemente (+)::Int->Int->Int , puesto que el operador -> es asociativo a la derecha.

Un poco de historia de Haskell

Los orígenes teóricos del modelo funcional se remontan a los años 30 en los cuales Church propuso un nuevo modelo de estudio de la computabilidad mediante el cálculo lambda. Este modelo permitía
trabajar con funciones como ciudadanos de primera clase. En esa misma época, Shönfinkel y Curry
construían los fundamentos de la lógica combinatoria que tendrá gran importancia para la implementación de los lenguajes funcionales.

Hacia 1950, John McCarthy diseñó el lenguaje LISP (List Processing) que utilizaba las listas como
tipo básico y admitía funciones de orden superior. Sin embargo, para que el lenguaje fuese práctico, fue necesario incluir características propias de los lenguajes imperativos como la asignación destructiva y los efectos laterales que lo alejaron del paradigma funcional. Actualmente ha surgido una nueva corriente defensora de las características funcionales del lenguaje encabezada por el dialecto Scheme, que aunque no es puramente funcional, se acerca a la definición original de
McCarthy.

En 1964, Peter Landin diseñó la máquina abstracta SECD para mecanizar la evaluación de expresiones, definió un subconjunto no trivial de Algol-60 mediante el cálculo lambda e introdujo la familia de lenguajes ISWIM (If You See What I Mean) con innovaciones sintácticas (operadores
infijos y espaciado) y semánticas importantes.

En 1978 J. Backus (uno de los diseñadores de FORTRAN y ALGOL) consiguió que la comunidad informática prestara mayor atención a la programación funcional con su artículo “Can Programming
be liberated from the Von Neumann style?” en el que criticaba las bases de la programación imperativa tradicional mostrando las ventajas del modelo funcional. Además Backus diseñó el lenguaje funcional FP (Functional Programming) con la filosofía de definir nuevas funciones combinando otras funciones.

A mediados de los 70, Gordon trabajaba en un sistema generador de demostraciones denominado
LCF que incluía el lenguaje de programación ML (Metalenguaje). Aunque el sistema LCF era interesante, se observó que el lenguaje ML podía utilizarse como un lenguaje de propósito general eficiente. ML optaba por una solución de compromiso entre el modelo funcional y el imperativo ya que, aunque contiene asignaciones destructivas y Entrada/Salida con efectos laterales, fomenta un estilo de programación claramente funcional. Esa solución permite que los sistemas ML compitan en eficiencia con los lenguajes imperativos.

A mediados de los ochenta se realizó un esfuerzo de estandarización que culminó con la definición de
SML (Stándar ML). Este lenguaje es fuertemente tipado con resolución estática de tipos, definición de funciones polimórficas y tipos abstractos. Actualmente, los sistemas en SML compiten en eficiencia con los sistemas en otros lenguajes imperativos.

A comienzos de los ochenta surgieron una gran cantidad de lenguajes funcionales debido
a los avances en las técnicas de implementación. Entre éstos, se podrían destacar Hope, LML, Orwell, Erlang, FEL, Alfl, etc. Esta gran cantidad de lenguajes perjudicaba el desarrollo del paradigma funcional. En septiembre de 1987, se celebró la conferencia FPCA en la que se decidió formar un comité internacional que diseñase un nuevo lenguaje puramente funcional de propósito general denominado Haskell.

Con el lenguaje Haskell se pretendía unificar las características más importantes de los lenguajes
funcionales. como las funciones de orden superior, evaluación perezosa, inferencia estática de tipos,
tipos de datos definidos por el usuario, encaje de patrones y listas por comprensión. Al diseñar el
lenguaje se observó que no existía un tratamiento sistemático de la sobrecarga con lo cual se construyó una nueva solución conocida como las clases de tipos. El lenguaje incorporaba, además, Entrada/Salida puramente funcional y definición de arrays por
comprensión.

Durante casi 10 años aparecieron varias versiones del lenguaje Haskell, hasta que en 1998 se decidió
proporcionar una versión estable del lenguaje, que se denominó Haskell98, a la vez que se continuaba
la investigación de nuevas características y nuevas extensiones al lenguaje.

Dejo link: https://es.wikipedia.org/wiki/Haskell

Frege como Haskell pero en la plataforma Java

Siempre me pregunte como no habia un leguaje igual a Haskell pero que corra en la plataforma java y aca esta!! Frege, que si vien no es una copia exacta de Haskell tiene mucha similitud.

Este lenguaje soporta muchas características de haskell, como:

• Typeclasses con polimorfismo
• Pattern matching
• Listas por compresión
• módulos
• Abstracción matemática que nos permite tenes estructuras como functors, monoids, semigroups, y monads.

Veamos un poco de código:

-- file hello.fr
module Hello where  -- moduleName maybe hierarchical as pkgdir.JavaClassname

main args = println $ "Hello world! your arguments are: " ++ show args

En este ejemplo se puede ver un simple hello world. Como ven es mu similar a haskell para tiene una clara influencia de la plataforma java.

Veamos otro ejemplo:

{--
    Este programa muestra la
     hora actual en la salida estándar
     cada dos segundos.
    -}
   
module examples.CommandLineClock where

data Date = native java.util.Date where
    native new :: () -> IO (MutableIO Date)             -- new Date()
    native toString :: Mutable s Date -> ST s String    -- d.toString()

--- 'IO' action to give us the current time as 'String'
current :: IO String
current = do
    d <- Date.new ()  -- reads system timer, hence IO
    d.toString

main args =
    forever do
        current >>= print   -- print formatted date
        print "\r"          -- followed by carriage return
        stdout.flush        -- make sure it's shown
        Thread.sleep 999L   -- wait 0.999 seconds


Este lenguaje fue diseñado por Ingo Wechsung quien nombra este lenguaje Frege por el matemático alemán Gottlob Frege.

Además podemos probarlo de forma online desde esta pagina: http://try.frege-lang.org/

Dejo links:
https://github.com/Frege/frege
https://en.wikipedia.org/wiki/Frege_(programming_language)

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