JS vs Haskell una comparación impura MedellínJS Julio 21, 2021 

Sobre mí ● Papá de Thiago. ● Desarrollador de Software. ● Actualmente trabajando en LaHaus como “FrontEnd” Developer. ● JS lover. ● Haskell lover. ● ... @JESSECOGOLLO 

JS vs Haskell 

TÍTULO DE LA CONFERENCIA CONFERENCIA ● Si comparto lo que he aprendido, estoy aprendiendo dos veces. ● Estoy haciendo un curso de Haskell. Compartir conocimientos Motivación ● Mostrar que cuando estás desarrollando en JS, algunas veces estas implementado codigo que seria fácil de aplicar/entender en Haskell ● Mostrar la versatilidad de JS que permite aplicar algunos cosas que en Haskell son muy naturales. Desarrolladores JS/Haskell ● ... Personas curiosas 

TÍTULO DE LA CONFERENCIA CONFERENCIA ● Me pueden preguntar durante la presentación. ● Canal Telegram para preguntas (temporal). ● Point-free style -> Cuando estas programando con las funciones; donde la data/parámetros no está directamente mencionada.. ● En Haskell las “variables” se llaman `named`. en otras palabras, en haskell podemos a las expresiones darle nombres. Estos es que los valores de esos nombramientos NUNCA cambia. Preguntas/Dudas/Inquietudes/Feedback FYI 

Contenido ● REPL ● Comentarios ● Expresiones ● Funciones ● Tipos ● Listas ● Funciones anónimas ● Funciones de orden superior ● Operadores Booleanos y expresiones ● Operadores lógicos ● ... 

Contenido ● I/O ● Recursividad ● folds ● Currying ● Libro de escuela** ● Juego de adivinanza** ● … 

TÍTULO DE LA CONFERENCIA CONFERENCIA ● Un lenguaje puramente funcional ● Tipado estatico ● Declarativo ● Inferencia de tipos ● Concurrente ● Perezoso Caracteristicas Qué es Haskell ? 

TÍTULO DE LA CONFERENCIA CONFERENCIA ● Tipado dinámico ● características de programación funcional ● Orientado a prototipos (prototype) ● Interpretado * V8 y otros motores lo compilan ● Asíncrono Caracteristicas Qué es JavaScript ? 

TÍTULO DE LA CONFERENCIA CONFERENCIA ● NodeJS ● Haskell Instalación 

TÍTULO DE LA CONFERENCIA CONFERENCIA ● Online ○ Node - Haskell ● Local REPL 

Comentarios Haskell JavaScript -- Comentario de una sola línea {- Comentario múltiples línea -} // Comentario de una sola línea /* Comentario múltiples línea */ 

Expresiones Haskell Solo hay expresiones. En otras palabras, código que se computa y retorna un valor. JavaScript Existen expresiones. pero también sentencias, que son código que ayudan a manejar código ejm: ciclos, condicionales, etc... 

Funciones // JavaScript function hello1 (name) { return "Hello, " + name } // hello1("medJS") // Hello, medJS function hello2 (name) { return `Hello, ${name}` } // hello2("medJS") // Hello, medJS -- Haskell hello name = "Hello, "++name -- hello "medJS" -- hello("medJS") -- hello, medJS 

TÍTULO DE LA CONFERENCIA CONFERENCIA Tipos Son los tipos de valores que puede ser una variable. Ejemplo: ● Caracteres ● Enteros ● Booleanos f :: Int -> Int -> Int f x y = x*y+x+y // f :: Int -> Int -> Int function f (x, y) { return x*y+x+y } 

Listas // JavaScript const list = [ "A", "list", "of", "strings"] -- Haskell -- Las listas en Haskell solo permiten elementos -- del mismo tipo list = [ "A", "list", "of", "strings"] 

Funciones anónimas // JavaScript const f = (x, y) => x*y+x+y // f(2,3) -- Haskell f = \x y -> x*y+x+y -- f 2 3 

Funciones de orden superior -- Haskell map (\x -> x*2+1) [1..10] // JavaScript Array.from({length: 10}, (_, i) => i + 1).map(x => x*2+1) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => x*2+1) 

Igualdad == ó === No Igualdad /= ó !== ó !=== Mayor (igual) que >, >= Menor (Igual) que <, <= Operadores Booleanos 

Negation AND Solo es verdadero, cuando todos los evaluados son verdadero OR Si al menos uno de los evaluados es verdadero, el resultado es verdadero Conditional En Haskell siempre el then y el else deben retornar el mismo tipo Operadores Lógicos not, ! && || if 

