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... 

HTML + javascript + Haskell = ELM, parte 3

Seguimos con el post anteriro.

Construimos tipos para el color y la pieza, y eso estuvo bien perooooooo nuestro ejemplo de ajedrez se volvió un poco más complicado cuando queríamos extraer el color. Lo que realmente necesitamos es una forma de acceder a los campos con nombre. Esa cosa es un registro, y es un compañero natural para los objetos de JavaScript. Digamos que queremos representar una pieza de ajedrez con los campos Color y Pieza:

> blackQueen = {color=Black, piece=Queen}
{ color = Black, piece = Queen } : { color : Repl.Color, piece : Repl.Piece }
> blackQueen.color
Black : Repl.Color
> blackQueen.piece
Queen : Repl.Piece

El Repl. es solo un alcance para los tipos, y el . es forma que llamamos a color es en realidad una función:

> .color blackQueen

Black : Repl.Color

Ahora, podemos acceder a los componentes de nuestro tipo estructurado. Al igual que con muchos lenguajes funcionales, los registros son inmutables, pero podemos crear uno nuevo con campos actualizados, o incluso campos cambiados, como este:

> whiteQueen = { blackQueen | color <- White }

{ color = White, piece = Queen } : { piece : Repl.Piece, color : Repl.Color }

> position = { column = "d", row = 1 }

{ column = "d", row = 1 } : {column : String, row : number}

> homeWhiteQueen = { whiteQueen | position = position }

{ color = White, piece = Queen, position = { column = "d", row = 1 } }

: { piece : Repl.Piece

, color : Repl.Color

, position : { column : String, row : number }

}

> colorAndPosition = { homeWhiteQueen - piece }

{ color = White, position = { column = "d", row = 1 } }

: { color : Repl.Color, position : { column : String, row : number }

}

> colorAndPosition.color

White : Repl.Color

Creamos tres nuevos registros, todos de diferentes tipos, transformando nuestro registro original. 

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

HTML + javascript + Haskell = ELM, parte 2

Seguimos con el post anteriro. 

elm provee el if tradicional :

 if x < 0 then "too small" else "ok"
"ok" : String

Similar al if de Ruby o al case de otros lengujes podemos escribir lo siguiente :

> x = 5
5 : number
> if | x < 0 -> "too small" \
|      | x > 0 -> "too big" \
|      | otherwise -> "just right"
"too big" : String

La barra invertida es porque estoy usando el RELP y tengo que avisarle de los enteres que no tienen sentido

Este if es muy similar a pattern matchinig pero Elm tiene pattern matching :

> list = [1, 2, 3]
[1,2,3] : [number]
> case list of \
| head::tail -> tail \
| [] -> []
[2,3] : [number]

Esta sentencia devuelve el final de una lista, si existe, las vacia, de otro modo. Se puede ver el uso de pattern matching.

La belleza y el poder de un sistema de tipos se ve cuando constrimos nuestros propios tipos de datos complejos. Veamos un ejemplo, una pieza de ajedrez tiene un tipo y un color. Lo que podemos hacer es lo siguiente :

> type Color = Black | White
> type Piece = Pawn | Knight | Bishop | Rook | Queen | King
> type ChessPiece = CP Color Piece
> piece = CP Black Queen
CP Black Queen : ChessPiece

Un constructor de tipos nos permite construir nuevas instancias de un tipo. Nuestro tipo ChessPiece consta de los caracteres CP, nuestro constructor de tipos, seguido de un Color y una Pieza. Ahora, podemos usar la combinación de mayúsculas y minúsculas para separar la pieza, así:

> color = case piece of \

| CP White _ -> White \

| CP Black _ -> Black

Black : Color

Crearemos un tipo que funcione como Lista. Para esto debe saber que Cons construye una lista, dado un elemento y otra lista :

type List = Nil | Cons Int List

Esta es una definición recursiva, una lista es una lista vacia o una construcción de un elemento y una lista. 

Ese tipo de datos es interesante, pero podemos hacerlo mejor. Podemos definir una lista abstracta, una que pueda contener cualquier tipo de datos, como este: 

type List a = Empty | Cons a (List a)

Es igual que la definición anterior pero con tipo generico a. 

Si desea saber cómo se evalúa una lista en Elm, observe el tipo de datos. Puede representar el tipo para la lista [1, 2] como Cons 1 (Cons 2 Empty).

