|
miércoles, 17 de junio de 2020
Libros de Java Geeks
Análisis de texto usando funciones de orden superior
- reconociendo los caracteres del sistema de escritura,
- palabras identificativas,
- identificar oraciones,
- identificar párrafos, etc.
Para poder hacerlo, necesitamos conocer el sistema de escritura, la ortografía y la gramática del idioma en el que está escrito el documento.
Para analizar texto estructurado como el código fuente del programa, HTML o JSON, el problema es similar.
Hasta ahora, hemos visto funciones que toman funciones como argumentos. Las funciones también pueden devolver funciones como valores
Por ejemplo, aplicación parcial de una función:
sum = foldl (+) 0
Aquí (suma) es el resultado devuelto por la aplicación parcial de (foldl).
Más explícitamente, podemos escribir esto como:
sum = \xs -> foldl (+) 0 xs
Ambos son, por supuesto, la misma cosa, solo diferentes interpretaciones.
Podemos usar este concepto para generar funciones parametrizadas
Por ejemplo, la siguiente función genera funciones que agregan un número constante a su argumento:
gen_add_n = \n ->
\x -> x+n
add_3 = gen_add_n 3
add_7 = gen_add_n 7
add_3 5 --> 8
add_7 4 --> 11
Por supuesto, esto no se limita a las constantes numéricas
Por ejemplo, la siguiente función genera funciones que realizan una operación aritmética dada en un número constante y su argumento:
gen_op_n = \op n ->
\x -> x `op` n
add_3 = gen_op_n (+) 3
mult_7 = gen_op_n (*) 7
add_3 5 --> 8
mult_7 4 --> 28
Para hacer que el problema de análisis sea más concreto, suponga que debe analizar la siguiente receta e identificar los diferentes pasos necesarios en la preparación.
Hervir una olla grande de agua. A diferencia de la pasta italiana, no es necesario salar el agua. Una vez que esté hirviendo, sostenga los fideos sobre el agua y espolvoréelos hilo por mechón. Una vez que todos los fideos estén adentro, revuelva suavemente para que estén todos sumergidos en el agua. Vuelva a hervir suavemente el agua y luego baje el fuego para que el agua hierva a fuego lento. (Esto difiere del 'hervor rodante' que se recomienda para la pasta). Si el agua amenaza con hervir, agregue aproximadamente 1/2 taza de agua fría (pero si baja el fuego a fuego lento y tenga una olla lo suficientemente grande) , esto no debería ser necesario). Cocine durante aproximadamente 7 a 8 minutos, o siguiendo las instrucciones del paquete (para fideos más delgados, de 5 a 6 minutos puede ser suficiente. Pruebe comiendo un mechón; debe cocinarse bien, no al dente, pero tampoco blanda).
Típicamente, un programa funcional se organiza alrededor de una estructura de datos en forma de árbol con un tipo de datos algebraicos que representa los datos centrales.Un analizador lee la entrada de texto y genera el árbol. Las funciones realizan transformaciones o recorridos en el árbol.
La función Show imprimen el árbol (original o transformado)
Los combinadores de analizador son funciones que le permiten combinar analizadores más pequeños en otros más grandes. Son funciones de orden superior que toman funciones como argumentos y devuelven funciones. Una biblioteca de combinador de analizador proporciona analizadores básicos (para palabras, números, etc.) y combinadores.
Parsec: combinadores de análisis monádico Hay muchas bibliotecas de análisis para Haskell. Parsec opera en una mónada.
Es posible que haya escuchado el término mónada antes, y discutiremos el concepto en detalle en una sesión posterior. Haskell usa mónadas para estructurar cálculos. Ya te has encontrado con la mónada IO, que debes usar para realizar IO en un programa Haskell. Un ejemplo típico es
hello :: String -> IO String
hello x =
do
putStrLn ("Hello, " ++ x)
putStrLn "What's your name?"
name <- getLine
return name
Esto ilustra las características sintácticas clave de una mónada: la palabra clave do, la secuencia de comandos, la forma de extraer información de un cálculo monádico utilizando la flecha izquierda <- y la palabra clave return. De hecho, el uso de la notación do es bastante similar a la programación imperativa.
También tenga en cuenta el valor de retorno de nuestra función hello: no solo String sino IO String. Un cálculo realizado en una mónada devuelve un tipo "monádico", decimos que la cadena se devuelve dentro de la mónada.
Por ejemplo, supongamos que queremos analizar una cadena de la forma (<etiqueta>), donde (etiqueta) debe ser una palabra, y devolver la etiqueta como un tipo (Etiqueta).
data Tag = MkTag String
parseTag :: Parser Tag
parseTag =
do char '<'
x <- identifier
char '>'
return (MkTag x)
Como puede ver, el analizador consta de una serie de funciones (por ejemplo, char e identificador) que se llaman secuencialmente. Además, el valor de retorno es de tipo Parser Tag, no simplemente Tag. Esto se debe a que parseTag no devuelve un valor, sino que devuelve un analizador. Podemos combinar este analizador con otros analizadores, y luego podemos ejecutar el analizador final en nuestros datos.
Para probar su analizador, inicie ghci:
[wim@fp4 ~]$ 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.
Then, import Parsec:
Prelude> import Text.ParserCombinators.Parsec
Parsec proporciona la práctica función parseTest, que toma un analizador y una cadena y la ejecuta. Intentemos ejecutar el analizador char 'b' en la cadena "contras":
Prelude Text.ParserCombinators.Parsec> parseTest (char 'b') "cons"
Loading package bytestring-0.9.2.1 ... linking ... done.
Loading package transformers-0.2.2.0 ... linking ... done.
Loading package mtl-2.0.1.0 ... linking ... done.
Loading package array-0.4.0.0 ... linking ... done.
Loading package deepseq-1.3.0.0 ... linking ... done.
Loading package text-0.11.2.0 ... linking ... done.
Loading package parsec-3.1.2 ... linking ... done.
Because the string “cons” does not contain the character ‘b’, we get a parse error:
parse error at (line 1, column 1):
unexpected 'c'
expecting 'b'Probemos con char 'c':
Prelude Text.ParserCombinators.Parsec> parseTest (char 'c') "cons"
'c'
Prelude Text.ParserCombinators.Parsec>
This time the parse succeeded.
El código real para el ejemplo parseTag requiere algunos módulos y definiciones adicionales
Como un ejemplo simple, definamos parseDiv como:
-- the "deriving Show" is needed to let `ghci` print the result
data Tag = MkTag String deriving Show
parseDiv = do
string "<div>"
return (MkTag "div")
Para definir esta función en ghci, puede escribir esto en una línea de la siguiente manera:
let parseDiv = do { string "<div>";return $ MkTag "div" }
Ahora podemos ejecutar este analizador utilizando la función parseTest:
Prelude Text.ParserCombinators.Parsec> parseTest parseDiv "<div>"
Loading package parsec-2.1.0.1 ... linking ... done.
MkTag "div"
Prelude Text.ParserCombinators.Parsec> parseTest parseDiv "div"
parse error at (line 1, column 1):
unexpected "d"
expecting "< "
Prelude Text.ParserCombinators.Parsec>
Todos los combinadores de analizador son funciones que devuelven funciones.
Es la función devuelta que opera en la cadena, no la función del combinador del analizador.
Los analizadores básicos ((identifier),(natural),(char)) no toman argumentos (por ejemplo (identifier)) o una o más cadenas para la parametrización (por ejemplo (char)).
char = \ch -> \str ->
-- try to match the character ch
-- return the result
Si la coincidencia tiene éxito, la cadena coincidente se elimina de la cadena de entrada; de lo contrario, se devuelve la cadena original, p.
char "c" "cons" -->
"c"
char "b" "cons" -->
parse error at (line 1, column 1):
unexpected "c"
expecting "b"
Los combinadores de analizador como <|> y parens toman otros analizadores como argumentos.
parens = \p ->
\str ->
-- first match "("
-- perform the parse of p if "(" was found
-- then match ")"
-- return the result
A menudo queremos probar un analizador sintáctico; Si eso falla, intente con otro. El combinador de elección <|> proporciona esta funcionalidad.
Ejemplo: (letter_digit) coincidirá con una letra o un dígito.
letter_digit :: Parser Char
letter_digit =
do x <- letter <|> digit
return x
Prelude Text.ParserCombinators.Parsec> parseTest letter_digit "b2"
"b"
Prelude Text.ParserCombinators.Parsec> parseTest letter_digit "2b"
"2"
Prelude Text.ParserCombinators.Parsec> parseTest letter_digit "*2"
parse error at (line 1, column 1):
unexpected "*"
expecting letter or digit
Supongamos que queremos hacer coincidir la bolsa o el pantano, pero nada más.
bag_bog :: Parser String
bag_bog =
do xs <- string "bag" <|> string "bog"
return xs
Prelude Text.ParserCombinators.Parsec> parseTest bag_bog "bag"
"bag"
Prelude Text.ParserCombinators.Parsec> parseTest bag_bog "bug"
parse error at (line 1, column 1):
unexpected "u"
expecting "bag"
But there’s a problem!
Prelude Text.ParserCombinators.Parsec> parseTest bag_bog "bog"
parse error at (line 1, column 1):
unexpected "o"
expecting "bag"
La primera "bag" de la cadena del analizador coincidió con la b pero luego falló en la a. Ahora ha consumido el b. La segunda cadena del analizador "bog" ahora intenta hacer coincidir b contra o, lo que por supuesto falla.
try: no consuma entradas en el análisis fallido
Para permitirle analizar provisionalmente sin consumir ninguna entrada, Parsec proporciona la función try:
bag_bog_try :: Parser String
bag_bog_try =
do xs <- try (string "bag") <|> string "bog"
return xs
Prelude Text.ParserCombinators.Parsec> parseTest bag_bog_try "bag"
"bag"
Prelude Text.ParserCombinators.Parsec> parseTest bag_bog_try "bug"
parse error at (line 1, column 1):
unexpected "u"
expecting "bog"
Prelude Text.ParserCombinators.Parsec> parseTest bag_bog_try "bog"
"bog"
Some parsers from the library
La biblioteca Parsec proporciona algunos analizadores pequeños que son útiles para definir los más grandes:
(char \; “?”) - (char) se aplica a un personaje y le da un analizador que coincide con ese personaje
(letter): coincide con cualquier letra
(digit): coincide con cualquier dígito
(string): coincide con una cadena de caracteres
(stringLiteral \; “xyz *”): coincide con el argumento de cadena
(many \; p): coincide con 0 o más apariciones de analizador (p)
(many1 \; p): coincide con 1 o más apariciones de analizador (p)
varname :: Parser String
varname =
do x <- letter
xs <- many (letter <|> digit)
return (x:xs)
Prelude Text.ParserCombinators.Parsec> parseTest varname "a4cc7*5"
"a4cc7"
Prelude Text.ParserCombinators.Parsec> parseTest varname "34a"
parse error at (line 1, column 1):
unexpected "3"
expecting letter
Las expresiones aritméticas son complejas de analizar debido a las reglas de precedencia y la aridad de los operadores.
Parsec proporciona soporte para el análisis de expresiones, por lo que no tiene que escribir su propio analizador de expresiones.
expr_parser :: Parser Expr
expr_parser = buildExpressionParser optable term <?> "expression"
optable =
let
op name assoc =
Infix ( do { reservedOp name;
return (\x y ->(Op (MkOpExpr name x y))) } ) assoc
prefix name =
Prefix (
reservedOp name >>
return (\x->(Pref (MkPrefixOpExpr name x))) )
in
[ [ op "*" AssocLeft, op "/" AssocLeft, op "%" AssocLeft ]
, [ op "+" AssocLeft, op "-" AssocLeft ], [ prefix "-" ] ]
Este ejemplo usa una sintaxis adicional de mónada: puede usar llaves y punto y coma en lugar de sangría; y el operador >> también es una forma más corta de escribir la notación do:
do
expr1
expr2
Se puede escribir como
expr1 >> expr2
También tenga en cuenta el uso del operador <?>, Que se utiliza para definir un mensaje de error personalizado en caso de que falle un análisis sin consumir ninguna entrada. Esta es una característica de depuración muy útil.
Parsec también tiene soporte para lenguajes de programación con un mecanismo para definir la sintaxis y las palabras clave a través de makeTokenParser.
Para casos simples, puede usar emptyDef.
import Text.ParserCombinators.Parsec.Expr
import qualified Text.ParserCombinators.Parsec.Token as P
lexer = P.makeTokenParser emptyDef
parens = P.parens lexer
commaSep = P.commaSep lexer
-- and many more
lunes, 15 de junio de 2020
Tenemos Patreon!!!
Para el que no sabe patreon, es una pagina para patrocinar cosas, en este caso el blog. Y tenes diferentes niveles de patrocinado, podes solo donar o subir de nivel y en este, pedir posts.
La idea es que con lo donado haga cursos y pueda crear más posts.
Dejo link: https://www.patreon.com/emanuelpeg
domingo, 14 de junio de 2020
JDBC en fibras
Si bien JDBC y otras tecnologías exponen API de bloqueo (principalmente debido a la espera de I/O), se está trabajando en el Project Loom. Loom presenta Fibers como una abstracción ligera que convertirá las API de bloqueo en no bloqueantes. Esto es posible mediante el cambio de pila tan pronto como una invocación golpea una API de bloqueo. Entonces, el Fiber subyacente intenta continuar en un flujo anterior que estaba usando una API de bloqueo.
El modelo de ejecución de Fiber reduce drásticamente la cantidad de hilos nativos requeridos. La consecuencia es una mejor escalabilidad y un comportamiento sin bloqueo, al descargar las llamadas de bloqueo a un ejecutor. Todo lo que necesitamos aquí es una API adecuada que permita el consumo de un JDBC sin bloqueo implementado con Fibras.
comsat-jdbc proporciona un contenedor de bloqueo de fibra de la API JDBC, para que pueda usar su conexión dentro de fibras en lugar de hilos Java normales.
¿Por qué harías eso? Debido a que las fibras son hilos livianos y puede tener muchas más fibras que hilos en su JVM. "Muchos más" significa que estamos hablando de millones frente a un puñado de miles.
Esto significa que tiene mucha más capacidad de concurrencia en su sistema para hacer otras cosas en paralelo mientras espera la ejecución de JDBC, ya sean cálculos simultáneos y/o paralelos (como el intercambio de mensajes de actores) o fibra -bloqueo de I/O (p. ej., servicio de solicitudes, invocación de microservicios, lectura de archivos a través de NIO en fibra o acceso a otras fuentes de datos habilitadas para fibra como MongoDB).
Las Fibras son una solución al problema de bloqueo de JDBC. Deberíamos hablar un poco más del proyecto Loom pero pero pero, esto es otra historia y va ha ser contada en otro post ...
Programación reactiva + bases de datos relacionales = R2DBC
Al carecer de una API estándar y la falta de disponibilidad de controladores, un equipo de Pivotal comenzó a investigar la idea de una API relacional reactiva que sería ideal para fines de programación reactiva. Y en ese momento nació, R2DBC que significa Conectividad de base de datos relacional reactiva.
Entre las características de R2DBC podemos nombrar:
R2DBC se basa en la especificación de Reactive Streams, que proporciona una API sin bloqueo totalmente reactiva.
Trabaja con bases de datos relacionales. A diferencia de la naturaleza bloqueante de JDBC, R2DBC le permite trabajar con bases de datos SQL utilizando una API reactiva.
Admite soluciones escalables. Con Reactive Streams, R2DBC le permite pasar del modelo clásico de "un subproceso por conexión" a un enfoque más potente y escalable.
Proporciona una especificación abierta. R2DBC es una especificación abierta y establece una interfaz de proveedor de servicios (SPI) para que los proveedores de controladores implementen y los clientes los consuman.
Actualmente existen las siguientes implementaciones :
- cloud-spanner-r2dbc: controlador para Google Cloud Spanner
- jasync-sql: contenedor R2DBC para Java & Kotlin Async Database Driver para MySQL y PostgreSQL escrito en Kotlin.
- r2dbc-h2: controlador nativo implementado para H2 como base de datos de prueba.
- r2dbc-mariadb: controlador nativo implementado para MariaDB.
- r2dbc-mssql: controlador nativo implementado para Microsoft SQL Server.
- r2dbc-mysql: controlador nativo implementado para MySQL.
- r2dbc-postgres: controlador nativo implementado para PostgreSQL.
Los estándares existentes, basados en el bloqueo de I/O, cortan la programación reactiva de los usuarios de bases de datos relacionales. R2DBC especifica una nueva API para permitir código reactivo que funciona de manera eficiente con bases de datos relacionales.
R2DBC es una especificación diseñada desde cero para la programación reactiva con bases de datos SQL. Define un SPI sin bloqueo para implementadores de controladores de bases de datos y autores de bibliotecas de clientes. Los controladores R2DBC implementan completamente el protocolo de conexión de la base de datos sobre una capa de I/O sin bloqueo.
R2DBC está pensado principalmente como un SPI del controlador para ser consumido por las bibliotecas del cliente y no para ser utilizado directamente en el código de la aplicación.
R2DBC admite aplicaciones nativas en la nube que utilizan bases de datos relacionales como PostgreSQL, MySQL y otras. Los desarrolladores de aplicaciones son libres de elegir la base de datos adecuada para el trabajo sin estar limitados por las API.
Spring Data R2DBC, parte de la familia Spring Data, facilita la implementación de repositorios basados en R2DBC. Spring Data R2DBC aplica abstracciones de la familia de Spring y soporte de repositorio para R2DBC. Facilita la creación de aplicaciones basadas en Spring que utilizan tecnologías de acceso a datos relacionales en una stack de aplicaciones reactivas.
Spring Data R2DBC pretende ser conceptualmente fácil. Para lograr esto, NO ofrece almacenamiento en caché, carga diferida, escritura detrás o muchas otras características de los marcos ORM. Esto hace que Spring Data R2DBC sea un mapeador de objetos simple, limitado y con opiniones.
Spring Data R2DBC permite un enfoque funcional para interactuar con su base de datos proporcionando DatabaseClient como el punto de entrada para las aplicaciones.
Veamos un ejemplo con postgres :
PostgresqlConnectionFactory connectionFactory = new PostgresqlConnectionFactory(PostgresqlConnectionConfiguration.builder()
.host(…)
.database(…)
.username(…)
.password(…).build());
DatabaseClient client = DatabaseClient.create(connectionFactory);
Mono<Integer> affectedRows = client.execute()
.sql("UPDATE person SET name = 'Joe'")
.fetch().rowsUpdated();
Flux<Person> all = client.execute()
.sql("SELECT id, name FROM person")
.as(Person.class)
.fetch().all();
Otro enfoque para atacar el bloqueo de JDBC es Fibers. Fibers como una abstracción ligera que convertirá las API de bloqueo en no bloqueantes. Esto es posible mediante el cambio de pila tan pronto como una invocación ... Pero eso es otra Historia y va ha ser contada en otro post ...
Dejo links:
Programación reactiva y bases de datos relacionales
Los beneficios completos de la programación reactiva entran en vigencia solo si toda el stack de tecnologías es reactiva y si todos los componentes participantes (código de aplicación, contenedor de tiempo de ejecución, integraciones) respetan la ejecución diferida, las API sin bloqueo y la naturaleza de flujo de flujo de datos, básicamente siguiendo los supuestos subyacentes .
Si bien es posible llevar componentes no reactivos a una aplicación que está escrita en un estilo funcional-reactivo, el resultado neto es que los beneficios reales esperados, disminuyen. En el peor de los casos, hay poca o ninguna diferencia en el comportamiento del tiempo de ejecución. Sin embargo, la programación reactiva ayuda a mejorar la legibilidad del código.
Si observamos el ecosistema reactivo, descubriremos varios frameworks, bibliotecas e integraciones. Cada uno de ellos tiene sus puntos fuertes específicos. Muchas áreas funcionales están bien cubiertas, ya sea con un enfoque genérico o dentro del contexto de un framework reactivo particular.
Java utiliza JDBC como tecnología principal para integrarse con bases de datos relacionales. JDBC es de naturaleza bloqueante: no hay nada sensato que se pueda hacer para mitigar la naturaleza bloqueante de JDBC. La primera idea de cómo hacer que las llamadas no se bloqueen es descargar las llamadas JDBC a un ejecutor (generalmente grupo de subprocesos). Si bien este enfoque funciona, viene con varios inconvenientes que descuidan los beneficios de un modelo de programación reactiva.
Los grupos de subprocesos requieren, no es de extrañar, subprocesos para ejecutarse. Los tiempos de ejecución reactivos suelen utilizar un número limitado de subprocesos que coinciden con el número de núcleos de CPU. Los hilos adicionales introducen gastos generales y reducen el efecto de limitación de hilos. Además, las llamadas JDBC generalmente se acumulan en una cola, y una vez que los hilos están saturados de solicitudes, el grupo se bloqueará nuevamente. Entonces, JDBC ahora no es una opción.
Hay un par de controladores independientes, como el reactive-pg-client. Estos controladores vienen con una API específica del proveedor y no son realmente adecuados para una adopción más amplia.
Como no hay una API estándar y la falta de disponibilidad de controladores, un equipo de Pivotal comenzó a investigar la idea de una API relacional reactiva que sería ideal para fines de programación reactiva. Se les ocurrió R2DBC que significa Conectividad de base de datos relacional reactiva. Pero eso es otra Historia y va ha ser contada en otro post ...
Dejo link:
jueves, 11 de junio de 2020
Guards, Guards!
fx
| predicate1 = expression1
| predicate2 = expression2
| predicate3 = expression3
Por ejemplo, el valor absoluto de un número es su magnitud, es decir, ignorar su signo. Podría definir una función para calcular el valor absoluto con un condicional if / then / else
absolute x = if (x<0) then (-x) else x
o con guards
absolute x
| x<0 = -x
| otherwise = x
Observe cómo no hay un signo igual en la primera línea de la definición de la función, pero hay un signo igual después de cada guard.
La opción por default debe ser la ultima.
Guards son más fáciles de leer que if/then/else y más si hay más de dos resultados condicionales
Por ejemplo, piense en anotar en el deporte del golf. Para un solo hoyo, un jugador realiza varios golpes. Hay un puntaje "par" para el hoyo, que es el número esperado de golpes.
holeScore :: Int -> Int -> String
holeScore strokes par
| strokes < par = show (par-strokes) ++ " under par"
| strokes == par = "level par"
| strokes > par = show(strokes-par) ++ " over par"
¿Cómo podríamos arreglar esto? Tal vez podríamos convertir la Guard final en otra cosa y también refactorizar con una cláusula where.
holeScore :: Int -> Int -> String
holeScore strokes par
| score < 0 = show (abs score) ++ " under par"
| score == 0 = "level par"
| otherwise = show(score) ++ " over par"
where score = strokes-par
Observe que la variable de puntaje definida en la cláusula where está dentro del alcance de los tres Guards.
Un valor con un tipo de datos algebraico puede tener una de varias formas diferentes, como una hoja o un nodo, en el caso de las estructuras de árbol. Por lo tanto, para procesar dicho valor necesitamos varios segmentos de código, uno para cada forma posible. La expresión de caso examina el valor y elige la cláusula correspondiente. Es como un Guard, pero selecciona en función de la forma del valor, es decir, coincide con el patrón.
Aquí hay un tipo de datos de suma para mis mascotas.
data Pet = Cat | Dog | Fish
Y así es como saludo a mis mascotas.
hello :: Pet -> String
hello x =
case x of
Cat -> "meeow"
Dog -> "woof"
Fish -> "bubble"
Tenga en cuenta que a cada patrón le sigue una flecha y luego un valor. También tenga en cuenta que cada patrón está alineado verticalmente. ¡La sangría realmente importa en Haskell!
Bien, ahora supongamos que queremos hacer que el tipo de datos sea un poco más sofisticado. Agreguemos un loro con un nombre de tipo cadena.
data Pet = Cat | Dog | Fish | Parrot String
hello :: Pet -> String
hello x =
case x of
Cat -> "meeow"
Dog -> "woof"
Fish -> "bubble"
Parrot name -> "pretty " ++ name
Ahora el patrón incluye una variable, que está asociada con el valor concreto para el nombre del Parrot.
hello (Parrot "polly")
De la misma manera que hay un caso general para los Guards, podemos tener un patrón general para un caso. Es el carácter de subrayado, que significa "no me importa" o "coincide con nada"
Entonces podríamos redefinir hola como:
hello :: Pet -> String
hello x =
case x of
Parrot name -> "pretty " ++ name
_ -> "grunt"
martes, 9 de junio de 2020
Datos de Erlang: números y atoms
Entonces, comencemos mirando los números. Los números en Erlang pueden ser enteros y flotantes. Los enteros bignums son números arbitrariamente grandes, números de precisión completa solo por defecto. Entonces, por ejemplo, puedes ver una gran cantidad de potencias de diez multiplicadas juntas. Pero también tenemos floats. Podemos usar diferentes bases, escribimos números a través de una base diferente poniendo la base seguida por un hash seguido inmediatamente por el número en esa base. Entonces, si escribimos dos hash uno cero cero, obtenemos el número cuatro. Si escribimos tres hash tres cuatro, obtenemos un entero ilegal porque, por supuesto, el dígito tres, el dígito cuatro no es un número legal base tres. Tendría que consistir en los dígitos cero, uno y dos. Entonces puedes usar esas diferentes bases. En particular, podemos usar hexadecimal y octal, etc. Tenemos todos los operadores habituales. .
Entonces, si escribimos 12 div 5, obtenemos la respuesta 2. Si escribimos 12.0 div 5, obtenemos un error de excepción porque lo que hemos hecho es invocar una operación entera en flotantes. Y eso es típico de Erlang. Estamos obteniendo un error de tiempo de ejecución. Así que podríamos escribir algo así en un archivo dentro de una definición de Erlang. Solo causaría un error en tiempo de ejecución. Entonces, los números son muy parecidos a los números en otros lenguajes, excepto que tenemos bignums y podemos usar diferentes bases.
Los átomos son datos que simplemente se representan a sí mismos. Entonces, si evalúo el átomo foo, que obtengo escribiendo una cadena que comienza con una letra minúscula, la respuesta es foo. No significa nada más. No es una variable. Es simplemente un dato que dice foo. Y, en general, puedo encerrar cualquier cadena de caracteres entre comillas simples. Y eso será un átomo. Entonces los átomos simplemente se representan por sí mismos. Ahora, el único cálculo que podemos hacer con los átomos es que podemos compararlos para la igualdad.
Para poder ver que si foo es igual a sí mismo y no es igual a 'I am an atom', podemos ordenarlos. Así que foo es mayor que el átomo 'I am an atom' , dado el ordenamiento lexicográfico basado en los códigos ASCII de los caracteres.
La otra forma de comparar Atoms en por patterns matching.
sábado, 6 de junio de 2020
Let y where en Haskell
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.
miércoles, 3 de junio de 2020
Libros Gratuitos de Java Code Geek
|
lunes, 1 de junio de 2020
Breve historia de Haskell
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.
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
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/
domingo, 31 de mayo de 2020
Crear un árbol binario con Haskell
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.
sábado, 30 de mayo de 2020
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 :
|
|
| ||||||||||||||||||||||||||||||||||||
Suscribirse a:
Entradas (Atom)
