Haskell for Todos 3

 

Continuamos con el tour de Haskell, en esta ocasión veremos como crear funciones y los tipos de datos que permite manejar. Para crear un función es importante conocer la síntaxis.

Sintaxis básica para crear una función:

nombreFunc :: Tipo -> Tipo -> Tipo

En lenguajes como Javascript sería algo como esto:

function nombreFunc(a, b){
  return a + b;
}

// o así:
var nombreFunc = (a, b) => a+b;

Ejemplo 1. Crear una función con dos parámetros (x, y). Si x es 0, el resultado será el parámetro y. Si y es cero, el resultado será el parámetro x. Si ambos parámetros son distintos de 0,entonces el resultado será la suma de x+y.

RESULT = 0
X=1
Y=0

IF X == 0 THEN
   RESULT = Y
END IF

IF Y == 0 THEN
  RESULT = X
END IF

IF X!=0 AND Y!=0 THEN
  RESULT = X + Y
END IF

En este ejemplo, el resultado será 1 (el valor de X).
Si trasladamos este pseudo código a Haskell obtendremos:
A. Cuando y es igual a 0.

{- RESULT = 0
X=1
Y=0

IF Y == 0 THEN
   RESULT = X
END IF
-}

nombreFunc :: Int -> Int -> Int
nombreFunc x 0 = x

B. Cuando x es igual a cero.

{- RESULT = 0
X=0
Y=1

IF X == 0 THEN
   RESULT = Y
END IF
-}

nombreFunc :: Int -> Int -> Int
nombreFunc 0 y = y

C. Cuando ni x ni y son 0.

{- RESULT = 0
X=1
Y=1

IF X != 0 AND Y !=0 THEN
   RESULT = X+Y
END IF
-}

nombreFunc :: Int -> Int -> Int
nombreFunc x y = x+y

Código completo:
nombreFunc.hs

{-

  Esto es un comentario
   multi línea en
      Haskell

-}
nombreFunc :: Int -> Int -> Int
nombreFunc x 0 = x
nombreFunc 0 y = y
nombreFunc x y = x + y

Cargamos y ejecutamos el script en el shell de Haskell

$ ghci
> :cd /home/user/ejemplosHaskell
> :l nombreFunc.hs
> nombreFunc 0 1
1
> nombreFunc 3 0
3
> nombreFunc 3 2
5

Tipos de datos en Haskell

Como vimos a la hora de crear funciones debemos elegir el tipo de datos con los que vamos a trabajar. Haskell permite trabajar con tipos de datos como Int, Float, Double, Char, String y Bool.

Int, para datos de tipo entero

Float, para datos de tipo flotante

Double, para datos de tipo doble que requieran más precisión

Char, para datos que empleen caracteres

String, para datos que requieran cadenas de texto

Bool, para datos de tipo falso o verdadero

doble.hs

doble :: Float -> Float
doble 0 = 1.0
doble x = x*2.0

Cargando y ejecutando el script:

ghci
GHCi, version 8.6.5: http://www.haskell.org/ghc/  :? for help
Prelude> :cd /home/user/Documentos/pruebasHaskell/
Prelude> :l doble.hs 
[1 of 1] Compiling Main             ( doble.hs, interpreted )
Ok, one module loaded.
*Main> doble 3
6.0
*Main> doble 6
12.0
*Main>

verdadero.hs

verdadero :: Bool -> Bool -> Bool
verdadero x y = x && y

Cargando y ejecutando el script:

ghci
GHCi, version 8.6.5: http://www.haskell.org/ghc/  :? for help
Prelude> :cd /home/user/Documentos/pruebasHaskell/
Prelude> :l verdadero.hs 
[1 of 1] Compiling Main             ( verdadero.hs, interpreted )
Ok, one module loaded.
*Main> verdadero True True
True
*Main> verdadero False True
False
*Main>

Enlaces:

http://www.willamette.edu/~fruehr/haskell/evolution.html
https://alquimistadecodigo.blogspot.com/2013/07/vamos-codificar-con-haskell.html
https://alquimistadecodigo.blogspot.com/2021/03/haskell-for-todos.html
https://alquimistadecodigo.blogspot.com/2021/03/haskell-for-todos-2.html