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.

Libros Gratuitos de Java Code Geek

Download IT Guides!   Eclipse IDE Handbook Eclipse is an integrated development environment (IDE) used in computer programming, and is the most widely used Java IDE. It contains a base workspace and an extensible plug-in system...     Advanced Java Tutorial Learning the basics of Java is easy. But really delving into the language and studying its more advanced concepts and nuances is what will make you a great Java developer. The web is...     Amazon AWS Lambda Tutorial AWS Lambda is an event-driven, serverless computing platform provided by Amazon as a part of the Amazon Web Services. It is a computing service that runs code in response to events and...     JPA Tutorial - Ultimate Guide The Java Persistence API (JPA) is a vendor independent specification for mapping Java objects to the tables of relational databases. Implementations of this specification allow...

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: 

Erlang en el panorama de la programación funcional.

Erlang es pragmático. Erlang es funcional, pero permite algunos efectos secundarios. Por ejemplo, la forma en que se maneja la comunicación en Erlang es como un efecto secundario. Pero Erlang evita algunos tipos de efectos secundarios. No mantiene estado, tiene lo que se llama asignación única estática. Entonces, aunque el lenguaje en sí es relativamente libre, hay herramientas que ayudan a garantizar la seguridad de los programas que escribimos. Así que hay un buen equilibrio pragmático. 

Si nos fijamos en el panorama del lenguaje de programación funcional, hay bastantes lenguajes que se denominan funcionales. Muchos lenguajes son lo que se llama fuertemente tipado. Lo que queremos decir con tipado fuerte es que cualquier error de tipo que sucede en el lenguaje, lo obtendremos en el momento de la compilación. No se obtienen errores de tipo de tiempo de ejecución. En este grupo tenemos lenguajes como Haskell y Miranda, que tienen lo que se denomina evaluación perezosa.

Lo que eso significa es que la evaluación de las expresiones está impulsada por la demanda. Entonces, en lugar de la evaluación tradicional, que se llama evaluación estricta, donde los argumentos de las funciones se evalúan a medida que se pasan a la función, antes de evaluar el cuerpo de la función. En Haskell y Miranda, los argumentos solo se evalúan cuando la evaluación del cuerpo lo requiere. Por lo tanto, es muy posible que un argumento no se evalúe en absoluto. O es posible que un compuesto, una estructura de datos, solo se evalúe parcialmente. Y esto permite tipos de estructuras de datos infinitos. 

A la vez Haskell y Miranda son completamente puros. No tienen ningún efecto secundario en absoluto. Y eso se debe a que los efectos secundarios y la evaluación perezosa encajan muy mal. La pereza te obliga a ser puro. Esto se debe a que no sabe cuándo se evaluarán partes particulares de una expresión. Entonces, no sabes cuándo ocurriría ese efecto secundario, si estuviera allí. Por otro lado, lenguajes como ML y OCaml y F# tienen una evaluación estricta. Y tienen algunas impurezas. Diferentes lenguajes tienen diferentes equilibrios de impureza, así como Erlang tiene efectos secundarios, tiene impureza en sus primitivas de comunicación. 

Los demás, ML, OCaml, etc., la familia ML son estrictos. Pero estos lenguajes están fuertemente tipados. En el otro extremo del espectro, hay lenguajes débilmente tipados de la familia LISP. Y estos son inherentemente no escritos, si lo desea. Porque construido en el corazón de ellos, tienen una función de evaluación. Entonces puede construir datos y luego evaluar esos datos. Por lo tanto, no hay forma de que sepa de antemano qué tipo de datos tendrá la construcción cuando se evalúen. LISP tiene una larga historia. LISP se inventó por primera vez hace más de 50 años. Y los descendientes de LISP como Common Lisp y Scheme y Racket se usan ampliamente en la actualidad. Pero el núcleo de esos lenguajes es el uso sofisticado de macros y el uso de eval para hacer que estos lenguajes sean muy reflexivos. Pero eso difiere del tipo de cosas que se hacen en Erlang. 

Si para ser un lenguaje de programación funcional, todo lo que necesita es tener una lambda que le permita definir funciones anónimas, entonces tenemos una gran clase de lenguajes de programación funcional. Debido a que Java, JavaScript, Ruby, C ++, casi todos los lenguajes en los que se puede imaginar están obteniendo un lambda, permiten la facilidad de tener funciones anónimas simplemente porque han demostrado ser muy útiles en paradigmas de programación funcional como MapReduce, etc. Pero no se puede considerara estos últimos lenguajes como funcionales. 

repl.it, Una super IDE online