Ahora, cuando te digo que puedes combinar el encabezado de una lista con la cola, tiene sentido. Cons funciona en tipos en tiempo de compilación. La contraparte en tiempo de ejecución del operador Cons que trabaja con datos es ::, y funciona así :

> 1 :: 2 :: 3 :: []

[1,2,3] : [number]

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

eBook "C++17 IN DETAIL - Part 1"

Me llego el siguiente mail de Embarcadero, y como es un libro gratuito lo comparto con ustedes :

Download your copy of the eBook "C++17 IN DETAIL - Part 1"   Learn the Exciting Features of the New C++ Standard!     Get your eBook

What you will learn: ● What was removed from the language and what is deprecated ● How the language is more precise: for example, thanks to expression evaluation order guarantees ● What the new features of templates are, like if constexpr or fold expressions ● What the new standard attributes are ● How you can write cleaner and more expressive code thanks to structured binding, inline variables, compile-time if or template argument deduction for classes

This eBook is offered to you by:

Embarcadero is the creator of the C++Builder, the powerful C++ IDE for multi-platform development focusing on database access and excellent UI design for all your platforms. Try C++Builder Whole Tomato is the creator of Visual Assist, an extension that improves Visual C# and Visual C++with a multitude of productivity features above those provided in the default IDE. Try Visual Assist

Happy programming from all of us at Embarcadero and Whole Tomato!

HTML + javascript + Haskell = ELM

Supongamos que tenemos que hacer un juego en Html, css y javascript. Ante esta idea, viene otra muy rápidamente relacionada con el suicidio.

Por suerte existe ELM, que es un lenguaje inspirado en Haskell el cual esta orientado a sistemas reactivos y compila a HTML y javascript.

Antes de comenzar debemos instalar ELM. ELM cuenta con 2 herramientas, una es el RELP y otra es le server. Por ahora vamos a utilizar el RELP.

Para instalar el RELP, vamos a : https://guide.elm-lang.org/install/elm.html
O podemos utilizar el try : https://elm-lang.org/try

Instalado el RELP, vamos a ver expresiones en ELM y literales : 

 > 4

4 : number

> "String"

"String" : String

> 5 < 4

False : Bool

Todo retorna un valor y ese valor tiene un tipo. ELM es de tipado estático y su tipado es muy poderoso pero algo quisquilloso :

> [1, "2"]

[1 of 1] Compiling Repl

 ( repl-temp-000.elm )

The 2nd element of this list is an unexpected type of value.

3|

 [1, "2"]

^^^

...

> 4 + "4"

[1 of 1] Compiling Repl

...

( repl-temp-000.elm )

As I infer the type of values flowing through your program, I see a conflict

between these two types: number String

> "4" ++ "4"

"44" : String

> 4 ++ 4

[1 of 1] Compiling Repl

...

Expected Type: appendable

...

> [1, 2] ++ [3, 4]

[1,2,3,4] : [number]

( repl-temp-000.elm ) 

Por lo visto, ELM es de tipado fuerte y estático.  ELM esta influenciado por el sistema de tipos de Haskell y ML. Su sistema de tipo contiene type classes. Esto se puede ver como las interfaces de Java. Es decir, un tipo implementa estas interfaces y todas las funciones que trabajan con este data type, puede ser utilizados con el tipo.

Por ejemplo tanto las listas como los Strings son appendable por lo tanto toda función que necesitan un appendable pueden ser utilizadas con listas o String por ejemplo ++.

A la vez ELM infiere el tipo, no es necesario indicar le tipo dado que este es inferido por el compilador : 

> a = [1, 2, 3]

[1,2,3] : [number]

A la vez cuenta con un sistema de tipos polimorfico, lo que significa que puede tratar los tipos que heredan de la misma type class de la misma manera. Verá que Elm aprovecha al máximo su herencia de ML y Haskell para construir uno de los mejores sistemas de tipos del mundo.

> a[1] = 2

[1 of 1] Compiling Repl ( repl-temp-000.elm )

> a[1] = 2

<function> : List number -> number'

Elm es un lenguaje de tipado estático, y muy estricto, aunque en REPL, puede redefinir valores primitivos por conveniencia. Elm es como Elixir a este aspecto. : List number -> number'

Creo que por este post estamos, continuará ...

Dejo link :  https://elm-lang.org/

Ballerina un lenguaje pensado para la nube, Parte 2

En el post anterior me quede con muchas ganas de ver código. Pero, si llegaste acá y no sabés de que estoy hablando o no sabés que es Ballerina ve esto: https://emanuelpeg.blogspot.com/2020/02/ballerina-un-lenguaje-pensado-para-la.html

