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

HTML + javascript + Haskell = ELM, parte 9

Los lenguajes funcionales son excelentes para transformar texto. Elm también es excelente para capturar texto. Aquí hay un ejemplo que toma algo de entrada, lo manipula y lo pone en la pantalla, usando un flujo HTML:

import String
import Html exposing (Html, Attribute, text, toElement, div, input)
import Html.Attributes exposing (..)
import Html.Events exposing (on, targetValue)
import Signal exposing (Address)
import StartApp.Simple as StartApp

--Importamos las bibliotecas que necesitaremos. String nos permite manipular cadenas, y Html nos da
-- acceso a varios aspectos de HTML, incluidos eventos, divs y campos de entrada.

 main = StartApp.start { model = "", view = view, update = update }

--Nuestra función principal de una línea inicia nuestra aplicación, inicializando con una cadena
--vacía, presentando una vista y manejando actualizaciones con nuestra función de actualización, que
--se llamará cada vez que cambie nuestro campo de entrada.

 update newStr oldStr = newStr

--A continuación, nuestra función de actualización trivial simplemente devuelve el nuevo valor del
--campo de entrada cada vez que el campo de entrada se actualiza.

 shout text = String.toUpper text
 whisper text = String.toLower text
 echo text = (shout text) ++ " " ++ (whisper text)

--A continuación, definimos un par de funciones simples para trabajar con texto, las funciones de
--grito y susurro. Los usamos para construir una función de eco para transformar el texto. Estas
--funciones no saben nada sobre las interfaces de usuario. Solo funcionan en datos de cadena sin
--procesar.

 view address string =
div []
     [ input
     [ placeholder "Speak"
       , value string
       , on "input" targetValue (Signal.message address)
       , myStyle
      ]
     []
  , div [ myStyle ] [ text (echo string) ]
]
myStyle = style [ ("width", "100%") ]

--La siguiente tarea es construir nuestra página HTML. Agregamos un control de entrada y un div
--que contendrá nuestro texto modificado. El control de entrada simplemente tiene los elementos
--HTML que Elm necesita para representar el control. La función on establece una señal que
--contendrá actualizaciones del campo de entrada. myStyle devuelve la hoja de estilo para nuestros
--elementos HTML. La función div crea un div HTML con los contenidos y el estilo especificados.

Puede parecer un poco extraño al principio, pero la visión del mundo de Elm es el complemento perfecto para la programación web front-end. Cada interfaz de usuario es solo un flujo de entradas de usuario transformadas

En lenguaje de programación esotérico, hoy : Poop

Como divertirse en la cuarenterna?

Por suerte tenemos los lenguajes esotéricos como Poop que fue creado por Eike Tim Jesinghaus en abril de 2014. Poop es inutilizable para la programación porque es solo un lenguaje en joda.

Veamos un Hello world :

eat eat eat eat eat eat eat eat eat

eat eat eat eat eat eat eat eat

POOP

puke puke puke

poop

eat eat eat eat eat eat eat

poop

poop

eat eat eat

poop

sniff

flush

eat eat eat eat eat eat eat eat eat

eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat

POOP

puke puke puke puke puke puke puke puke

poop

eat eat eat

poop

puke puke puke puke puke puke

poop

puke puke puke puke puke puke puke puke

poop

eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat eat

poop

sniff

Dejo link : https://esolangs.org/wiki/Poop

1. Desafío, escribir hola mundo! jajaja

HTML + javascript + Haskell = ELM, parte 8

Seguimos con el post anterior.

Uno de los problemas más comunes de la interfaz de usuario es encontrar dónde hace clic un usuario.

Usemos la función sampleOn. Esa función nos permite muestrear una señal cuando se actualiza otra, como esta:

import Graphics.Element exposing (show)
import Mouse
clickPosition = Signal.sampleOn Mouse.clicks Mouse.position
main = Signal.map show clickPosition

Construimos dos señales, clickPosition y main. Primero, creamos una señal con sampleOn. Cuando la señal Mouse.Clicks se actualice, probaremos la posición más reciente con Mouse.position. El resultado es una nueva señal que devuelve la posición del mouse y cambia cada vez que el usuario hace clic en el mouse. Luego, simplemente construimos nuestra señal principal. Mapeamos show en nuestra señal clickPosition. Sencillo. Podemos muestrear los controles de entrada de la misma manera.

O, supongamos que está implementando el desplazamiento con una barra de desplazamiento. Necesita saber qué tan lejos está el mouse en una página, así:

import Graphics.Element exposing (show)

import Mouse

import Window

div x y = show ((toFloat x) / (toFloat y))