I/O // JavaScript const readline = require('readline') const rl = readline.createInterface({ input: process.stdin, output: process.stdout }) const question = (question) => { return new Promise(function (resolve) { rl.question(question, function(value) { return resolve(value) }) }) } async function greet() { try { const name = await question('') const communityName = await question('') const eventName = await question('') console.log(`Hola ${name}`) console.log(`bienvenido al meetup de ${communityName}`) console.log(`Espero ${eventName} te guste`) console.log('sigue aprendiendo !!! 💪') } catch(err) { console.log('err', err) } finally { process.exit(0) } } greet() -- Haskell greet() = do name <- getLine communityName <- getLine eventName <- getLine putStrLn ("Hola " ++ name) putStrLn ("bienvenido al meetup de " ++ communityName) putStrLn ("Espero " ++ eventName ++ " te guste") putStrLn "sigue aprendiendo !!! 💪" 

Recursividad // JavaScript const myFilter = (fn, arr) => { const [head, ...tail] = arr; return arr.length === 0 ? [] : fn(head) ? [head].concat(myFilter(fn, tail)) : myFilter(fn, tail) } // const greaterThan3 = x => x > 3 // const myArray = [1,2,3,4,5,6,7,3] // const result = myFilter(greaterThan3, myArray) // console.log('result', result) -- Haskell myFilter :: (a -> Bool) -> [a] -> [a] myFilter pred [] = [] myFilter pred (x:xs) | pred x = x : myFilter pred xs | otherwise = myFilter pred xs -- myFilter (\x -> x > 3) [1,2,3,4,5,6,7] -- myFilter (>3) [1,2,3,4,5,6,7] 

Muchas computaciones que serían ciclos `for/while` en un lenguaje imperativo son naturalmente expresados como computaciones de listas en lenguajes funcionales -- map :: (a -> b) -> [a] -> [b] -- foldl :: (b -> a -> b) -> b -> [a] -> b -- foldr :: (a -> b -> b) -> b -> [a] -> b folds 

maps / foldl /foldr // JavaScript const lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] // map const f = (x) => x*(x+1) const lst_ = lst.map(f) // foldl const g = (acc, value) => acc / value const accl = lst.reduce(g) // foldr const gr = (acc, value) => value / acc const accr = lst.reduceRight(gr) console.log(lst_) console.log(accl) console.log(accr) -- Haskell lst = [1..10] -- map f x = x*(x+1) lst_ = map f lst -- foldl g = (/) accl = foldl g 1 lst -- foldr g' = (/) accr = foldr g' 1 lst -- main main = do print lst_ print accl print accr -- stack runhaskell folds.hs 

Currying La técnica de re-escribir una función con múltiples argumentos dentro de una secuencia de funciones con un solo argumento es llamado `currying`. 

-- Haskell -- currying :: X -> Y -> Z -> A currying :: Int -> Int -> Int -> Int -- currying 3 4 5 currying x y z = x*y+z -- currying' 3 4 5 currying' = \x y z -> x*y+z -- (currying'' 3) 4 5 currying'' = \x -> (\y z -> x*y+z) -- ((currying''' 3) 4) 5 currying''' = \x -> (\y -> (\z -> x*y+z)) currying // JavaScript const currying = (x, y, z) => x*y+z const currying1 = (x) => (y, z) => x*y+z const currying2 = (x) => (y) => (z) => x*y+z console.log(currying(3, 4, 5)) console.log(currying1(3)(4, 5)) console.log(currying2(3)(4)(5)) const temp1 = currying2(3) const temp2 = temp1(4) const temp3 = temp2(5) console.log('->', temp3) 

Letras - Libro de aprendizaje (.js / .hs) “ El código consiste en obtener una palabra y retornar una frase de libro de primaria. Ejemplo: recibimos ‘casa’ y retornamos ‘C de casa’ o ‘Medellín’ y retornamos ‘M de Medellín’.” 

Ahorcado - Adivina la palabra (.js / .hs) “ El juego consiste en un jugador que debe adivinar una palabra y debe ir adivinando de a una letra por turno. Si la letra es correcta, la letra se muestra. De lo contrario, el jugador pierde una estrella.” 

Preguntas? 

TÍTULO DE LA CONFERENCIA CONFERENCIA ● Paso a paso en nodejs.dev. ● Módulo práctico funcionara para JS ramdaJS Javascript Recursos ● Curso Haskell en futureLearn.com ● Grupo de estudio de Haskell en español Haskell ● Discord (Club de algoritmia Hispano) Algoritmos 

Gracias ❤