repl.it es un IDE gratuito, colaborativo y en el navegador para codificar en más de 50 lenguajes, sin gastar un segundo en la configuración.

Les cuento, quería probar algo en Haskell y me encontré con esta joya. Esta muy bueno, te haces un usuario si queres, codeas y si configuraste un repo en github te guarda los archivos ahí. Podes compartir codigo, trabajar en equipo...

Podes programar en : 

Python, Nodejs, C, Java, C++, Ruby, HTML, CSS, JS, Lisp, Go, Rust, Roy, kotlin, Swift, F#, C#, etc...

Punto bajo, no permite ni Scala, ni Grovyy... 

Dejo link: https://repl.it/

Crear un árbol binario con Haskell

En informática, los árboles crecen al revés. La raíz única está en la parte superior, y las hojas están en la parte inferior. En realidad depende como se lo vea. 

El árbol binario se usa a menudo para almacenar datos ordenados, para permitir una búsqueda eficiente, por ejemplo, un directorio telefónico.

Vamos a definir un tipo de datos Haskell para árboles, almacenando valores enteros.

data Tree = Leaf | Node Int Tree Tree deriving Show

Un valor de árbol puede ser una hoja o un nodo. Tenga en cuenta que este es un tipo de datos recursivo, ya que un Nodo almacena un árbol de enteros y tiene ramificaciones a dos subárboles (a veces llamados hijos). Como se ve definimos que un árbol es una hoja o un nodo con el dato y dos arboles. 

Aquí está el árbol más simple: es solo una hoja.

Leaf

Aquí hay un árbol con un Nodo que contiene el valor 3 y dos hojas.

Node 3 Leaf Leaf

Si escribe esto en ghci, verá los valores devueltos cuando construya estos árboles, siempre que su tipo de datos Tree derive la clase Show type.

El tipo de este valor es:

let l = Node 3 Leaf Leaf

:t l

El tipo del nodo constructor:

:t Node

Esta es una función: el nodo constructor toma tres argumentos y devuelve un resultado de árbol.

Ahora escribamos una función para calcular la profundidad de un árbol: esta es la cantidad máxima de ramas desde la raíz hasta cualquier hoja. Para escribir esta función, haremos coincidir patrones en los diferentes tipos de árbol, es decir, valores de hoja y nodo. Cada hoja es un caso base, pero para cada nodo, necesitamos procesar recursivamente los dos árboles secundarios.

treeDepth :: Tree -> Int

treeDepth Leaf = 0

treeDepth (Node _ leftSubtree rightSubtree) = 

  1 + max (treeDepth leftSubtree) (treeDepth rightSubtree)

Observe el _ en la línea 3, que es un valor de "don’t care" o "no me importa", ya que descartamos el entero en cada nodo.

¿Qué tal una función para verificar si un árbol está ordenado correctamente? La estructura de datos invariable que queremos es que, para cualquier valor de almacenamiento de Nodo x, todos los valores en su subárbol izquierdo sean <x, y todos los valores en su subárbol derecho sean> = x.

Entonces, esta función tomará un Árbol, un valor mínimo, un valor máximo y devolverá un Bool. isSortedTree :: Árbol -> Int -> Int -> Bool

Una hoja se ordena automáticamente, ya que no contiene un valor. Para cada nodo, tenemos que verificar que el valor entre los valores mínimo y máximo, que comienzan lo más lejos posible, luego se dividen en rangos más pequeños según el valor en el nodo.

isSortedTree :: Tree -> Int -> Int -> Bool

isSortedTree Leaf _ _ = True

isSortedTree (Node x leftSubtree rightSubtree) minVal maxVal =

    let leftSorted   = isSortedTree leftSubtree minVal x

        rightSorted = isSortedTree rightSubtree x maxVal

    in x >= minVal && x< maxVal && leftSorted && rightSorted

Hasta ahora, hemos estudiado las funciones de recorrido del árbol, donde revisamos la estructura de datos del árbol y hacemos algunos cálculos incrementales en cada nodo. Ahora queremos hacer una función de modificación del árbol. Esto genera un nuevo árbol que es una versión modificada del árbol de entrada.

La función particular que vamos a definir inserta un nuevo valor máximo. Pasamos por el árbol de entrada hasta encontrar el nodo de la derecha con una hoja a la derecha, luego reemplazamos esta hoja de la derecha con un nuevo nodo que contiene un nuevo valor máximo (uno más grande que el valor máximo anterior).

addNewMax :: Tree -> Tree

-- add a new max element to tree

addNewMax Leaf = Node 0 Leaf Leaf  -- input tree with no nodes