main = Signal.map2 (div) Mouse.y Window.height

Ejecútelo y desplácese en el lado derecho para obtener algo como esto:

0.42973977695167286

Este ejemplo usa map2. Al igual que map, esta función asigna funciones a señales, pero usa dos señales y funciones de dos argumentos. Primero, para simplificar las conversiones de tipos, creamos una versión de división que toma enteros y devuelve texto. A continuación, usamos map2 para mapear div en dos señales, Mouse.y y Window.height. Piense en cómo se vería un programa JavaScript similar. 

Monitorear las entradas del usuario es un trabajo funcional.

infoQ, contenido adicional

Encontré el contenido adicional de los patrocinadores de infoQ y esta bueno, unas lindas lecturas para este tiempo de cuarentena.

Dejo link: https://www.infoq.com/vendorcontent/show.action?vcr=5252&showExpired=true

Open Data Structures in C++

Si no tenes nada que leer o tenes para leer pero te interesan las estructuras de datos en c++, te dejo este libro, libre y gratuito.

Dejo link:
 https://www.academia.edu/35238256/Open_Data_Structures_in_C_Edition_0.1G%CE%B2?email_work_card=title

HTML + javascript + Haskell = ELM, parte 7

Seguimos con el post anterior.

Agregaremos un par de funciones para contar la cantidad de interacciones con el mouse. En lenguajes funcionales como Elm, debes aprender trucos para manejar el estado. Hemos visto cómo las señales pueden ayudar a acceder a cosas como la posición del mouse que cambia con el tiempo y cómo usamos la recursividad para procesar listas. Gestionamos el estado por la forma en que estructuramos nuestras funciones. Las funciones de folds, que quizás conozcas de Lisp o Haskell, son un buen ejemplo. Toman una función de dos argumentos, un valor inicial y una lista. Aquí hay un ejemplo de foldl en Elm:

> foldl (+)  0  [1, 2, 3]
6 : number

Esto es lo que sucede en cada paso:

• fold (+) 0 [1, 2, 3]. fold toma el valor inicial de la lista, 1, y el acumulador, 0, y los suma, devolviendo 1, y usa ese número, con el resto de la lista, llamando a fold nuevamente.
• fold (+) 1 [2, 3]. Elm toma el valor más a la izquierda de la lista, 2, y el acumulador, 1, y los pasa a la función (+), devolviendo 3.
• fold (+) 3 [3]. Llamamos (+) con el acumulador 3 y el elemento de lista más a la izquierda de 3, devolviendo 6, y hemos terminado.

Ahora, creamos una señal con foldp. Esa señal agrega el acumulador, llamado presses, al valor x de la señal de Keyboard.arrows. Luego podemos asignar ese valor a la función show. Ahora, cuando ejecute la aplicación, obtendrá un total de presses. 

Usemos el mismo principio general para contar los movimientos del mouse. Signal.map aplica una señal a una función. Signal.foldp se pliega sobre una señal:

import Mouse

import Graphics.Element exposing (show)

count signal = Signal.foldp (\_ n -> n + 1) 0 signal

main = Signal.map show (count Mouse.position)

La función de conteo toma una señal y agrega una cada vez que la señal cambia. foldp funciona igual que foldl, pero en lugar de doblar una lista desde la izquierda, foldp se pliega a través del tiempo. Nuestra función foldp toma una función anónima que agrega uno a un valor, comienza con un valor inicial de 0 y proporciona una señal. Nuestra nueva señal tendrá valores que comienzan con 0 que aumentan cada vez que se actualiza la señal. Podemos cambiar fácilmente el programa para contar los clics del mouse:

import Mouse

import Graphics.Element exposing (show)

main = Signal.map show (count Mouse.clicks)

count signal = Signal.foldp (\_ n -> n + 1) 0 signal

En este caso, la función de conteo cuenta el número de actualizaciones de señal, que son clics del mouse. Puede comenzar a ver cómo podemos escribir código que respete las reglas de la programación funcional, pero que sea reactivo y fácil de entender.

Veamos cómo funcionarían las señales del teclado:

import Graphics.Element exposing (show)

import Keyboard

main = Signal.map show Keyboard.arrows

Map actualiza el texto cuando cambia la señal, por lo que obtenemos un programa limpio que nos dice el estado de las teclas de flecha, en una forma que podemos usar fácilmente. Como podemos componer con funciones, podemos ser más sofisticados.

HTML + javascript + Haskell = ELM, parte 6

Seguimos con el post anterior.