Si queres probar el código que vamos dejando, pueden hacerlo acá : https://play.ballerina.io/

Veamos un poco de código en Ballerina y empecemos con un hola mundo:

import ballerina/io;

public function main() {
    io:println("Hello, World!");
}

Lindo pero, ahora vamos hacerlo en paralelo :

import ballerina/io;

public function main() {

    worker w1 {
        io:println("Hello, World! #m");
    }    worker w2 {
        io:println("Hello, World! #n");
    }    worker w3 {
        io:println("Hello, World! #k");
    }
}

veamos el mismo código en un servidor :

import ballerina/http;
import ballerina/log;

service hello on new http:Listener(9090) {
    resource function sayHello(http:Caller caller, http:Request req) {
        var result = caller->respond("Hello, World!");
        if (result is error) {
            log:printError("Error sending response", result);
        }
    }
}

y ahora de cliente : 

import ballerina/http;

import ballerina/io;

public function main() {

    http:Client clientEP = new ("http://www.mocky.io");

    var resp = clientEP->get("/v2/5ae082123200006b00510c3d/");    

    if (resp is http:Response) {

        var payload = resp.getTextPayload();

        if (payload is string) {

            io:println(payload);

        } else {

            io:println(payload.detail());

        }

    } else {

        io:println(resp.detail());

    }

}

Puff... lo que se puede hacer con un "hola mundo". Primera conclusión, claramente se ve que Ballerina esta ampliamente influenciado por Node y javascript. 

Veamos un objeto : 

import ballerina/io;

type Person object {

    public string name = "";

    public int age = 0;

    public Person? parent = ();

    private string email = "default@abc.com";

    string address = "No 20, Palm grove";

};

public function main() {

    Person p1 = new;

    io:println(p1.age);    

    

    Person p2 = new();

    io:println(p2.age);

    Person p3 = new Person();

    io:println(p3.age);

}

Se ve que las clases se declaran con type y se pueden hacer cosas más complejas : 

import ballerina/io;

type Person object {

    public int age;

    public string firstName;

    public string lastName;

    function __init(int age, string firstName, string lastName) {

        self.age = age;

        self.firstName = firstName;

        self.lastName = lastName;

    }

    function getFullName() returns string {

        return self.firstName + " " + self.lastName;

    }

};

public function main() {

    Person p1 = new(5, "John", "Doe");    

    io:println(p1.getFullName());

}

Ahora podemos ver la influencia de Go. Porque tiene la misma forma de manejar errores, los retorna y sigue la filosofía de que el error es un resultado más : 

import ballerina/io;

const ACCOUNT_NOT_FOUND = "AccountNotFound";

const INVALID_ACCOUNT_ID = "InvalidAccountID";

function getAccountBalance(int accountID) returns int|error {

    if (accountID < 0) {

        return error(INVALID_ACCOUNT_ID, accountID = accountID);

    } else if (accountID > 100) {

        return error(ACCOUNT_NOT_FOUND, accountID = accountID);

    }

    return 600;

}

public function main() {

    error simpleError = error("SimpleErrorType", message = "Simple error occurred");

    io:println("Error: ", simpleError.reason(),

                ", Message: ", simpleError.detail()?.message);

    int|error result = getAccountBalance(-1);

    if (result is int) {

        io:println("Account Balance: ", result);

    } else {

        io:println("Error: ", result.reason(),

                    ", Account ID: ", result.detail()["accountID"]);

    }

}

Y por último un ejemplo de interacción con Java : 

import ballerinax/java;

import ballerina/io;

function newArrayDeque() returns handle = @java:Constructor {

    class: "java.util.ArrayDeque"

} external;

function newArrayDequeWithInitialCapacity(int numElements) returns handle = @java:Constructor {

    class: "java.util.ArrayDeque",

    paramTypes: ["int"]

} external;

public function main() {

    var arrayDeque = newArrayDeque();

    io:println(arrayDeque);

    var arrayDequeWithCapacity = newArrayDequeWithInitialCapacity(10);

    io:println(arrayDequeWithCapacity);

}

No mucho que explicar, de esta manera podemos llamar clases java. 

Conclusión, me gusto!

Toma buenas cosas de diferentes lenguajes y lo mezcla de forma equilibrada. Lo único que le critico es el ";" que no lo veo necesario.  Por lo dicho, vamos a tener que estudiar un nuevo lenguaje :P

Dejo link: https://ballerina.io/v1-1/learn/by-example/