addNewMax (Node x t1 Leaf) = Node x t1 (Node (x+1) Leaf Leaf)  -- this is the rightmost Node

addNewMax (Node x t1 t2) = Node x t1 (addNewMax t2) -- intermediate node, go down right subtree

Esta función addNewMax toma un valor de entrada de árbol y devuelve un valor de salida de árbol. 

Inscripción gratuita a MongoDB.live

Me llego el siguiente mail de la gente de MongoDB para anotarme a Mongo.live un evento gratuito donde podes aprender sobre esta gran base de datos NoSql :

Únanse el 9 y 10 de junio* a MongoDB.live para profundizar en el contenido educativo y conocer las nuevas tecnologías. Aprenderá de los expertos en MongoDB para resolver desafíos y adelantarse a la competencia. En MongoDB.live podrás: Personalizar tu experiencia con sesiones centradas en temas como arquitectura de aplicaciones, rendimiento de consultas, modelo de datos, diseño de esquemas, análisis, seguridad, microservicios, migración a la nube y más. Aprender de los clientes de MongoDB en todos los sectores sobre las herramientas y características que están utilizando para aumentar la agilidad de su organización y la productividad de sus equipos de desarrollo. ¡Participar durante la conferencia para ganar puntos de actividad y competir con otros asistentes para ganar premios! Regístrese gratis ahora Después de asistir, estará equipado con los conocimientos esenciales para crear y administrar aplicaciones basadas en datos. ¡Esperamos verte ahí! * MongoDB.live comenzará a las 10:00 a.m. ET el 9 de junio y se extenderá hasta el 10 de junio a las 4:00 p.m. ET.

MongoDB Inc., 2020. All rights reserved. 1633 Broadway, Floor 38, New York, NY 10019 Unsubscribe or change your email preferences. View in browser

Libros Gratuitos de Java Code Geek

Download IT Guides!   Vaadin Programming Cookbook Vaadin is an open source web framework for rich Internet applications. In contrast to JavaScript libraries and browser-plugin based solutions, it features a server-side architecture,...     GWT Programming Cookbook Google Web Toolkit, or GWT Web Toolkit, is an open source set of tools that allows web developers to create and maintain complex JavaScript front-end applications in Java. Other than a...     Amazon Elastic Beanstalk Tutorial AWS Elastic Beanstalk is an orchestration service offered from Amazon Web Services for deploying infrastructure which orchestrates various AWS services, including EC2, S3, Simple...     Hibernate Tutorial Hibernate ORM (Hibernate in short) is an object-relational mapping framework, facilitating the conversion of an object-oriented domain model to a traditional relational database....

Revolution.OS.2001

Quiero recomendarles un buen documental para pasar la pandemia : 

y de yapa:

Design patterns

Quiero recomendar una pagina de patrones de diseño que esta buenisima, trae una descripción de casi todos los patrones con ejemplos y código. El codigo esta en deferentes lenguajes. 

Dejo link : https://refactoring.guru/design-patterns

Juego de Serie en C# con .net core

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en C# para ello creamos el proyecto con : 

$ dotnet new console -lang C#

Luego de esto abrimos nuestro editor favorito, podemos utilizar visual code.  

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

using System;

namespace dotNetSecuencia.model

{

    public abstract class Secuencia

    {

        protected int[] nros = new int[4];

        public Secuencia() {

            this.generar();

        }

        public int[] Nro {

            get {

                return nros;

            }

        }

        

        public abstract void generar();

    }

}

Ahora vamos a ver las implementaciones de secuencia:

using System;

namespace dotNetSecuencia.model

{

    public class SecuenciaPar : Secuencia

    {        

        public override void generar() {

            int semilla = new Random ().Next (99) * 2;

            for (int i = 0; i<4; i++) {

                this.nros[i] = (semilla + i * 2); 

            }

        }

    }

}

Y ahora la secuencia Impar: 

using System;

namespace dotNetSecuencia.model

{

    public class SecuenciaImpar : Secuencia

    {

        public override void generar() {

            int semilla = new Random ().Next (99) * 2;

            for (int i = 0; i<4; i++) {

                this.nros[i] = (semilla + i * 2) + 1; 

            }

        }

    }

}

Y ahora la secuencia Fibonacci :

using System;

namespace dotNetSecuencia.model

{

    public class SecuenciaFibonacci : Secuencia

    {

        public override void generar() {

            int until = new Random ().Next (15);

            this.nros[0] = 0;

            this.nros[1] = 1;

            this.nros[2] = 1;

            this.nros[3] = 2;

            for (int i = 0; i<until; i++) {

                 this.nros[0] = this.nros[1];

                 this.nros[1] = this.nros[2];

                 this.nros[2] = this.nros[3];

                 this.nros[3] = this.nros[1] + this.nros[2];

            }

        }

    }

}