Elm fue construido desde cero para manejar los aspectos más difíciles del desarrollo de la interfaz de usuario. Se puede utilizar para crear una aplicación comercial con controles de interfaz de usuario o un juego, debe poder reaccionar ante los eventos. De hecho, todo lo que haces es una reacción a algún evento. El programa típico de JavaScript se basa en enviar eventos a través de funciones de callbacks, lo que hace que los programas sean mucho más receptivos pero a un costo. Son demasiado difíciles de leer. Aquí hay un ejemplo típico usando la biblioteca JQuery con JavaScript que le permite tomar la posición del mouse:

$(document).ready(function () {
       var position = {'x': 0, 'y': 0};
      $(document).bind('mousemove', function(event) {
                   position = {'x': event.pageX, 'y': event.pageY};
       });
       setInterval(function () {
      // custom position code
      }, seconds * 1000);
});

Comprender ese código requiere un poco de experiencia. Cuando se carga la página, recibimos una devolución de llamada lista. En ese momento, vinculamos el evento mousemove a una función que establece una variable de posición. Luego, a intervalos específicos, tenemos otra función de callback que utiliza la posición. Tenga en cuenta que nuestro código vincula funciones anónimas a eventos. Dicho de otra manera, estamos poniendo JavaScript a cargo de la organización del código. A esta estrategia de programación de adentro hacia afuera la llamamos inversión de control.

Para una característica tan trivial, ese código es demasiado complejo, pero es una compensación. Obtenemos una mejor capacidad de respuesta ya que este programa cambiará la posición del mouse cada vez que el usuario mueva el mouse. Cambiamos la simplicidad. El problema es que realmente necesitamos ambos.

import Graphics.Element exposing (..)

import Mouse

main = Signal.map show Mouse.position

La directiva de exposición nos permite mostrar sin especificar el módulo. Luego, haga clic en el botón de compilación. Verás una salida similar a esta:

(29, 162)

Eso es mucho más simple. Importamos los módulos Graphics.Element y Mouse, y luego declaramos la función principal.

Conceptualmente, la señal Mouse.position representa los valores de xey que varían con el tiempo. Signal.map aplica una señal a una sola función.

En el código anterior, la señal Mouse.position representa una tupla que contiene la posición del mouse a lo largo del tiempo. Nuestra función es show, que se convierte en texto.

Mouse.position se "disparará" cada vez que el mouse se mueva, y Signal.map volverá a evaluar show con la nueva posición del mouse. Curiosamente, el resultado es una nueva señal!

Mirando la parte inferior de la ventana, puede ver que la principal es en realidad una señal, una que mostramos en la pantalla. Eso significa que Elm actualizará la ventana cada vez que se mueva la posición del mouse.

No hay call back ni inversión de control. Simplemente usamos una señal, la convertimos a texto y mapeamos el valor actual cuando la señal cambia. 

Cursos Gugler para el primer cuatrimestre !!

Quiero compartir la oferta de cursos de Gugler para el primer cuatrimestre :

Recuerden que hay cursos presenciales y a distancia. Y están muy buenos...

Sin más dejo el link: https://gugler.com.ar/

Que es SRE ?

Me llego un mail de O'Reilly sobre Site reliability engineering. Bien bien, no se bien que es Site reliability engineering pero básicamente es la ingeniería que permite escalar y tener un sitio accesible y confiable. Pero mejor me leo el libro para tener mejor idea :

Online Learning • Conferences • Radar     Hi Emanuel, Site reliability engineering, or SRE for short, can be the key to running sites more effectively and reliably by keeping system components in a more consistent state. But it’s easier said than done. This short ebook shows how you can successfully introduce SRE processes to your business through a variety of helpful case studies from companies like Google and Slack. And the best part? It’s free, our gift to you.   DOWNLOAD THE EBOOK   The O’Reilly Team PS Whether you want to introduce SRE best practices, incorporate automation or AI, modernize your systems, or create entirely new products or business models, you’ll find the information you need at O’Reilly online learning. Check it out.       This message was sent to emanuelpeg@yahoo.com.ar. You are receiving this because you’re a customer of O’Reilly Media, or you’ve signed up to receive email from us. We hope you found this message to be useful. However, if you’d rather not receive future emails of this type from O’Reilly, please manage your preferences or unsubscribe here. Read our Privacy Policy.

HTML + javascript + Haskell = ELM, parte 5

Seguimos con el post anterior.

Elm incluye Pattern Matching, Puede usarlo para simplificar algunas definiciones de funciones:

> first (head::tail) = head
<function> : List a -> a
> first [1, 2, 3]
1 : number

Se deberá cubrir todos los casos o se puede tener este error:

> first []

Error: Runtime error in module Repl (on line 23, column 22 to 26):

