function - Estructura básica de un programa Haskell

data-structures subroutine

Question

Muchos de los tutoriales de Haskell que he analizado se centran casi por completo en la sintaxis con muy poca cobertura sobre cómo estructurar un programa.

Por ejemplo...

Aquí hay un resumen escueto de una aplicación C ++:

#include <iostream>
using namespace std;

int addition (int a, int b)
{
  int r;
  r=a+b;
  return (r);
}

int main ()
{
  int z;
  z = addition (5,3);
  cout << "The result is " << z;
  return 0;
}

Cuando comencé a aprender C ++, ejemplos como estos me ayudaron inmensamente a aprender a ensamblar piezas individuales en programas de trabajo. Tal vez estoy buscando en los lugares equivocados, pero no he podido encontrar ningún ejemplo que sea tan directo y simple para Haskell.

Ya sé MUCHA sintaxis Haskell. Puedo escribir comprensiones de listas recursivas y manipular cadenas, enteros y enumerar el wazoo.

En resumen: solo quiero saber cómo se ven las dos subrutinas y el pase variable en Haskell. Si puedo obtener una comprensión básica sobre cómo estructurar un programa Haskell, finalmente podría ser útil para poner en práctica toda la sintaxis que he aprendido.

Answer 1

La estructura de un programa Haskell es sorprendentemente simple. Usted tiene una función main que hace IO, y eso es todo. Entonces lo básico:

module Main where

addition a b = a + b

main :: IO ()
main = do let z = addition 5 3
          putStrLn $ "The result is: " ++ show z

Ahora puedes compilar esto en un programa simple usando algo como:

ghc --make Main.hs -o program

y debería producir un ejecutable llamado programa.

En general, los programas se estructuran como funciones casi puras haciendo el cálculo real junto con partes discretas del código que trata con el IO. (Por supuesto, hay excepciones a esto, pero la idea general de escribir tanto código puro como sea posible es bastante universal.)

Como casi todo se expresa como un conjunto de funciones puras, no se pasan variables entre ellas; las funciones se comunican mediante la aprobación de argumentos.

La parte de tu código que hace IO está anclada en main . En la mayoría de los casos, todo su IO pasará por main; incluso si escribe acciones de E / S por separado y les da nombres, en última instancia se ejecutarán comenzando desde la main .

Un "grupo de funciones" en Haskell se llama un "módulo". Puede tener múltiples módulos, cada uno en su propio archivo:

module Blarg (exportedFunction) where

helper a b = ... -- this will *not* be exported
exportedFunction a b = helper a b -- this *will* be exported

Solo los identificadores entre paréntesis serán realmente exportados; el resto está oculto. Si no incluye los paréntesis, todo se exportará de manera predeterminada.

Guarde este archivo como Blarg.hs . Ahora puedes importarlo en Main :

import Blarg

Otra forma útil de agrupar funciones es where :

complicatedFunction a b c = helper 0
  where helper count = ...

De esta manera, helper solo está en el alcance de complicatedFunction y también tiene acceso a a , c desde complicatedFunction .