Ahora vamos a ver el juego, este tiene la responsabilidad de verificar si el usuario acertó y tambien debe llevar los puntos: 

 using System;

namespace dotNetSecuencia.model

{

    public class Juego

    {

        private int puntaje = 0;

        private Secuencia secuencia = null;

        public Juego() 

        {

            this.generarSecuencia();

        }

        public int Nro1 {

            get {

                return this.secuencia.Nro[0];

            }

        }

        public int Nro2 {

            get {

                return this.secuencia.Nro[1];

            }

        }

        public int Nro4 {

            get {

                return this.secuencia.Nro[3];

            }

        }

        public int Puntaje {

            get {

                return this.puntaje;

            }

        }

        public void generarSecuencia() 

        {

            int semilla = new Random ().Next (3);

            switch (semilla)

            {

                case 0 :

                    this.secuencia = new SecuenciaPar(); 

                break;

                case 1 :

                    this.secuencia = new SecuenciaImpar(); 

                break;

                default:

                    this.secuencia = new SecuenciaFibonacci();

                break;

            }

        }

        public bool isOk(int valor) {

            bool result = false;

            if (this.secuencia.Nro[2] == valor) {

                this.puntaje++;

                result = true;

            } else {

                this.puntaje--;

            }

            this.generarSecuencia();

            return result;

        }

    }

}

Ahora programemos la interfaz por consola por supuesto : 

using System;

using dotNetSecuencia.model;

namespace dotNetSecuencia

{

    class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine("Bienvenido !!");

            Juego juego = new Juego();

            String respuestaStr;

            do {

                Console.WriteLine("La secuencia es : ");

                Console.WriteLine(" " + juego.Nro1 + " " + juego.Nro2 + "  __  " + juego.Nro4 );

                respuestaStr = Console.ReadLine();

                int respuesta = Convert.ToInt32(respuestaStr);

                if (juego.isOk(respuesta)) {

                    Console.WriteLine("Ganaste!! Tu puntaje es " + juego.Puntaje);

                } else {

                    Console.WriteLine("Perdiste!! Tu puntaje es " + juego.Puntaje);

                }

                Console.WriteLine("Quieres seguir Jugando [n/s] ? ");

                respuestaStr = Console.ReadLine();

            } while (respuestaStr != "n");

        }

    }

}

Y eso es todo!!! a jugar se a dicho!!

Dejo el repositorio git: 

https://github.com/emanuelpeg/secuenciaCSharp

Coconut, programación funcional simple, elegante en python

Coconut es un lenguaje de programación funcional que compila a Python. Como todo codigo válido en Python es válido en Coconut , el uso de Coconut solo extenderá y mejorará lo que ya es capaz de hacer en Python.

¿Por qué usar Coconut? Coconut está hecho para ser útil. Coconut mejora el repertorio de los programadores de Python para incluir las herramientas de la programación funcional moderna, de tal manera que esas herramientas sean fáciles de usar e inmensamente poderosas; es decir, Coconut hace a la programación funcional lo que Python hizo a la programación imperativa. Y el código Coconut se ejecuta igual en cualquier versión de Python.

Instalar Coconut es tan fácil como

instalando Python,

abriendo una línea de comandos,

y escribir:

pip install coconut

Veamos un poco de código: 

Un "hola mundo" : 

"hello, world!" |> print

lambdas:

x -> x ** 2

pattern-matching:

match [head] + tail in [0, 1, 2, 3]:

    print(head, tail)

composición de funciones: 

(f..g..h)(x, y, z)

Data types: 

data Empty()

data Leaf(n)

data Node(l, r)

def size(Empty()) = 0

addpattern def size(Leaf(n)) = 1

addpattern def size(Node(l, r)) = size(l) + size(r)

Sin, más dejo link: 

http://coconut-lang.org/

Funciones recursivas en listas parte 2

Seguimos con Funciones recursivas en listas 

Si deseamos realizar una operación en cada elemento de una lista map es la función indicada. map aplica una función a cada elemento de una lista

map f [x0,x1,x2] -- > [f x0, f x1, f x2]

map es una de las herramientas más utilizadas en programación funcional. Un estilo común es definir un conjunto de cálculos simples usando el map y componerlos.

map f (map g xs) = map (f . g) xs

Map se puede definir de esta manera: 

map :: (a -> b) -> [a] -> [b]

map _ []     = []