Non-exhaustive pattern match in case-expression.

Make sure your patterns cover every case!

Como head :: tail no coincide [], Elm no sabe qué hacer con esta expresión. Usar una coincidencia de patrón no exhaustiva es una de las pocas formas en que puede bloquear un lenguaje de la familia ML y es totalmente evitable.

Elm es un lenguaje curry como Haskell :

> add x y = x + y

<function> : number -> number -> number

Observe el tipo de datos de la función. Es posible que haya esperado una función que tome dos argumentos de tipo número y devuelva un tipo de número. Así es como funciona el curry. Elm puede aplicar parcialmente add, lo que significa que puede completar uno de los dos números, así:

> inc = (add 1)

<function> : number -> number

Acabamos de crear una nueva función parcialmente aplicada llamada inc. Esa nueva función aplica uno de los argumentos para agregar. Completamos x, pero no y, así que Elm básicamente está haciendo esto:

addX y = 1 + y

Curry significa cambiar las funciones de múltiples argumentos a una cadena de funciones que cada una toma un solo argumento. Ahora, podemos manejar el curry nosotros mismos. Recuerde, las funciones currificadas no pueden tomar más de un argumento a la vez:

> add x y = x + y

<function> : number -> number -> number

> add 2 1

3 : number

> (add 2) 1

3 : number

Además de curring, puedes usar funciones parcialmente aplicadas para crear algunos algoritmos geniales. 

Elm infiere que vas a hacer aritmética con números. Elm usa el número de clase de tipo porque esa es la clase de tipo que admite el operador +. Sin embargo, no está limitado a enteros:

> add 1 2

3 : number

> add 1.0 2

3 : Float

> add 1.0 2.3

3.3 : Float

Y esto funciona porque Elm es polimórfico. Calcula el tipo más general que funcionará, en función de su uso de operadores. De hecho, puede ver el mismo comportamiento con el operador ++:

> concat x y = x ++ y

<function> : appendable -> appendable -> appendable

Elm asume que la función usa dos elementos anexables, como este:

> concat ["a", "b"] ["c", "d"]

["a","b","c","d"] : [String]

> concat "ab" "cd"

"abcd" : String

Eso es polimorfismo. Como es de esperar, también puede usar polimorfismo con puntos. Digamos que tengo un punto y quiero calcular la distancia al eje x. Eso es fácil de hacer:

> somePoint = {x=5, y=4}