map f (x:xs) = f x : map f xs

Una iteración sobre una lista para producir un valor se llama pliegue y existen varias variaciones: plegado desde la izquierda, plegado desde la derecha y varias variaciones que tienen que ver con la "inicialización" y algunas variaciones más avanzadas.

Los pliegues pueden parecer difíciles al principio, pero son extremadamente poderosos y se usan mucho. Y en realidad no son muy complicados.

foldl se pliega desde la izquierda y ed como una iteración en una lista, de izquierda a derecha.

Una aplicación típica es por ejemplo, foldl f z xs

Donde z es un valor inicial

El argumento xs :: [a] es una lista de valores que combinamos sistemáticamente utilizando la función proporcionada f

Una intuición útil: piense en el argumento z :: b como un "acumulador".

La función f toma el valor actual del acumulador y un elemento de lista, y da el nuevo valor del acumulador.

foldl :: (b-> a-> b) -> b -> [a] -> b

Similar a foldl, pero funciona de derecha a izquierda

foldr :: (a -> b -> b) -> b -> [a] -> b

Hemos visto que una lista [x0, x1, x2] también se puede escribir como

    x0: x1: x2: []

cons (:) sobre una lista usando la lista vacía [] como el acumulador da:

foldr (:) [] [x0, x1, x2]

  ->

  x0: x1: x2: []

¡Esto es idéntico a construir la lista usando (:) y []! Podemos formalizar esta relación de la siguiente manera:

foldr cons [] xs = xs

 

Veamos algunos ejemplos: 

suma xs = foldr (+) 0 xs

producto xs = foldr (*) 1 xs

De hecho, podemos "factorizar" las x que aparecen a la derecha de cada lado de la ecuación, y escribir:

sum = foldr (+) 0

producto = foldr (*) 1

(Esto a veces se denomina estilo "point free" porque está programando únicamente con las funciones; los datos no se mencionan directamente).

Programación explicada con música

Dejo link: https://toggl.com/blog/programming-languages-explained-with-music-comic

Funciones recursivas en listas

Hay dos enfoques para trabajar con listas:

• Escribir funciones utilizando definiciones recursivas que atraviesan la estructura de la lista.
• Utilizar funciones estandar. 

Se prefiere el segundo enfoque, pero las funciones estándar de procesamiento de listas deben definirse, y esas definiciones usan el primer enfoque (definiciones recursivas).

Se crea una lista a partir de la lista vacía [] y la función cons :: a → [a] → [a] la cual se puede escribir con ":"

Una lista se puede definir como : 

• [] o
• (x: xs) para algunas x (el encabezado de la lista) y xs (la cola) donde (x: xs) 

La lista esta definida de forma recursiva, el caso base de la recursión es [], el caso de recursión (o inducción) es (x: xs).

La longitud de una lista se puede calcular de forma recursiva de la siguiente manera:

length :: [a] -> Int           -- function type

length [] = 0                  -- base case

length (x:xs) = 1 + length xs  -- recursion case

filter recibe un predicado (una función que da un resultado booleano) y una lista, y devuelve una lista de los elementos que satisfacen el predicado.

filter :: (a->Bool) -> [a] -> [a]

filter (<5) [3,9,2,12,6,4] -- > [3,2,4]

La podemos definir así:

filter :: (a -> Bool) -> [a] -> [a]

filter pred []    = []

filter pred (x:xs)

  | pred x         = x : filter pred xs

  | otherwise      = filter pred xs

Muchos cálculos que serían calculados con bucles for / while en un lenguaje imperativo se expresan naturalmente como cálculos de lista en un lenguaje funcional.

En Haskell tenemos: 

• Map : Realizar un cálculo en cada elemento de una lista
• Foldl: Iterar sobre una lista, de izquierda a derecha 
• Foldr: Iterar sobre una lista, de derecha a izquierda

Es una buena práctica usar estas tres funciones cuando corresponda

Podemos expresar un gran cálculo "encadenando" una secuencia de funciones que realizan cálculos más pequeños. Por ejemplo tenemos un argumento de tipo a, aplicamos una función g :: a−> b, obteniendo un resultado intermedio de tipo b luego aplicamos una función f :: b−> c al resultado intermedio, obteniendo el resultado final de tipo c. El cómputo completo (primero g, luego f) se escribe como f∘g. Esta es la notación matemática tradicional; solo recuerda que en f∘g, las funciones se usan en orden de derecha a izquierda.

Haskell utiliza el . como operador de composición de funciones

(.) :: (b->c) -> (a->b) -> a -> c

(f . g) x = f (g x)