{ x = 5, y = 4 } : {x : number, y : number'}

> xDist point = abs point.x

<function> : {a | x : number} -> number

> xDist somePoint

5 : number

La inferencia de tipos de Elm infiere que x e y son números dentro de un registro. Ahora, puedo pasarlo en cualquier punto:

> twoD = {x=5, y=4}

{ x = 5, y = 4 } : {x : number, y : number'}

> threeD = {x=5, y=4, z=3}

{ x = 5, y = 4, z = 3 } : {x : number, y : number', z : number''}

> xDist twoD

5 : number

> xDist threeD

5 : number

Alternativamente, podría usar la coincidencia de patrones, así:

> xDist {x} = abs x

<function> : { a | x : number } -> number

> xDist threeD

5 : number

Con  Pattern Matching seleccionar el campo x, y el resto del ejemplo funciona de la misma manera. El punto es que los registros también son completamente polimórficos. A Elm no le importa que los registros que utilizamos sean del mismo tipo. Solo necesita el registro para tener un campo x. Estás viendo el poder de un sistema de tipos que hará todo lo posible para detectar problemas reales, pero que se saldrá del camino cuando no haya ninguno.

Apache Druid

Apache Druid es una base de datos analíticos en tiempo real de alto rendimiento.

La idea es vos conectas Apache Druid a un origen de datos por ejemplo Apache Kafka y con Druid pueden analizar la información en tiempo real. Me hace acordar a Presto.

Druid está diseñado para flujos de trabajo donde las consultas rápidas y la ingesta de datos realmente importan. Druid se destaca en la visibilidad instantánea de datos, consultas ad-hoc, análisis operacionales y manejo de alta concurrencia.

Druid puede transmitir datos de forma nativa desde buses de mensajes como Kafka, Amazon Kinesis y más, y cargar archivos por lotes desde data lakes como HDFS, Amazon S3 y más.

Druid ha sido comparado para superar en gran medida las soluciones heredadas para la ingestión de datos y las consultas de datos. La nueva arquitectura de Druid combina los mejores almacenes de datos, bases de datos de series de tiempo y sistemas de búsqueda.

Druid desbloquea nuevos tipos de consultas y flujos de trabajo para clickstream, APM, cadena de suministro, telemetría de red, marketing digital y muchas otras formas de datos basados ​​en eventos. Druid está diseñado específicamente para consultas rápidas y ad-hoc sobre datos históricos y en tiempo real.

Druid se puede implementar en cualquier entorno * NIX en hardware básico, tanto en la nube como para instalaciones tradicionales. Implementar Druid es fácil: escalar hacia arriba y hacia abajo es tan simple como agregar y eliminar servicios de Druid.

Dejo link: https://druid.apache.org/

Libro gratuito de Java code Geeks

Download IT Guides!

JPA Minibook The basic Java framework to access the database is JDBC. Unfortunately, with JDBC, a lot of hand work is needed to convert a database query result into Java classes. Other disadvantages...	Microservices for Java Developers Microservices are a software development technique – a variant of the service-oriented architecture (SOA) structural style – that arranges an application as a collection of loosely...
JMeter Tutorial JMeter is an application that offers several possibilities to configure and execute load, performance and stress tests using different technologies and protocols. It allows simulating...	Java Design Patterns A design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be...

Ya esta listo el capitulo 7 y 8 del libro Machine Learning Engineering.

Me escribió mi amigoAndriy Burkov. Y me dijo que ya se encuentra el capitulo 7 y 8 del libro gratuito   Machine Learning Engineering.

No sé que más agregar, dejo el link : http://www.mlebook.com/wiki/doku.php?id=start

HTML + javascript + Haskell = ELM, parte 4

Seguimos con el post anteriro.

Como con cualquier lenguaje funcional, la base de Elm es la función. Definir una es trivial. Veamos algunas funciones :

> add x y = x + y
<function> : number -> number -> number
> double x = x * 2
<function> : number -> number
> anonymousInc = \x -> x + 1
<function> : number -> number
> double (add 1 2)
6 : number
> List.map anonymousInc [1, 2, 3]
[2,3,4] : [number]

La sintaxis para crear funciones es muy simple e intuitiva. add es una función con nombre con dos argumentos, x e y. Las funciones anónimas expresan parámetros como \ x, y el cuerpo de la función sigue los caracteres ->.

Como Elixir, Elm tiene el operador de tubería que permite componer funciones, de esta manera:

> 5 |> anonymousInc |> double

12 : number

https://emanuelpeg.blogspot.com/2017/03/pipe-operator-de-elixir.html
Y Factor : https://emanuelpeg.blogspot.com/2019/08/factor.html

Tomamos 5 y lo pasamos como el primer argumento a anonymousInc, para obtener 6. Luego, lo pasamos como el primer argumento para duplicar. También podemos hacer que esa expresión se ejecute de derecha a izquierda:

> double <| anonymousInc <| 5

12 : number

Evan Czaplicki, creador de Elm, dice que obtuvo esta función de F#, que a su vez obtuvo la idea de las tuberías de Unix, por lo que esta idea ha existido por un tiempo, ¡pero es buena!

Al igual que con cualquier lenguaje funcional, hay muchas funciones que le permitirán trabajar con funciones de todo tipo de formas:

> List.map double [1..3]

[2,4,6] : List number

> List.filter (\x -> x < 3) [1..20]

[1,2] : List comparable

[1..3] es un rango. Puede explorar más funciones de la Lista con la biblioteca de listas.

Cuando está componiendo una solución con Elm, puede tener la tentación de codificar cada caso como un cuerpo de función separado como lo haría en Haskell, Erlang o Elixir, pero no se puede :( :

> factorial 1 = 1

<function> : number -> number'

> factorial x = x * factorial (x - 1)

<function> : number -> number

> 

RangeError: Maximum call stack size exceeded

Parece que la segunda llamada reemplazó a la primera. En cambio, debe usar el mismo cuerpo de función y dividir el problema usando mayúsculas y minúsculas o si, de esta manera:

> factorial x = \

|  if | x == 0 -> 1 \

|      | otherwise -> x * factorial (x - 1)

<function> : number -> number

> factorial 5

120 : number

Suficientemente simple. factorial 0 es 1; de lo contrario, factorial x es x * factorial (x-1). Manejaría la recursividad de la lista de la misma manera:

> count list = \

| case list of \

| [] -> 0 \

| head::tail -> 1 + count tail

<function> : [a] -> number

> count [4, 5, 6]

3 : number

La cantidad de elementos de una lista vacía es cero y la cantidad de elementos de cualquier otra lista es 1 más la cantidad del resto. Veamos cómo atacar problemas similares con la coincidencia de patrones.

Por ahora vamos bien, pero seguimos en otro post...