Plantilla:Portada/Encabezado

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.11/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.11/ http://www.mediawiki.org/xml/export-0.11.xsd" version="0.11" xml:lang="es">
  <siteinfo>
    <sitename>Wikilibros</sitename>
    <dbname>eswikibooks</dbname>
    <base>https://es.wikibooks.org/wiki/Portada</base>
    <generator>MediaWiki 1.47.0-wmf.24</generator>
    <case>first-letter</case>
    <namespaces>
      <namespace key="-2" case="first-letter">Medio</namespace>
      <namespace key="-1" case="first-letter">Especial</namespace>
      <namespace key="0" case="first-letter" />
      <namespace key="1" case="first-letter">Discusión</namespace>
      <namespace key="2" case="first-letter">Usuario</namespace>
      <namespace key="3" case="first-letter">Usuario discusión</namespace>
      <namespace key="4" case="first-letter">Wikilibros</namespace>
      <namespace key="5" case="first-letter">Wikilibros discusión</namespace>
      <namespace key="6" case="first-letter">Archivo</namespace>
      <namespace key="7" case="first-letter">Archivo discusión</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">MediaWiki discusión</namespace>
      <namespace key="10" case="first-letter">Plantilla</namespace>
      <namespace key="11" case="first-letter">Plantilla discusión</namespace>
      <namespace key="12" case="first-letter">Ayuda</namespace>
      <namespace key="13" case="first-letter">Ayuda discusión</namespace>
      <namespace key="14" case="first-letter">Categoría</namespace>
      <namespace key="15" case="first-letter">Categoría discusión</namespace>
      <namespace key="710" case="first-letter">TimedText</namespace>
      <namespace key="711" case="first-letter">TimedText talk</namespace>
      <namespace key="828" case="first-letter">Módulo</namespace>
      <namespace key="829" case="first-letter">Módulo discusión</namespace>
      <namespace key="1728" case="first-letter">Evento</namespace>
      <namespace key="1729" case="first-letter">Evento discusión</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Plantilla:Portada/Encabezado</title>
    <ns>10</ns>
    <id>17829</id>
    <revision>
      <id>436371</id>
      <parentid>436360</parentid>
      <timestamp>2026-10-13T12:39:46Z</timestamp>
      <contributor>
        <username>Antimundo</username>
        <id>74354</id>
      </contributor>
      <comment>Quitar libro de visitas tras consenso</comment>
      <origin>436371</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="714" sha1="7i0nfck98xswdckswqlocfb645u4ss5" xml:space="preserve">&lt;div style=&quot;display:flex;flex-wrap:wrap;margin-bottom: 1rem;align-items:center;&quot;&gt;
&lt;div style=&quot;flex:2 1 30rem;min-width:20rem;&quot;&gt;
&lt;span style=&quot;font-size:1.5rem;line-height:1.5;&quot;&gt;
Te damos la [[Wikilibros:Bienvenida|bienvenida]] a Wikilibros,
&lt;/span&gt;
&lt;br&gt;
la biblioteca colaborativa de contenido libre.
&lt;div class=&quot;plainlinks&quot; style=&quot;margin-top:0.75rem;font-size:0.875rem;&quot;&gt;
[[Wikilibros:Ayuda|Ayuda]] · [[Ayuda:Preguntas frecuentes|Preguntas frecuentes]] · [[Wikilibros:Café|Café comunitario]]
&lt;/div&gt;
&lt;/div&gt;
&lt;div style=&quot;flex:1 1 20rem;text-align:right;font-size:0.95rem;&quot;&gt;
[[Wikilibros:Estadísticas|'''{{NUMBEROFARTICLES}}''' páginas]] en español,
&lt;br&gt;
en más de '''{{NUMBEROFBOOKS}}''' libros.
&lt;/div&gt;
&lt;/div&gt;</text>
      <sha1>7i0nfck98xswdckswqlocfb645u4ss5</sha1>
    </revision>
  </page>
  <page>
    <title>Wikilibros:Libro de visitas</title>
    <ns>4</ns>
    <id>17966</id>
    <revision>
      <id>436369</id>
      <parentid>427198</parentid>
      <timestamp>2026-10-13T12:34:15Z</timestamp>
      <contributor>
        <username>Antimundo</username>
        <id>74354</id>
      </contributor>
      <comment>Consenso en discusión</comment>
      <origin>436369</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5688" sha1="01kbnvy0to5hyjt2od2e9uts6ilxuio" xml:space="preserve">{{Museo}}
{| width=&quot;100%&quot; cellspacing=&quot;0&quot; cellpadding=&quot;0&quot; style=&quot;border:1px solid var(--border-color-progressive, #36c); color: var(--color-base); background:var(--background-color-progressive-subtle, #e8eeff); border-radius: 2px;&quot;
|-
| colspan=&quot;2&quot; style=&quot;color:var(--color-inverted, #fff); background:var(--border-color-progressive, #36c); padding:12px 15px;font-size: 120%;&quot; | [[Archivo:Gartoon mimetypes txt2.svg|36px|sinmarco]] '''¡Te damos la bienvenida al libro de visitas de Wikilibros en español!'''
|-
| style=&quot;padding:1em;&quot; |
'''&lt;span class=&quot;plainlinks&quot;&gt;[http://es.wikibooks.org/w/wiki.phtml?title=Wikibooks:Libro_de_visitas&amp;action=edit&amp;section=new Pulsa aquí]&lt;/span&gt;''' para dejarnos tus impresiones sobre Wikilibros. ¡Los comentarios y sugerencias constructivos nos ayudan a mejorar!

Sé amable y respetuoso con los demás. Evita compartir información personal, spam, y cualquier contenido inapropiado.
|}
[[vi:Wikibooks:Guestbook for non-Vietnamese speakers]]

== ¡Simplemente....fantástico...! ==

He quedado sorprendido por el caudal de conocimiento al cual los seres humanos estamos

{{Nofirmado|186.144.162.155|23:40 14 ago 2011}}

== ¡Mas imágenes! ==

Creo que están muy bien sus libros pero se ve necesario poner mas imágenes para tener mas claro lo que se hace.

{{Nofirmado|190.53.229.124|21:45 20 ago 2011}}

== Biblioteca carente ==

La verdad les falta mucho material, los pocos libros que tienen carecen de interés, ojalá y puedan mejorar, gracias. Enrique Garrido. {{Nofirmado|200.66.106.34|09:49 21 oct 2011}}

Enrique te animamos a que completes aquellos puntos en los que crees que wikilibros puede mejorar. {{Nofirmado|88.0.243.127|15:59 21 ene 2012}}

== Felicitaciones ==
Wikilibros me ayudó mucho en lo que es el inglés. Felicito a los que hicieron de Wikipedia, Wikilibros. Muchas felicitaciones.

Atte. Maria C. Salamanca {{Nofirmado|190.110.152.229|00:38 13 ene 2012}}

== Comentario del 2012 ==

Pero.., ¿de verdad es lo que parece? No me lo puedo creer..., me parece que es demasiado bueno para ser verdad esto de WIKILIBROS. MUCHÍSIMAS GRACIAS Y MUCHA SUERTE A TODOS.

jose luis alvarez {{Nofirmado|88.151.16.21|18:21 8 feb 2012}}

== Música popular ==

Me encanta que se pueda editar las páginas para colaborar con wikilibros como lo hice ahora.

{{Nofirmado|186.60.26.119|21:54 9 may 2012}}

== Me agrada Wikilibros ==

Muy interesante este proyecto de wikilibros, porque permite al usuario obtener información inmediata y libre. Felicitaciones. 

María Mercedes González Brand Julio 25/2012 --[[Especial:Contribuciones/181.129.254.200|181.129.254.200]] 02:12 26 jul 2012 (UTC)

== ¿Y la literatura? ==

es muy interesante el compendio de libros que tiene wikilibros pero creo que le falta agregar obras literarias. no sé si eso sea posible pero si lo es quisiera que los agreguen. gracias 
(nancy guzmán) {{Nofirmado|190.236.19.165|01:15 24 ene 2013}}
:Hola gracias por compartir tu opinión, pero Wikilibros no puede admitir obras literarias ya que su contenido se limita a libros de carácter pedagógico, ya sean manuales, guías o similares. Si buscas obras literarias ya existentes tienes a tu disposición el proyecto [[Manual wiki/Los proyectos Wikimedia/Wikisource|Wikisource]]. Si te refieres a la creación de obras literarias de forma colaborativa me temo que ningún proyecto de Wikimedia tiene esa función. Un saludo, --[[Usuario:Morza|Morza]] ([[Usuario Discusión:Morza|sono qui]]) 17:44 29 ene 2013 (UTC)

== Temas de la Geociencia ==

Sería muy útil la creación de libros relativo a la Geociencia

{{Nofirmado|Juananto~eswikibooks|21:00 28 feb 2013}}

== ePub y odt ==
	
Por favor, incluyan la extensión de descarga en odt como Wikipedia y, además, ePub. 

La difusión será más alta.

Gracias.

{{Nofirmado|188.85.112.29|08:44 9 ago 2013}}

== ¿Qué es esto? ==

De verdad que puedes encontrar cosas muy interesantes, y gracias a eso aprendí Coreano,...Pero...POR POCO ME VUELVO LOCA BUSCANDO UN LIBRO DE DISEÑO de modas!!!!, aunque sea alguno de confecciones.¿NO PODRÍAN COMPLACERME AMPLIANDO UN POCO TEMAS COMO ESTOS?(Diseño, dibujo, etc).
Espero que me complazcan, Lo estoy esperando. Hae Na Kang {{Nofirmado|201.220.215.14|18:29 17 ene 2014}}

== Genial la cantidad de informacion brindada a profesores y alumnos! ==

Hola desde Cuba! Pues muy bueno esta gran cantidad de informacion compartida para el mundo entero, gracias a la colaboracion de todos. Es uno de los pocos portales a los que puedo acceder desde aca, y en hora buena que llegue a todas partes del mundo.
Felicidades por su concepcion de compartir la informacion entre todos, en la unidad esta la fuerza!

{{Nofirmado|Vampgoth|02:54 28 may 2014}}

== Hola ==

Wikilibros es estupenda porque aqui se encuentra todo el conocimiento necesario para un estudiante--[[Especial:Contribuciones/201.220.215.14|201.220.215.14]] 21:38 8 oct 2014 (UTC)

== Seguimos. ==

Felicitaciones por el avance contínuo de los aportes abiertos !!!.

{{Nofirmado|Guillspa|01:15 2 nov 2014}}

== El conocimiento ==

De gran manera, podemos acercarnos al conocimiento por medio de esta base de datos. Gracias! [[Especial:Contribuciones/2806:104E:13:1993:3184:B3B:7CB0:7A35|2806:104E:13:1993:3184:B3B:7CB0:7A35]] 13:32 21 sep 2023 (UTC)

== Ediciones  ==

me encanta que se pueda editar las páginas para colaborar con el proyecto y desarrollar el wikilibro que se está editando gracias [[Especial:Contribuciones/2803:33C0:7507:A014:4C7B:6EAE:3C1:9310|2803:33C0:7507:A014:4C7B:6EAE:3C1:9310]] 17:41 8 oct 2023 (UTC)

== Muy interesante ==

Muy choro
Muy bueno [[Especial:Contribuciones/190.215.245.184|190.215.245.184]] 21:32 14 dic 2023 (UTC)</text>
      <sha1>01kbnvy0to5hyjt2od2e9uts6ilxuio</sha1>
    </revision>
    <revision>
      <id>436370</id>
      <parentid>436369</parentid>
      <timestamp>2026-10-13T12:34:27Z</timestamp>
      <contributor>
        <username>Antimundo</username>
        <id>74354</id>
      </contributor>
      <minor />
      <origin>436370</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5689" sha1="h7gyh46kiexoamfkrcdtif4qqh58o3n" xml:space="preserve">{{Museo}}

{| width=&quot;100%&quot; cellspacing=&quot;0&quot; cellpadding=&quot;0&quot; style=&quot;border:1px solid var(--border-color-progressive, #36c); color: var(--color-base); background:var(--background-color-progressive-subtle, #e8eeff); border-radius: 2px;&quot;
|-
| colspan=&quot;2&quot; style=&quot;color:var(--color-inverted, #fff); background:var(--border-color-progressive, #36c); padding:12px 15px;font-size: 120%;&quot; | [[Archivo:Gartoon mimetypes txt2.svg|36px|sinmarco]] '''¡Te damos la bienvenida al libro de visitas de Wikilibros en español!'''
|-
| style=&quot;padding:1em;&quot; |
'''&lt;span class=&quot;plainlinks&quot;&gt;[http://es.wikibooks.org/w/wiki.phtml?title=Wikibooks:Libro_de_visitas&amp;action=edit&amp;section=new Pulsa aquí]&lt;/span&gt;''' para dejarnos tus impresiones sobre Wikilibros. ¡Los comentarios y sugerencias constructivos nos ayudan a mejorar!

Sé amable y respetuoso con los demás. Evita compartir información personal, spam, y cualquier contenido inapropiado.
|}
[[vi:Wikibooks:Guestbook for non-Vietnamese speakers]]

== ¡Simplemente....fantástico...! ==

He quedado sorprendido por el caudal de conocimiento al cual los seres humanos estamos

{{Nofirmado|186.144.162.155|23:40 14 ago 2011}}

== ¡Mas imágenes! ==

Creo que están muy bien sus libros pero se ve necesario poner mas imágenes para tener mas claro lo que se hace.

{{Nofirmado|190.53.229.124|21:45 20 ago 2011}}

== Biblioteca carente ==

La verdad les falta mucho material, los pocos libros que tienen carecen de interés, ojalá y puedan mejorar, gracias. Enrique Garrido. {{Nofirmado|200.66.106.34|09:49 21 oct 2011}}

Enrique te animamos a que completes aquellos puntos en los que crees que wikilibros puede mejorar. {{Nofirmado|88.0.243.127|15:59 21 ene 2012}}

== Felicitaciones ==
Wikilibros me ayudó mucho en lo que es el inglés. Felicito a los que hicieron de Wikipedia, Wikilibros. Muchas felicitaciones.

Atte. Maria C. Salamanca {{Nofirmado|190.110.152.229|00:38 13 ene 2012}}

== Comentario del 2012 ==

Pero.., ¿de verdad es lo que parece? No me lo puedo creer..., me parece que es demasiado bueno para ser verdad esto de WIKILIBROS. MUCHÍSIMAS GRACIAS Y MUCHA SUERTE A TODOS.

jose luis alvarez {{Nofirmado|88.151.16.21|18:21 8 feb 2012}}

== Música popular ==

Me encanta que se pueda editar las páginas para colaborar con wikilibros como lo hice ahora.

{{Nofirmado|186.60.26.119|21:54 9 may 2012}}

== Me agrada Wikilibros ==

Muy interesante este proyecto de wikilibros, porque permite al usuario obtener información inmediata y libre. Felicitaciones. 

María Mercedes González Brand Julio 25/2012 --[[Especial:Contribuciones/181.129.254.200|181.129.254.200]] 02:12 26 jul 2012 (UTC)

== ¿Y la literatura? ==

es muy interesante el compendio de libros que tiene wikilibros pero creo que le falta agregar obras literarias. no sé si eso sea posible pero si lo es quisiera que los agreguen. gracias 
(nancy guzmán) {{Nofirmado|190.236.19.165|01:15 24 ene 2013}}
:Hola gracias por compartir tu opinión, pero Wikilibros no puede admitir obras literarias ya que su contenido se limita a libros de carácter pedagógico, ya sean manuales, guías o similares. Si buscas obras literarias ya existentes tienes a tu disposición el proyecto [[Manual wiki/Los proyectos Wikimedia/Wikisource|Wikisource]]. Si te refieres a la creación de obras literarias de forma colaborativa me temo que ningún proyecto de Wikimedia tiene esa función. Un saludo, --[[Usuario:Morza|Morza]] ([[Usuario Discusión:Morza|sono qui]]) 17:44 29 ene 2013 (UTC)

== Temas de la Geociencia ==

Sería muy útil la creación de libros relativo a la Geociencia

{{Nofirmado|Juananto~eswikibooks|21:00 28 feb 2013}}

== ePub y odt ==
	
Por favor, incluyan la extensión de descarga en odt como Wikipedia y, además, ePub. 

La difusión será más alta.

Gracias.

{{Nofirmado|188.85.112.29|08:44 9 ago 2013}}

== ¿Qué es esto? ==

De verdad que puedes encontrar cosas muy interesantes, y gracias a eso aprendí Coreano,...Pero...POR POCO ME VUELVO LOCA BUSCANDO UN LIBRO DE DISEÑO de modas!!!!, aunque sea alguno de confecciones.¿NO PODRÍAN COMPLACERME AMPLIANDO UN POCO TEMAS COMO ESTOS?(Diseño, dibujo, etc).
Espero que me complazcan, Lo estoy esperando. Hae Na Kang {{Nofirmado|201.220.215.14|18:29 17 ene 2014}}

== Genial la cantidad de informacion brindada a profesores y alumnos! ==

Hola desde Cuba! Pues muy bueno esta gran cantidad de informacion compartida para el mundo entero, gracias a la colaboracion de todos. Es uno de los pocos portales a los que puedo acceder desde aca, y en hora buena que llegue a todas partes del mundo.
Felicidades por su concepcion de compartir la informacion entre todos, en la unidad esta la fuerza!

{{Nofirmado|Vampgoth|02:54 28 may 2014}}

== Hola ==

Wikilibros es estupenda porque aqui se encuentra todo el conocimiento necesario para un estudiante--[[Especial:Contribuciones/201.220.215.14|201.220.215.14]] 21:38 8 oct 2014 (UTC)

== Seguimos. ==

Felicitaciones por el avance contínuo de los aportes abiertos !!!.

{{Nofirmado|Guillspa|01:15 2 nov 2014}}

== El conocimiento ==

De gran manera, podemos acercarnos al conocimiento por medio de esta base de datos. Gracias! [[Especial:Contribuciones/2806:104E:13:1993:3184:B3B:7CB0:7A35|2806:104E:13:1993:3184:B3B:7CB0:7A35]] 13:32 21 sep 2023 (UTC)

== Ediciones  ==

me encanta que se pueda editar las páginas para colaborar con el proyecto y desarrollar el wikilibro que se está editando gracias [[Especial:Contribuciones/2803:33C0:7507:A014:4C7B:6EAE:3C1:9310|2803:33C0:7507:A014:4C7B:6EAE:3C1:9310]] 17:41 8 oct 2023 (UTC)

== Muy interesante ==

Muy choro
Muy bueno [[Especial:Contribuciones/190.215.245.184|190.215.245.184]] 21:32 14 dic 2023 (UTC)</text>
      <sha1>h7gyh46kiexoamfkrcdtif4qqh58o3n</sha1>
    </revision>
  </page>
  <page>
    <title>Wikilibros discusión:Libro de visitas</title>
    <ns>5</ns>
    <id>18872</id>
    <revision>
      <id>436372</id>
      <parentid>436368</parentid>
      <timestamp>2026-10-13T12:45:59Z</timestamp>
      <contributor>
        <username>Antimundo</username>
        <id>74354</id>
      </contributor>
      <comment>/* Consenso para archivado de esta página */ Respuesta</comment>
      <origin>436372</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5015" sha1="fuwqnp5yx5ifj2kn44c6sgsglhg368u" xml:space="preserve">== Formato ==
Me he tomado la libertad de realizarle unas pequeñas modificaciones en el formato en pro.

[[Usuario:Oleinad|Oleinad]] 08:52 30 ene 2008 (UTC)

----

Este podria ser un proyecto a destacar y en la que todos los amigos del mundo lo hagan posible. ¿Que es lo mas grande de su tierra?

Hasta lo luego. --[[Especial:Contributions/190.53.81.59|190.53.81.59]] 02:34 2 mar 2008 (UTC)

----

He firmado y limpiado la página. También me he permitido cambiar un poquito el estilo de la caja de bienvenida e introducción (centrado, rayas, correcciones menores, etc.). Espero que quede así a gusto de todos. — [[Usuario:Ketamino|Ketamino]] 14:29 22 may 2009 (UTC)
==Discutiendo el formato de bienvenida==
*Sobre el ''Centrado'': tienes razón en cuanto a la resolución.
*Las ''rayas'', gramaticalmente no es necesario para nada.
*Las ''mayúsculas'', solo en palabras propias, para lo demás existen símbolos ortográficos. -- Saludos, [[Usuario:Oleinad|Ole&lt;b&gt;i&lt;/b&gt;nad]] &lt;sup style=&quot;color=#33f933&quot;&gt;(opina [[Usuario_Discusión:Oleinad|aquí]])&lt;/sup&gt; 21:11 25 may 2009 (UTC)

:Ok, de acuerdo contigo, pero las rayas no son signos gramaticales, son tipográficos. Sirven para diferenciar mínimamente esa frase referente al (futuro) archivo e igualar la longitud de la línea respecto a la inmediatamente anterior. Con un poco de buena voluntad, si me la respetas, ni «para ti ni para mi», sino para los dos ;). Saludos. --[[Usuario:Ketamino|Ketamino]] 01:15 26 may 2009 (UTC)
::Estas de acuerdo en que se centra el contenido del cuadro para que resalte respecto al demás texto, por lo que '''esta centrado el contenido primordial que no interesa que los usuarios lean'''. En la linea en donde colocas las rayas no es primordial por lo no debe estar centrado, por lo tanto no es necesario ningún otro símbolo. -- Saludos, [[Usuario:Oleinad|Ole&lt;b&gt;i&lt;/b&gt;nad]] &lt;sup style=&quot;color=#33f933&quot;&gt;(opina [[Usuario_Discusión:Oleinad|aquí]])&lt;/sup&gt; 18:17 26 may 2009 (UTC)
:::El centrado no es «para que resalte», es porque tipográficamente es un horror eso a la izquierda, respecto al título de la caja, que sí aceptas centrado. Soy editor, sé de lo que hablo, respétalo. PD. Por cierto, «discucion» es discusión. Cuida también la sintaxis, no se entiende tu argumentación. --[[Usuario:Ketamino|Ketamino]] 01:42 27 may 2009 (UTC)

== felicitaciones==

muy buena la página. {{Nofirmado|200.72.40.99|14:31 17 feb 2011}}

== Consenso para archivado de esta página ==
Esta página está enlazada en la portada de Wikilibros desde hace prácticamente 20 años. El objetivo de esta página es solicitar «comentarios y sugerencias», sin embargo en todos estos años tan solo se han hecho 17 comentarios y la página (antes de que yo la arreglase en junio de este año) estaba en un estado de abandono evidente, llena de ediciones sin sentido, comentarios sin firmar, etc.

Me gustaría archivar esta página, y retirar su enlace de la portada, para que si alguien tiene un «comentario o sugerencia» se haga en el Café o en la página de discusión correspondiente a ese comentario. No veo que ni otras wikis en español, ni las ediciones de Wikibooks en otros idiomas, incluyan esta clase «libro de visitas», y personalmente no le encuentro ninguna utilidad. Los comentarios que ahí aparecen no son particularmente útiles y además hay una cantidad extremadamente baja de ellos para la cantidad de años que esta página ha estado listada en la portada.

Insisto en que no solicito su borrado. Solicito el colocar la plantilla {{ep|Museo}} y retirarla de la portada por los motivos mencionados anteriormente.

Menciono a @[[Usuario:Mazbel|Mazbel]] para escuchar su opinión. Saludos. [[Usuario:Antimundo|Antimundo]] ([[Usuario discusión:Antimundo|discusión]]) 10:00 13 oct 2026 (UTC)
: Por lo general, cuando uno presenta un comentario o sugerencia sobre alguna página, puede hacerla directamente en el Café, por tanto, no hay problema en quitar el enlace de esta página en la portada y dejar esta misma, con la plantilla {{tl|museo}}. Sería bueno, eso sí, que en la portada, se mencione que, en caso de «comentario o sugerencia», el usuario pueda hacerlo en la página correspondiente (café). Saludos! [[Usuario:Mazbel|&lt;span style=&quot;font-weight:bold; font-family:cursive, serif;&quot;&gt;Mazbel&lt;/span&gt;]] [[Usuario discusión:Mazbel|&lt;span style=&quot;font-size:small; font-family:cursive, serif;&quot;&gt;(Discusión)&lt;/span&gt;]] 11:26 13 oct 2026 (UTC)
::Estoy intentando «actualizar» un poco la portada, tomando como referencia el diseño de esWikipedia. De momento, he cambiado el enlace a «Café comunitario» para dar algo de contexto a quienes no sepan qué es el Café. Creo que añadir explicaciones sobre cada apartado en la portada generaría demasiado texto y podría hacerla un poco abrumadora. Si lo ves bien, prefiero mantener un diseño más sencillo para el encabezado como el de esWikipedia. [[Usuario:Antimundo|Antimundo]] ([[Usuario discusión:Antimundo|discusión]]) 12:45 13 oct 2026 (UTC)</text>
      <sha1>fuwqnp5yx5ifj2kn44c6sgsglhg368u</sha1>
    </revision>
  </page>
  <page>
    <title>Temario Oposición Profesor FP Informática/Tema 02. Elementos funcionales de un ordenador digital. Arquitectura.</title>
    <ns>0</ns>
    <id>27685</id>
    <revision>
      <id>436395</id>
      <parentid>396972</parentid>
      <timestamp>2026-10-13T20:08:08Z</timestamp>
      <contributor>
        <username>~2026-55042-54</username>
        <id>128009</id>
      </contributor>
      <comment>/* Unidad Aritmético-lógica (ALU) */</comment>
      <origin>436395</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="10971" sha1="j6x4lb8j9lglzx4zb38q8dlbzxjjbn0" xml:space="preserve">=Estructura básica de un ordenador=

Históricamente los ordenadores eran computadores con un programa fijado pero en la actualidad los ordenadores siguen un modelo basado en programas de almacenamiento, de esta manera se tienen:

*'''Computadora de programa fijado (Fixed Program Computer)''': Actualmente algunas máquinas todavía utilizan este módelo, las calculadoras, por ejemplo.
*'''Computadora de programa almacenado (Stored Program Computer)''': En estas máquinas existe una memoria que sirve para almacenar programas por lo que son reprogramables sin necesidad de rediseñarlas por completo.

Éste último modelo también es conocido como [[:m:w:en:Von_Neumann_architecture|Arquitectura Von Neumann]].

'''Arquitectura John Von Neummann'''
Fue diseñada en 1946 por el matemático [[:m:w:en:John_von_Neumann|John Von Neumann]] y es un modelo que utiliza la memoria tanto para almacenar instrucciones como datos. Estos computadores implementan [[:m:w:es:M%C3%A1quina_de_Turing#M.C3.A1quina_Universal_de_Turing|la máquina Universal de Turing]] ya que permiten crear aplicaciones capaces de interpretar otras aplicaciones.

La idea de esta arquitectura es la de conectar de forma fija y coordinar el funcionamiento de los componentes de un ordenador con una unidad central de proceso (CPU). La CPU dispone de un conjunto de instrucciones que permiten manejar la máquina y además estas instrucciones se pueden almacenar en la memoria del sistema como el resto de datos.

==Componentes de un ordenador. Modelo de máquina sencilla de Von Neumman==

Una máquina [[:m:w:en:Von_Neumann_architecture|Von Neumman]] está compuesta por cuatro partes:

===Unidad de Control (UC)=== 

Es la unidad que se encarga de leer las instrucciones secuencialmente. Las instrucciones las obtiene de la memoria principal.

===Unidad Aritmético-lógica (ALU)===

Realiza las operaciones matemáticas fundamentales (suma, resta, AND, OR, etc.). Es conocida como ALU (UAL en español).

===Memoria principal===

Es donde se almacenan los datos mediante celdas identificadas por direcciones

===Unidad de control de entrada/salida===

Es la encargada de conectar la máquina con el exterior. Permite la transferencia de datos desde la máquina a los periféricos.

[[Imatge:Adcfig2.gif]]

La comunicación entre los diferentes componentes se realiza usando '''buses o canales'''. Los buses son los caminos físicos a través de los cuales las instrucciones y los datos circulan entre los diferentes componentes de la máquina.

==Funcionamiento==

Veamos un ejemplo de como se ejecuta un programa en un ordenador actual. El siguiente gráfico nos muestra como es el proceso:

Supongamos un programa al que llamaramos '''holaMundo.sh''' y que una vez ejecutado nos saludara con la frase &quot;¡Hola mundo!&quot;. Según el gráfico el primer paso del proceso de ejecución del programa es utilizar un dispositivo de entrada. En este caso utilizaremos el teclado y mediante una terminal de linea de comandos ejecutaremos:

 $ holaMundo.sh

Conviene destacar que no siempre será un dispositivo de entrada el que iniciara el programa ya que los programas pueden ser iniciados por otros programas.

Con esta orden le indicamos a la computadora que debe ejecutar un programa llamado holaMundo.sh y que deberá buscar las instrucciones de las que se compone el programa en la memoria. La CPU irá leyendo las instrucciones de la memoria de forma secuencial y una vez que tenga un resultado lo mostrará por algún dispositivo de salida. (por ejemplo, la pantalla).

 '''NOTA''': Se han obviado los pasos de interpretación del lenguaje de programación y otros aspectos.

=La unidad central de proceso (CPU)=

Para mas detalle consultar el tema 3:

Los computadores actuales tienen un componente que se llama la unidad dcentral de procesamiento.(conocida por el término inglés [[:m:w:en:CPU|Central processing unit]] o CPU). La CPU esta compuesta por los siguientes componentes:

La unidad aritmético-lógica (ALU): Es la encargada de realizar las operaciones básicas
La Unidad de Control: Es la encargada de coordinar y gestionar el resto de elementos de la CPU.
Registros: Son elementos de memoria que contienen información relativa al programa que se está ejecutando.

La forma, diseño e implementación de las CPU ha cambiado mucho durante la evolución de la informática pero su funcionamiento continúa siendo el mismo desde su definición funcional en la arquitectura de Von Neumman.

==Lenguaje máquina==

Las CPU ejecutan programas que leen de la memória principal. Pero estos programas no son escritos en lenguajes de alto nivel sino que son interpretados por la máquina utilizando un lenguaje muy restringido y de bajo nivel llamado lenguaje máquina. Este lenguaje es muy sencillo y se limita a un conjunto de instrucciones muy limitado que comunmente se llama juego de instrucciones del computador.

Cada CPU tiene su conjunto de instrucciones propio. Las CPU pueden ser de propósito general o estar diseñadas para un proposito concreto y por tanto tener un conjunto de instrucciones muy diferentes. De cualquier manera suelen cumplir los siguientes requisitos:

*Realizan una única y sencilla operación.
*Utilizan un número fijo de operandos y con una representación numérica fija.
*La codificación de las instrucciones es lo más simple y sitemática posible de tal forma que el interprete del lenguaje máquina pueda ser también sencillo.
*Las instrucciones son independientes y autocontenidas. Contienen todos los datos necesarios para ejecutarse y no dependen de otras instrucciones.

Y las podemos clasificar en::

*'''Instrucciones de transferencia de datos''': Leen o escriben datos de una memoria.
*'''Instrucciones aritméticas''': Realizan operaciones aritméticas utilizando la ALU.
*'''Instrucciones lógicas''': Realizan operaciones lógicas utilizando la ALU.
*'''Instrucciones de desplazamiento''': Realizan operaciones de desplazamiento.
*'''Instrucciones de transferencia de control''': Actualizan el registro PC de la CPU administrando el flujo de ejecución del programa (llamadas a subrutinas).
*'''Instrucciones I/O''': Administran los comandos de entrada salida.

Las instrucciones tienen un  '''formato rígido''' definido por el conjunto de instrucciones del sistema. Una instrucción tiene dos partes:
*'''Código de la operación''': es descodificado por la unidad de control
*'''Operandos''': Los datos sobre los cuales se ejecutará una operación. Hay operaciones que no tienen datos, operaciones unarias y operaciones binarias.
*Todas las instrucciones son '''imperativas'''

La arquitectura mas utilizada en PC de sobremesa es la [[:m:w:en:X86-16|x86]] de Intel y compatibles (com por ejemplo las CPU de AMD).  Esta arquitectura apareció en 1978 con intel y ha ido evolucionando Intel 286, Intel 386, Pentium,Pentium 2, Pentium 3, Itanium hasta los actuales Pentium 4.

Se han desarrollado y se continúan desarollando extensiones del lenguaje máquina. Un par de ejemplos son:

*[[:m:w:en:MMX_%28instruction_set%29|MMX d'Intel]]
*[[:m:w:en:3DNow%21|3DNow]]

Conviene destacar que nosrmalmente es difícil encontrar software y sistemas operativos que soporten las nuevas instrucciones.

'''Propiedades''':
*Las instrucciones son independientes y autocontenidas. Contienen todos los datos necesarios para ejecutarse y no dependen de otras instrucciones.
*Instrucciones sistemáticas (facilita su decodificación). El decodificador ha de ser sencillo (no puede ser tan complicado como un compilador de un lenguaje de alto nivel).
*Es el único lenguaje que entiende la máquina.
*Utiliza código binario, octal o hexadecimal.
*Fueron los '''primeros lenguajes de programación'''
*Cada máquina (CPU) tiene su propio lenguaje y conjunto de instrucciones. Poco portable. Es necesario conocer el conjunto de instrucciones de la máquina para poder programarla.Diferentes arquitecturas.
*Actualmente se utilizan mucho más los lenguajes de alto nivel(mas faciles de aprender y utilizar por que son más cercanos al lenguaje natural)
**La unidad de controlo utilizando el descodificador es la encargada de convertir las instrucciones en código interpretable por la CPU.
*Los datos utilizados son referenciados por su posición en la memória. Es responsabilidad del programador controlar el mapa de memoria y la asignación de memoria a cada dato.
*Las instrucciones tiene un formato rígido definido por el conjunto de instrucciones del sistema. Una instrucción tiene dos partes:
**Código de la operación: Es descodificado por la unidad de control
**Operandos
*Todas las instrucciones son '''imperativas'''
*No se pueden utilizar comentarios

==La unidad aritmético-lógica (ALU)==

Las  ALU son las encargadas de realizar las operaciones aritmético-lógicas que le proporciona la unidad de control. Las operaciones son muy sencillas hasta el punto de que muchos procesadores disponen de un simple sumador/restador y el resto de operaciones se realizan mediante la descomposición en operaciones sencillas de otras más complejas.

Las ALU tiene el siguiente esquema:

[[file:ALU_symbol.svg|200px|thumb]]

La forma de V se utiliza tipicamente para representarla donde los extremos de la v son los operandos y el vértice el resultado. La comunicación entre la CPU y la ALU se realiza mediante los siguientes registros:

*'''A y B''': Son los registros que contienen los operandos. Tambien se llaman '''Registros de entrada'''.
*'''R''': Es el registro que contiene el resultado. Los registros A, B y R normalmente se almacenan en un banco de registros.
*'''F''': Es el registro que indica que '''tipo de operación''' se realiza sobre los operandos A y B.
*'''D''': Es el '''registro de estado del resultado'''. También conocido como '''registro de estado''' (Status Register). Se utiliza para indicar estados especiales como '''bits de arrastre''', '''divisiones por cero''' o ''''desbordamientos/overflows'''.

Las operaciones que suelen hacer las ALU son:

*Operaciones aritméticas con números enteros (suma, resta y a veces multiplicaciones y divisiones).
*Operaciones lógicas binarías 
*Operaciones de desplazamiento de bits: Desplazamientos a derecha o izquierda de bits (equivaliendo a multiplicar o a dividir por 2). 

Estas operaciones se suelen realizar mediante circuitos electrónicos que pueden ser circuitos combinacionales o circuitos secuenciales según utilizan registros de memoria o no.

Los operandos normalmente se representan en complemento a dos (Ver complemento a 2 en el tema 10) y las operaciones son con números enteros. 

Las operaciones se pueden clasificar en:
*'''Operacions unarias''': Un solo operando (operación de negación)
*'''Operacions binaria''': 2 operadores (suma, resta, división, etc.)

Las operaciones pueden ser:
*'''Operador paralelo''': La operación se realiza con todos los bits del operador a la vez.
*'''Operador serie''': la operación se realiza dígito a dígito.</text>
      <sha1>j6x4lb8j9lglzx4zb38q8dlbzxjjbn0</sha1>
    </revision>
    <revision>
      <id>436396</id>
      <parentid>436395</parentid>
      <timestamp>2026-10-13T20:10:15Z</timestamp>
      <contributor>
        <username>~2026-55042-54</username>
        <id>128009</id>
      </contributor>
      <comment>/* La unidad central de proceso (CPU) */</comment>
      <origin>436396</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="10970" sha1="o45akjm2n4sk90dwax02vyh37phmat3" xml:space="preserve">=Estructura básica de un ordenador=

Históricamente los ordenadores eran computadores con un programa fijado pero en la actualidad los ordenadores siguen un modelo basado en programas de almacenamiento, de esta manera se tienen:

*'''Computadora de programa fijado (Fixed Program Computer)''': Actualmente algunas máquinas todavía utilizan este módelo, las calculadoras, por ejemplo.
*'''Computadora de programa almacenado (Stored Program Computer)''': En estas máquinas existe una memoria que sirve para almacenar programas por lo que son reprogramables sin necesidad de rediseñarlas por completo.

Éste último modelo también es conocido como [[:m:w:en:Von_Neumann_architecture|Arquitectura Von Neumann]].

'''Arquitectura John Von Neummann'''
Fue diseñada en 1946 por el matemático [[:m:w:en:John_von_Neumann|John Von Neumann]] y es un modelo que utiliza la memoria tanto para almacenar instrucciones como datos. Estos computadores implementan [[:m:w:es:M%C3%A1quina_de_Turing#M.C3.A1quina_Universal_de_Turing|la máquina Universal de Turing]] ya que permiten crear aplicaciones capaces de interpretar otras aplicaciones.

La idea de esta arquitectura es la de conectar de forma fija y coordinar el funcionamiento de los componentes de un ordenador con una unidad central de proceso (CPU). La CPU dispone de un conjunto de instrucciones que permiten manejar la máquina y además estas instrucciones se pueden almacenar en la memoria del sistema como el resto de datos.

==Componentes de un ordenador. Modelo de máquina sencilla de Von Neumman==

Una máquina [[:m:w:en:Von_Neumann_architecture|Von Neumman]] está compuesta por cuatro partes:

===Unidad de Control (UC)=== 

Es la unidad que se encarga de leer las instrucciones secuencialmente. Las instrucciones las obtiene de la memoria principal.

===Unidad Aritmético-lógica (ALU)===

Realiza las operaciones matemáticas fundamentales (suma, resta, AND, OR, etc.). Es conocida como ALU (UAL en español).

===Memoria principal===

Es donde se almacenan los datos mediante celdas identificadas por direcciones

===Unidad de control de entrada/salida===

Es la encargada de conectar la máquina con el exterior. Permite la transferencia de datos desde la máquina a los periféricos.

[[Imatge:Adcfig2.gif]]

La comunicación entre los diferentes componentes se realiza usando '''buses o canales'''. Los buses son los caminos físicos a través de los cuales las instrucciones y los datos circulan entre los diferentes componentes de la máquina.

==Funcionamiento==

Veamos un ejemplo de como se ejecuta un programa en un ordenador actual. El siguiente gráfico nos muestra como es el proceso:

Supongamos un programa al que llamaramos '''holaMundo.sh''' y que una vez ejecutado nos saludara con la frase &quot;¡Hola mundo!&quot;. Según el gráfico el primer paso del proceso de ejecución del programa es utilizar un dispositivo de entrada. En este caso utilizaremos el teclado y mediante una terminal de linea de comandos ejecutaremos:

 $ holaMundo.sh

Conviene destacar que no siempre será un dispositivo de entrada el que iniciara el programa ya que los programas pueden ser iniciados por otros programas.

Con esta orden le indicamos a la computadora que debe ejecutar un programa llamado holaMundo.sh y que deberá buscar las instrucciones de las que se compone el programa en la memoria. La CPU irá leyendo las instrucciones de la memoria de forma secuencial y una vez que tenga un resultado lo mostrará por algún dispositivo de salida. (por ejemplo, la pantalla).

 '''NOTA''': Se han obviado los pasos de interpretación del lenguaje de programación y otros aspectos.

=La unidad central de proceso (CPU)=

Para mas detalle consultar el tema 3:

Los computadores actuales tienen un componente que se llama la unidad central de procesamiento.(conocida por el término inglés [[:m:w:en:CPU|Central processing unit]] o CPU). La CPU esta compuesta por los siguientes componentes:

La unidad aritmético-lógica (ALU): Es la encargada de realizar las operaciones básicas
La Unidad de Control: Es la encargada de coordinar y gestionar el resto de elementos de la CPU.
Registros: Son elementos de memoria que contienen información relativa al programa que se está ejecutando.

La forma, diseño e implementación de las CPU ha cambiado mucho durante la evolución de la informática pero su funcionamiento continúa siendo el mismo desde su definición funcional en la arquitectura de Von Neumman.

==Lenguaje máquina==

Las CPU ejecutan programas que leen de la memória principal. Pero estos programas no son escritos en lenguajes de alto nivel sino que son interpretados por la máquina utilizando un lenguaje muy restringido y de bajo nivel llamado lenguaje máquina. Este lenguaje es muy sencillo y se limita a un conjunto de instrucciones muy limitado que comunmente se llama juego de instrucciones del computador.

Cada CPU tiene su conjunto de instrucciones propio. Las CPU pueden ser de propósito general o estar diseñadas para un proposito concreto y por tanto tener un conjunto de instrucciones muy diferentes. De cualquier manera suelen cumplir los siguientes requisitos:

*Realizan una única y sencilla operación.
*Utilizan un número fijo de operandos y con una representación numérica fija.
*La codificación de las instrucciones es lo más simple y sitemática posible de tal forma que el interprete del lenguaje máquina pueda ser también sencillo.
*Las instrucciones son independientes y autocontenidas. Contienen todos los datos necesarios para ejecutarse y no dependen de otras instrucciones.

Y las podemos clasificar en::

*'''Instrucciones de transferencia de datos''': Leen o escriben datos de una memoria.
*'''Instrucciones aritméticas''': Realizan operaciones aritméticas utilizando la ALU.
*'''Instrucciones lógicas''': Realizan operaciones lógicas utilizando la ALU.
*'''Instrucciones de desplazamiento''': Realizan operaciones de desplazamiento.
*'''Instrucciones de transferencia de control''': Actualizan el registro PC de la CPU administrando el flujo de ejecución del programa (llamadas a subrutinas).
*'''Instrucciones I/O''': Administran los comandos de entrada salida.

Las instrucciones tienen un  '''formato rígido''' definido por el conjunto de instrucciones del sistema. Una instrucción tiene dos partes:
*'''Código de la operación''': es descodificado por la unidad de control
*'''Operandos''': Los datos sobre los cuales se ejecutará una operación. Hay operaciones que no tienen datos, operaciones unarias y operaciones binarias.
*Todas las instrucciones son '''imperativas'''

La arquitectura mas utilizada en PC de sobremesa es la [[:m:w:en:X86-16|x86]] de Intel y compatibles (com por ejemplo las CPU de AMD).  Esta arquitectura apareció en 1978 con intel y ha ido evolucionando Intel 286, Intel 386, Pentium,Pentium 2, Pentium 3, Itanium hasta los actuales Pentium 4.

Se han desarrollado y se continúan desarollando extensiones del lenguaje máquina. Un par de ejemplos son:

*[[:m:w:en:MMX_%28instruction_set%29|MMX d'Intel]]
*[[:m:w:en:3DNow%21|3DNow]]

Conviene destacar que nosrmalmente es difícil encontrar software y sistemas operativos que soporten las nuevas instrucciones.

'''Propiedades''':
*Las instrucciones son independientes y autocontenidas. Contienen todos los datos necesarios para ejecutarse y no dependen de otras instrucciones.
*Instrucciones sistemáticas (facilita su decodificación). El decodificador ha de ser sencillo (no puede ser tan complicado como un compilador de un lenguaje de alto nivel).
*Es el único lenguaje que entiende la máquina.
*Utiliza código binario, octal o hexadecimal.
*Fueron los '''primeros lenguajes de programación'''
*Cada máquina (CPU) tiene su propio lenguaje y conjunto de instrucciones. Poco portable. Es necesario conocer el conjunto de instrucciones de la máquina para poder programarla.Diferentes arquitecturas.
*Actualmente se utilizan mucho más los lenguajes de alto nivel(mas faciles de aprender y utilizar por que son más cercanos al lenguaje natural)
**La unidad de controlo utilizando el descodificador es la encargada de convertir las instrucciones en código interpretable por la CPU.
*Los datos utilizados son referenciados por su posición en la memória. Es responsabilidad del programador controlar el mapa de memoria y la asignación de memoria a cada dato.
*Las instrucciones tiene un formato rígido definido por el conjunto de instrucciones del sistema. Una instrucción tiene dos partes:
**Código de la operación: Es descodificado por la unidad de control
**Operandos
*Todas las instrucciones son '''imperativas'''
*No se pueden utilizar comentarios

==La unidad aritmético-lógica (ALU)==

Las  ALU son las encargadas de realizar las operaciones aritmético-lógicas que le proporciona la unidad de control. Las operaciones son muy sencillas hasta el punto de que muchos procesadores disponen de un simple sumador/restador y el resto de operaciones se realizan mediante la descomposición en operaciones sencillas de otras más complejas.

Las ALU tiene el siguiente esquema:

[[file:ALU_symbol.svg|200px|thumb]]

La forma de V se utiliza tipicamente para representarla donde los extremos de la v son los operandos y el vértice el resultado. La comunicación entre la CPU y la ALU se realiza mediante los siguientes registros:

*'''A y B''': Son los registros que contienen los operandos. Tambien se llaman '''Registros de entrada'''.
*'''R''': Es el registro que contiene el resultado. Los registros A, B y R normalmente se almacenan en un banco de registros.
*'''F''': Es el registro que indica que '''tipo de operación''' se realiza sobre los operandos A y B.
*'''D''': Es el '''registro de estado del resultado'''. También conocido como '''registro de estado''' (Status Register). Se utiliza para indicar estados especiales como '''bits de arrastre''', '''divisiones por cero''' o ''''desbordamientos/overflows'''.

Las operaciones que suelen hacer las ALU son:

*Operaciones aritméticas con números enteros (suma, resta y a veces multiplicaciones y divisiones).
*Operaciones lógicas binarías 
*Operaciones de desplazamiento de bits: Desplazamientos a derecha o izquierda de bits (equivaliendo a multiplicar o a dividir por 2). 

Estas operaciones se suelen realizar mediante circuitos electrónicos que pueden ser circuitos combinacionales o circuitos secuenciales según utilizan registros de memoria o no.

Los operandos normalmente se representan en complemento a dos (Ver complemento a 2 en el tema 10) y las operaciones son con números enteros. 

Las operaciones se pueden clasificar en:
*'''Operacions unarias''': Un solo operando (operación de negación)
*'''Operacions binaria''': 2 operadores (suma, resta, división, etc.)

Las operaciones pueden ser:
*'''Operador paralelo''': La operación se realiza con todos los bits del operador a la vez.
*'''Operador serie''': la operación se realiza dígito a dígito.</text>
      <sha1>o45akjm2n4sk90dwax02vyh37phmat3</sha1>
    </revision>
    <revision>
      <id>436397</id>
      <parentid>436396</parentid>
      <timestamp>2026-10-13T20:11:22Z</timestamp>
      <contributor>
        <username>~2026-55042-54</username>
        <id>128009</id>
      </contributor>
      <comment>/* Lenguaje máquina */</comment>
      <origin>436397</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="10969" sha1="qzhq8qqhek284nfmzzcs3m1fbsftuz2" xml:space="preserve">=Estructura básica de un ordenador=

Históricamente los ordenadores eran computadores con un programa fijado pero en la actualidad los ordenadores siguen un modelo basado en programas de almacenamiento, de esta manera se tienen:

*'''Computadora de programa fijado (Fixed Program Computer)''': Actualmente algunas máquinas todavía utilizan este módelo, las calculadoras, por ejemplo.
*'''Computadora de programa almacenado (Stored Program Computer)''': En estas máquinas existe una memoria que sirve para almacenar programas por lo que son reprogramables sin necesidad de rediseñarlas por completo.

Éste último modelo también es conocido como [[:m:w:en:Von_Neumann_architecture|Arquitectura Von Neumann]].

'''Arquitectura John Von Neummann'''
Fue diseñada en 1946 por el matemático [[:m:w:en:John_von_Neumann|John Von Neumann]] y es un modelo que utiliza la memoria tanto para almacenar instrucciones como datos. Estos computadores implementan [[:m:w:es:M%C3%A1quina_de_Turing#M.C3.A1quina_Universal_de_Turing|la máquina Universal de Turing]] ya que permiten crear aplicaciones capaces de interpretar otras aplicaciones.

La idea de esta arquitectura es la de conectar de forma fija y coordinar el funcionamiento de los componentes de un ordenador con una unidad central de proceso (CPU). La CPU dispone de un conjunto de instrucciones que permiten manejar la máquina y además estas instrucciones se pueden almacenar en la memoria del sistema como el resto de datos.

==Componentes de un ordenador. Modelo de máquina sencilla de Von Neumman==

Una máquina [[:m:w:en:Von_Neumann_architecture|Von Neumman]] está compuesta por cuatro partes:

===Unidad de Control (UC)=== 

Es la unidad que se encarga de leer las instrucciones secuencialmente. Las instrucciones las obtiene de la memoria principal.

===Unidad Aritmético-lógica (ALU)===

Realiza las operaciones matemáticas fundamentales (suma, resta, AND, OR, etc.). Es conocida como ALU (UAL en español).

===Memoria principal===

Es donde se almacenan los datos mediante celdas identificadas por direcciones

===Unidad de control de entrada/salida===

Es la encargada de conectar la máquina con el exterior. Permite la transferencia de datos desde la máquina a los periféricos.

[[Imatge:Adcfig2.gif]]

La comunicación entre los diferentes componentes se realiza usando '''buses o canales'''. Los buses son los caminos físicos a través de los cuales las instrucciones y los datos circulan entre los diferentes componentes de la máquina.

==Funcionamiento==

Veamos un ejemplo de como se ejecuta un programa en un ordenador actual. El siguiente gráfico nos muestra como es el proceso:

Supongamos un programa al que llamaramos '''holaMundo.sh''' y que una vez ejecutado nos saludara con la frase &quot;¡Hola mundo!&quot;. Según el gráfico el primer paso del proceso de ejecución del programa es utilizar un dispositivo de entrada. En este caso utilizaremos el teclado y mediante una terminal de linea de comandos ejecutaremos:

 $ holaMundo.sh

Conviene destacar que no siempre será un dispositivo de entrada el que iniciara el programa ya que los programas pueden ser iniciados por otros programas.

Con esta orden le indicamos a la computadora que debe ejecutar un programa llamado holaMundo.sh y que deberá buscar las instrucciones de las que se compone el programa en la memoria. La CPU irá leyendo las instrucciones de la memoria de forma secuencial y una vez que tenga un resultado lo mostrará por algún dispositivo de salida. (por ejemplo, la pantalla).

 '''NOTA''': Se han obviado los pasos de interpretación del lenguaje de programación y otros aspectos.

=La unidad central de proceso (CPU)=

Para mas detalle consultar el tema 3:

Los computadores actuales tienen un componente que se llama la unidad central de procesamiento.(conocida por el término inglés [[:m:w:en:CPU|Central processing unit]] o CPU). La CPU esta compuesta por los siguientes componentes:

La unidad aritmético-lógica (ALU): Es la encargada de realizar las operaciones básicas
La Unidad de Control: Es la encargada de coordinar y gestionar el resto de elementos de la CPU.
Registros: Son elementos de memoria que contienen información relativa al programa que se está ejecutando.

La forma, diseño e implementación de las CPU ha cambiado mucho durante la evolución de la informática pero su funcionamiento continúa siendo el mismo desde su definición funcional en la arquitectura de Von Neumman.

==Lenguaje máquina==

Las CPU ejecutan programas que leen de la memoria principal. Pero estos programas no son escritos en lenguajes de alto nivel sino que son interpretados por la máquina utilizando un lenguaje muy restringido y de bajo nivel llamado lenguaje máquina. Este lenguaje es muy sencillo y se limita a un conjunto de instrucciones muy limitado que comunmente se llama juego de instrucciones del computador.

Cada CPU tiene su conjunto de instrucciones propio. Las CPU pueden ser de propósito general o estar diseñadas para un proposito concreto y por tanto tener un conjunto de instrucciones muy diferentes. De cualquier manera suelen cumplir los siguientes requisitos:

*Realizan una única y sencilla operación.
*Utilizan un número fijo de operandos y con una representación numérica fija.
*La codificación de las instrucciones es lo más simple y sitemática posible de tal forma que el interprete del lenguaje máquina pueda ser también sencillo.
*Las instrucciones son independientes y autocontenidas. Contienen todos los datos necesarios para ejecutarse y no dependen de otras instrucciones.

Y las podemos clasificar en::

*'''Instrucciones de transferencia de datos''': Leen o escriben datos de una memoria.
*'''Instrucciones aritméticas''': Realizan operaciones aritméticas utilizando la ALU.
*'''Instrucciones lógicas''': Realizan operaciones lógicas utilizando la ALU.
*'''Instrucciones de desplazamiento''': Realizan operaciones de desplazamiento.
*'''Instrucciones de transferencia de control''': Actualizan el registro PC de la CPU administrando el flujo de ejecución del programa (llamadas a subrutinas).
*'''Instrucciones I/O''': Administran los comandos de entrada salida.

Las instrucciones tienen un  '''formato rígido''' definido por el conjunto de instrucciones del sistema. Una instrucción tiene dos partes:
*'''Código de la operación''': es descodificado por la unidad de control
*'''Operandos''': Los datos sobre los cuales se ejecutará una operación. Hay operaciones que no tienen datos, operaciones unarias y operaciones binarias.
*Todas las instrucciones son '''imperativas'''

La arquitectura mas utilizada en PC de sobremesa es la [[:m:w:en:X86-16|x86]] de Intel y compatibles (com por ejemplo las CPU de AMD).  Esta arquitectura apareció en 1978 con intel y ha ido evolucionando Intel 286, Intel 386, Pentium,Pentium 2, Pentium 3, Itanium hasta los actuales Pentium 4.

Se han desarrollado y se continúan desarollando extensiones del lenguaje máquina. Un par de ejemplos son:

*[[:m:w:en:MMX_%28instruction_set%29|MMX d'Intel]]
*[[:m:w:en:3DNow%21|3DNow]]

Conviene destacar que nosrmalmente es difícil encontrar software y sistemas operativos que soporten las nuevas instrucciones.

'''Propiedades''':
*Las instrucciones son independientes y autocontenidas. Contienen todos los datos necesarios para ejecutarse y no dependen de otras instrucciones.
*Instrucciones sistemáticas (facilita su decodificación). El decodificador ha de ser sencillo (no puede ser tan complicado como un compilador de un lenguaje de alto nivel).
*Es el único lenguaje que entiende la máquina.
*Utiliza código binario, octal o hexadecimal.
*Fueron los '''primeros lenguajes de programación'''
*Cada máquina (CPU) tiene su propio lenguaje y conjunto de instrucciones. Poco portable. Es necesario conocer el conjunto de instrucciones de la máquina para poder programarla.Diferentes arquitecturas.
*Actualmente se utilizan mucho más los lenguajes de alto nivel(mas faciles de aprender y utilizar por que son más cercanos al lenguaje natural)
**La unidad de controlo utilizando el descodificador es la encargada de convertir las instrucciones en código interpretable por la CPU.
*Los datos utilizados son referenciados por su posición en la memória. Es responsabilidad del programador controlar el mapa de memoria y la asignación de memoria a cada dato.
*Las instrucciones tiene un formato rígido definido por el conjunto de instrucciones del sistema. Una instrucción tiene dos partes:
**Código de la operación: Es descodificado por la unidad de control
**Operandos
*Todas las instrucciones son '''imperativas'''
*No se pueden utilizar comentarios

==La unidad aritmético-lógica (ALU)==

Las  ALU son las encargadas de realizar las operaciones aritmético-lógicas que le proporciona la unidad de control. Las operaciones son muy sencillas hasta el punto de que muchos procesadores disponen de un simple sumador/restador y el resto de operaciones se realizan mediante la descomposición en operaciones sencillas de otras más complejas.

Las ALU tiene el siguiente esquema:

[[file:ALU_symbol.svg|200px|thumb]]

La forma de V se utiliza tipicamente para representarla donde los extremos de la v son los operandos y el vértice el resultado. La comunicación entre la CPU y la ALU se realiza mediante los siguientes registros:

*'''A y B''': Son los registros que contienen los operandos. Tambien se llaman '''Registros de entrada'''.
*'''R''': Es el registro que contiene el resultado. Los registros A, B y R normalmente se almacenan en un banco de registros.
*'''F''': Es el registro que indica que '''tipo de operación''' se realiza sobre los operandos A y B.
*'''D''': Es el '''registro de estado del resultado'''. También conocido como '''registro de estado''' (Status Register). Se utiliza para indicar estados especiales como '''bits de arrastre''', '''divisiones por cero''' o ''''desbordamientos/overflows'''.

Las operaciones que suelen hacer las ALU son:

*Operaciones aritméticas con números enteros (suma, resta y a veces multiplicaciones y divisiones).
*Operaciones lógicas binarías 
*Operaciones de desplazamiento de bits: Desplazamientos a derecha o izquierda de bits (equivaliendo a multiplicar o a dividir por 2). 

Estas operaciones se suelen realizar mediante circuitos electrónicos que pueden ser circuitos combinacionales o circuitos secuenciales según utilizan registros de memoria o no.

Los operandos normalmente se representan en complemento a dos (Ver complemento a 2 en el tema 10) y las operaciones son con números enteros. 

Las operaciones se pueden clasificar en:
*'''Operacions unarias''': Un solo operando (operación de negación)
*'''Operacions binaria''': 2 operadores (suma, resta, división, etc.)

Las operaciones pueden ser:
*'''Operador paralelo''': La operación se realiza con todos los bits del operador a la vez.
*'''Operador serie''': la operación se realiza dígito a dígito.</text>
      <sha1>qzhq8qqhek284nfmzzcs3m1fbsftuz2</sha1>
    </revision>
    <revision>
      <id>436398</id>
      <parentid>436397</parentid>
      <timestamp>2026-10-13T20:13:49Z</timestamp>
      <contributor>
        <username>~2026-55042-54</username>
        <id>128009</id>
      </contributor>
      <comment>/* Lenguaje máquina */</comment>
      <origin>436398</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="10968" sha1="aav0xldn2279dhhhvnj7gqfqaj69e7p" xml:space="preserve">=Estructura básica de un ordenador=

Históricamente los ordenadores eran computadores con un programa fijado pero en la actualidad los ordenadores siguen un modelo basado en programas de almacenamiento, de esta manera se tienen:

*'''Computadora de programa fijado (Fixed Program Computer)''': Actualmente algunas máquinas todavía utilizan este módelo, las calculadoras, por ejemplo.
*'''Computadora de programa almacenado (Stored Program Computer)''': En estas máquinas existe una memoria que sirve para almacenar programas por lo que son reprogramables sin necesidad de rediseñarlas por completo.

Éste último modelo también es conocido como [[:m:w:en:Von_Neumann_architecture|Arquitectura Von Neumann]].

'''Arquitectura John Von Neummann'''
Fue diseñada en 1946 por el matemático [[:m:w:en:John_von_Neumann|John Von Neumann]] y es un modelo que utiliza la memoria tanto para almacenar instrucciones como datos. Estos computadores implementan [[:m:w:es:M%C3%A1quina_de_Turing#M.C3.A1quina_Universal_de_Turing|la máquina Universal de Turing]] ya que permiten crear aplicaciones capaces de interpretar otras aplicaciones.

La idea de esta arquitectura es la de conectar de forma fija y coordinar el funcionamiento de los componentes de un ordenador con una unidad central de proceso (CPU). La CPU dispone de un conjunto de instrucciones que permiten manejar la máquina y además estas instrucciones se pueden almacenar en la memoria del sistema como el resto de datos.

==Componentes de un ordenador. Modelo de máquina sencilla de Von Neumman==

Una máquina [[:m:w:en:Von_Neumann_architecture|Von Neumman]] está compuesta por cuatro partes:

===Unidad de Control (UC)=== 

Es la unidad que se encarga de leer las instrucciones secuencialmente. Las instrucciones las obtiene de la memoria principal.

===Unidad Aritmético-lógica (ALU)===

Realiza las operaciones matemáticas fundamentales (suma, resta, AND, OR, etc.). Es conocida como ALU (UAL en español).

===Memoria principal===

Es donde se almacenan los datos mediante celdas identificadas por direcciones

===Unidad de control de entrada/salida===

Es la encargada de conectar la máquina con el exterior. Permite la transferencia de datos desde la máquina a los periféricos.

[[Imatge:Adcfig2.gif]]

La comunicación entre los diferentes componentes se realiza usando '''buses o canales'''. Los buses son los caminos físicos a través de los cuales las instrucciones y los datos circulan entre los diferentes componentes de la máquina.

==Funcionamiento==

Veamos un ejemplo de como se ejecuta un programa en un ordenador actual. El siguiente gráfico nos muestra como es el proceso:

Supongamos un programa al que llamaramos '''holaMundo.sh''' y que una vez ejecutado nos saludara con la frase &quot;¡Hola mundo!&quot;. Según el gráfico el primer paso del proceso de ejecución del programa es utilizar un dispositivo de entrada. En este caso utilizaremos el teclado y mediante una terminal de linea de comandos ejecutaremos:

 $ holaMundo.sh

Conviene destacar que no siempre será un dispositivo de entrada el que iniciara el programa ya que los programas pueden ser iniciados por otros programas.

Con esta orden le indicamos a la computadora que debe ejecutar un programa llamado holaMundo.sh y que deberá buscar las instrucciones de las que se compone el programa en la memoria. La CPU irá leyendo las instrucciones de la memoria de forma secuencial y una vez que tenga un resultado lo mostrará por algún dispositivo de salida. (por ejemplo, la pantalla).

 '''NOTA''': Se han obviado los pasos de interpretación del lenguaje de programación y otros aspectos.

=La unidad central de proceso (CPU)=

Para mas detalle consultar el tema 3:

Los computadores actuales tienen un componente que se llama la unidad central de procesamiento.(conocida por el término inglés [[:m:w:en:CPU|Central processing unit]] o CPU). La CPU esta compuesta por los siguientes componentes:

La unidad aritmético-lógica (ALU): Es la encargada de realizar las operaciones básicas
La Unidad de Control: Es la encargada de coordinar y gestionar el resto de elementos de la CPU.
Registros: Son elementos de memoria que contienen información relativa al programa que se está ejecutando.

La forma, diseño e implementación de las CPU ha cambiado mucho durante la evolución de la informática pero su funcionamiento continúa siendo el mismo desde su definición funcional en la arquitectura de Von Neumman.

==Lenguaje máquina==

Las CPU ejecutan programas que leen de la memoria principal. Pero estos programas no son escritos en lenguajes de alto nivel sino que son interpretados por la máquina utilizando un lenguaje muy restringido y de bajo nivel llamado lenguaje máquina. Este lenguaje es muy sencillo y se limita a un conjunto de instrucciones muy limitado que comunmente se llama juego de instrucciones del computador.

Cada CPU tiene su conjunto de instrucciones propio. Las CPU pueden ser de propósito general o estar diseñadas para un proposito concreto y por tanto tener un conjunto de instrucciones muy diferentes. De cualquier manera suelen cumplir los siguientes requisitos:

*Realizan una única y sencilla operación.
*Utilizan un número fijo de operandos y con una representación numérica fija.
*La codificación de las instrucciones es lo más simple y sitemática posible de tal forma que el interprete del lenguaje máquina pueda ser también sencillo.
*Las instrucciones son independientes y autocontenidas. Contienen todos los datos necesarios para ejecutarse y no dependen de otras instrucciones.

Y las podemos clasificar en::

*'''Instrucciones de transferencia de datos''': Leen o escriben datos de una memoria.
*'''Instrucciones aritméticas''': Realizan operaciones aritméticas utilizando la ALU.
*'''Instrucciones lógicas''': Realizan operaciones lógicas utilizando la ALU.
*'''Instrucciones de desplazamiento''': Realizan operaciones de desplazamiento.
*'''Instrucciones de transferencia de control''': Actualizan el registro PC de la CPU administrando el flujo de ejecución del programa (llamadas a subrutinas).
*'''Instrucciones I/O''': Administran los comandos de entrada salida.

Las instrucciones tienen un  '''formato rígido''' definido por el conjunto de instrucciones del sistema. Una instrucción tiene dos partes:
*'''Código de la operación''': es descodificado por la unidad de control
*'''Operandos''': Los datos sobre los cuales se ejecutará una operación. Hay operaciones que no tienen datos, operaciones unarias y operaciones binarias.
*Todas las instrucciones son '''imperativas'''

La arquitectura mas utilizada en PC de sobremesa es la [[:m:w:en:X86-16|x86]] de Intel y compatibles (com por ejemplo las CPU de AMD).  Esta arquitectura apareció en 1978 con intel y ha ido evolucionando Intel 286, Intel 386, Pentium,Pentium 2, Pentium 3, Itanium hasta los actuales Pentium 4.

Se han desarrollado y se continúan desarollando extensiones del lenguaje máquina. Un par de ejemplos son:

*[[:m:w:en:MMX_%28instruction_set%29|MMX d'Intel]]
*[[:m:w:en:3DNow%21|3DNow]]

Conviene destacar que normalmente es difícil encontrar software y sistemas operativos que soporten las nuevas instrucciones.

'''Propiedades''':
*Las instrucciones son independientes y autocontenidas. Contienen todos los datos necesarios para ejecutarse y no dependen de otras instrucciones.
*Instrucciones sistemáticas (facilita su decodificación). El decodificador ha de ser sencillo (no puede ser tan complicado como un compilador de un lenguaje de alto nivel).
*Es el único lenguaje que entiende la máquina.
*Utiliza código binario, octal o hexadecimal.
*Fueron los '''primeros lenguajes de programación'''
*Cada máquina (CPU) tiene su propio lenguaje y conjunto de instrucciones. Poco portable. Es necesario conocer el conjunto de instrucciones de la máquina para poder programarla.Diferentes arquitecturas.
*Actualmente se utilizan mucho más los lenguajes de alto nivel(mas faciles de aprender y utilizar por que son más cercanos al lenguaje natural)
**La unidad de controlo utilizando el descodificador es la encargada de convertir las instrucciones en código interpretable por la CPU.
*Los datos utilizados son referenciados por su posición en la memória. Es responsabilidad del programador controlar el mapa de memoria y la asignación de memoria a cada dato.
*Las instrucciones tiene un formato rígido definido por el conjunto de instrucciones del sistema. Una instrucción tiene dos partes:
**Código de la operación: Es descodificado por la unidad de control
**Operandos
*Todas las instrucciones son '''imperativas'''
*No se pueden utilizar comentarios

==La unidad aritmético-lógica (ALU)==

Las  ALU son las encargadas de realizar las operaciones aritmético-lógicas que le proporciona la unidad de control. Las operaciones son muy sencillas hasta el punto de que muchos procesadores disponen de un simple sumador/restador y el resto de operaciones se realizan mediante la descomposición en operaciones sencillas de otras más complejas.

Las ALU tiene el siguiente esquema:

[[file:ALU_symbol.svg|200px|thumb]]

La forma de V se utiliza tipicamente para representarla donde los extremos de la v son los operandos y el vértice el resultado. La comunicación entre la CPU y la ALU se realiza mediante los siguientes registros:

*'''A y B''': Son los registros que contienen los operandos. Tambien se llaman '''Registros de entrada'''.
*'''R''': Es el registro que contiene el resultado. Los registros A, B y R normalmente se almacenan en un banco de registros.
*'''F''': Es el registro que indica que '''tipo de operación''' se realiza sobre los operandos A y B.
*'''D''': Es el '''registro de estado del resultado'''. También conocido como '''registro de estado''' (Status Register). Se utiliza para indicar estados especiales como '''bits de arrastre''', '''divisiones por cero''' o ''''desbordamientos/overflows'''.

Las operaciones que suelen hacer las ALU son:

*Operaciones aritméticas con números enteros (suma, resta y a veces multiplicaciones y divisiones).
*Operaciones lógicas binarías 
*Operaciones de desplazamiento de bits: Desplazamientos a derecha o izquierda de bits (equivaliendo a multiplicar o a dividir por 2). 

Estas operaciones se suelen realizar mediante circuitos electrónicos que pueden ser circuitos combinacionales o circuitos secuenciales según utilizan registros de memoria o no.

Los operandos normalmente se representan en complemento a dos (Ver complemento a 2 en el tema 10) y las operaciones son con números enteros. 

Las operaciones se pueden clasificar en:
*'''Operacions unarias''': Un solo operando (operación de negación)
*'''Operacions binaria''': 2 operadores (suma, resta, división, etc.)

Las operaciones pueden ser:
*'''Operador paralelo''': La operación se realiza con todos los bits del operador a la vez.
*'''Operador serie''': la operación se realiza dígito a dígito.</text>
      <sha1>aav0xldn2279dhhhvnj7gqfqaj69e7p</sha1>
    </revision>
  </page>
  <page>
    <title>Mantenimiento y Montaje de Equipos Informáticos/Tema 2/Conectores</title>
    <ns>0</ns>
    <id>38624</id>
    <revision>
      <id>436474</id>
      <parentid>427612</parentid>
      <timestamp>2026-10-14T07:25:21Z</timestamp>
      <contributor>
        <username>~2026-55384-72</username>
        <id>128016</id>
      </contributor>
      <comment>/* USB: */</comment>
      <origin>436474</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="13238" sha1="j33pugb595h6ez1dk64fevpvgoj9sk9" xml:space="preserve">{{#ifeq:{{SUBPAGENAME}} |Texto completo ||
{{Mantenimiento y Montaje de Equipos Informáticos|tono=nube}}
}}
==Conectores Eléctricos==
Se verán en el tema 5

==Conectores informáticos==
Son conectores, también llamados puertos, que '''transmiten información''' entre el dispositivo y el computador. Pueden contener cables para la alimentación eléctrica.

===Conectores externos===
[[Archivo:conectores traseros.png|left|thumb|conectores externos, situados en la parte trasera de la caja.]]
Son los conectores que comunican al computador con diferentes periféricos externos al PC desde el monitor a una red LAN o impresora. 
Los conectores están situados en la parte trasera del computador y soldados a la placa base del computador. Son de alta fiabilidad. Los más comunes son:

====RED====
Par trenzado o '''[//es.wikipedia.org/wiki/RJ45 RJ-45]'''es una interfaz física comúnmente usada para conectar redes de cableado estructurado.

====Audio====
* '''Naranja''': Conector de salida de los altavoces centrales y del amplificador de graves. Configuración de audio de 5.1/7.1 canales.
* '''Negro''': Conector de salida de los altavoces traseros. Configuración de audio de 4/5.1/7.1 canales.
* '''Gris''': Conector de salida de los altavoces laterales. Configuración de audio de 7.1 canales.
* '''Verde''':Conector de salida de línea. Es el conector de salida de '''línea predeterminado'''. Utiliza este conector de audio para unos auriculares, etc.
* '''Rosa''': Conector de entrada de micrófono. Es el conector de entrada de '''micrófono predeterminado'''.
* '''Azul''': Conector de entrada de línea. Utiliza  este conector de audio para dispositivos mp3, otro micrófono, etc.

====USB:====
El [//es.wikipedia.org/wiki/USB Universal Serial Bus ('''USB''')] (bus universal en serie BUS) es un estándar industrial desarrollado en los años 1990 que define los cables, conectores y protocolos usados en un bus para conectar, comunicar y proveer de alimentación eléctrica entre computadores y periféricos y dispositivos electrónicos. Los dispositivos USB se clasifican según su velocidad de transferencia de datos y prestaciones en varios tipos:
FIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII


{|  class=wikitable style=&quot;text-align:center; margin-left:auto; margin-right:auto;&quot;
|-
! colspan=&quot;2&quot; scope=&quot;col&quot; | Connectors
! scope=&quot;col&quot; | USB 1.0&lt;br&gt;1996
! scope=&quot;col&quot; | USB 1.1&lt;br&gt;1998
! scope=&quot;col&quot; | USB 2.0&lt;br&gt;2001
! scope=&quot;col&quot; | USB 2.0&lt;br&gt;Revised 
! scope=&quot;col&quot; | [//es.wikipedia.org/wiki/USB_3.0 USB 3.0]&lt;br&gt;2011
! scope=&quot;col&quot; | [//es.wikipedia.org/wiki/USB_3.0#USB_3.1_y_USB_3.2 USB 3.1]&lt;br&gt;2014
! scope=&quot;col&quot; | [//es.wikipedia.org/wiki/USB_3.0#USB_3.1_y_USB_3.2 USB 3.2]&lt;br&gt;2017
! scope=&quot;col&quot; | [//es.wikipedia.org/wiki/Universal_Serial_Bus#USB_4 USB4]&lt;br&gt;2019
|-
! colspan=&quot;2&quot; scope=&quot;row&quot; | Data rate
| colspan=&quot;2&quot; | 1.5Mbit/s&lt;br&gt;(''Low Speed'')&lt;br&gt;12Mbit/s&lt;br&gt;(''Full Speed'')
| colspan=&quot;2&quot; | 1.5Mbit/s&lt;br&gt;(''Low Speed'')&lt;br&gt;12Mbit/s&lt;br&gt;(''Full Speed'')&lt;br&gt;480Mbit/s&lt;br&gt;(''High Speed'')
| 5 Gbit/s&lt;br&gt;(''SuperSpeed'')
| 10 Gbit/s&lt;br&gt;(''SuperSpeed+'')
| 20 Gbit/s&lt;br&gt;(''SuperSpeed+'')
| 40 Gbit/s&lt;br&gt;(''SuperSpeed+, Thunderbolt 3 and 4'')
|-
! rowspan=&quot;3&quot; scope=&quot;row&quot; | Standard
! A
| colspan=&quot;4&quot; | Type A&lt;br&gt;[[File:USB Type-A receptacle.svg|75px]]
| colspan=&quot;2&quot; | Type A&lt;br&gt;[[File:USB 3.0 Type-A receptacle blue.svg|75px]]
| colspan=&quot;2&quot; | Obsoleto
|-
! B
| colspan=&quot;4&quot; | Type B&lt;br&gt;[[File:USB Type-B receptacle.svg|x60px]]
| colspan=&quot;2&quot; | Type B&lt;br&gt;[[File:USB 3.0 Type-B receptacle blue.svg|x75px]]
| colspan=&quot;2&quot; | Obsoleto
|-
! C
| colspan=&quot;2&quot; | No disponible
| colspan=&quot;7&quot; | [//es.wikipedia.org/wiki/USB-C '''Type C'''] &lt;br&gt;[[File:USB Type-C Receptacle Pinout.svg|219x219px]]
|-
! rowspan=&quot;3&quot; scope=&quot;row&quot; | Mini
! A
| rowspan=&quot;2&quot; | No disponible
| colspan=&quot;3&quot; | Mini A&lt;br&gt;[[File:USB Mini-A receptacle.svg|75x75px]]
| rowspan=&quot;3&quot; colspan=&quot;5&quot; | Obsoleto
|-
! B
| colspan=&quot;3&quot; | Mini B&lt;br&gt;[[File:USB Mini-B receptacle.svg|67x67px]]
|-
! AB
| colspan=&quot;3&quot; | No disponible
| Mini AB&lt;br&gt;[[File:USB_Mini-AB_receptacle.svg|60px]]
|- style=&quot;height: 6em;&quot;
! rowspan=&quot;3&quot; scope=&quot;row&quot; | Micro
! A
| colspan=&quot;8&quot; | No disponible
|-
! B
| colspan=&quot;3&quot; rowspan=&quot;2&quot; | No disponible
| Micro B&lt;br&gt;[[File:USB Micro-B receptacle.svg|alt=|frameless|75x75px]]
| colspan=&quot;2&quot; | Micro B&lt;br&gt;[[File:USB 3.0 Micro-B receptacle.svg|frameless|117x117px]]
| colspan=&quot;2&quot; | Obsoleto
|-
! AB
| Micro AB&lt;br&gt;[[File:USB Micro-AB receptacle.svg|75x75px]]
| colspan=&quot;4&quot; | Obsoleto
|-
! colspan=&quot;2&quot; scope=&quot;row&quot; | Conectores
! scope=&quot;col&quot; | USB 1.0&lt;br&gt;1996
! scope=&quot;col&quot; | USB 1.1&lt;br&gt;1998
! scope=&quot;col&quot; | USB 2.0&lt;br&gt;2001
! scope=&quot;col&quot; | USB 2.0&lt;br&gt;Revised 
! scope=&quot;col&quot; | USB 3.0&lt;br&gt;2011
! scope=&quot;col&quot; | USB 3.1&lt;br&gt;2014
! scope=&quot;col&quot; | USB 3.2&lt;br&gt;2017
! scope=&quot;col&quot; | USB4&lt;br&gt;2019
|}

====[//es.wikipedia.org/wiki/Video_Graphics_Array VGA]====
O D-sub 15 de tres hileras de 15 pines se encuentra en la mayoría de las tarjetas gráficas, monitores de computadoras, y otros dispositivos de vídeo. Está cayendo en desuso por ser analógico y soportar menor resolución que el DVI-D. No se debe confundir con puerto Serie (dos filas de pines).

[[Archivo:DVI Connector Types.svg|thumb|left|Conector DVI (vista del enchufe macho).]]

====[//es.wikipedia.org/wiki/Digital_Visual_Interface DVI (Digital Visual Interface)]====
Es un conector de vídeo diseñado para obtener la máxima calidad de visualización posible en pantallas digitales, tales como los monitores LCD de pantalla plana y los proyectores digitales.  posee pins para transmitir las señales digitales nativas de DVI. En los sistemas de doble enlace, se proporcionan pins adicionales para la segunda señal. También puede tener pins para transmitir las señales analógicas del estándar VGA. Esta característica se incluyó para dar un carácter universal al conector. Los conectores que la implementan admiten monitores de ambos tipos (analógico o digital). Se clasifican en tres tipos en función de qué señales admiten:

{| class=&quot;wikitable&quot;
! tipo conector || Señal
|-
| DVI-D 
| sólo digital
|-
| DVI-A
| sólo analógica
|-
|  DVI-I
| digital y analógica
|}

====[//es.wikipedia.org/wiki/HDMI High-Definition Multimedia Interface o '''HDMI''']==== 
[[File:HDMI Connector Pinout.svg|thumb|Conector HDMI]]

Es una interfaz multimedia de alta definición, es una norma de audio y vídeo digital cifrado sin compresión apoyada por la industria para que sea el sustituto del euroconector. HDMI provee una interfaz entre cualquier fuente de audio y vídeo digital como podría ser un sintonizador TDT, un reproductor de Blu-ray, un Tablet PC, un computador o un receptor A/V, y monitor de audio/vídeo digital compatible, como un televisor digital (DTV). Permite el uso de vídeo computarizado, mejorado o de alta definición, así como audio digital multicanal en un único cable.

====[//es.wikipedia.org/wiki/DisplayPort '''DisplayPort''']====
[[File:DisplayPort Connector.svg|thumb|Conector DisplayPort]]
[[File:DisplayPort-rid.jpg|thumb|DisplayPort]]
DisplayPort es una interfaz digital estándar de dispositivos desarrollado por la Asociación de Estándares Electrónicos de Vídeo (VESA). Libre de licencias y cánones, define un tipo de interconexión destinado a la transmisión de Vídeo entre una computadora y su monitor con una resolución máxima 4k x 2K (4096 x 2160). '''Opcionalmente permite la transmisión de Audio''' para su uso por ejemplo en sistemas de cine en casa con un máximo de 8 canales sin compresión 192 kHz, 24-bit, '''y la transmisión de Datos''', por ejemplo USB.

====[https://es.wikipedia.org/wiki/TOSLINK TOSLINK]====
Es una conexión de fibra óptica, que se basa en la utilización de señales ópticas en lugar de señales eléctricas. Se utiliza generalmente para la interconexión de equipos de audio, aunque admite diferentes formatos, tanto físicos como de datos. Ventajas: El ruido electromagnético no afecta a la transmisión, tampoco radia ruido electromagnético, fácil de montar y conectar.
====[[w:Thunderbolt_(bus)|Thunderbolt]]====
Es el nombre comercial utilizado por Intel para designar a un tipo de interfaz de conexión de alta velocidad. En su versión Thunderbolt 5 publicada en 2024.&lt;ref&gt;[https://newsroom.intel.com/client-computing/intel-introduces-thunderbolt-5-standard ''Intel Introduces Thunderbolt 5 Connectivity Standard''] - 12 de septiembre de 2023 (''en inglés'').&lt;/ref&gt; ofrece un ancho de banda de 80Gbit/s. Aunque nació bajo el nombre clave ''Ligit Peak'' planteando el uso de fibra óptica, se consolidó en el mercado masivo usando cables de cobre y adoptando el conector USB-C. Se creó con el propósito de reemplazar a las antiguas versiones de USB, FireWire y HDMI.

En definitiva, si no funciona un periférico con los conectores frontales, se debe comprobar con los traseros. Si no funcionara, se debiera probar otro similar y/o comprobar en el BIOS que estos conectores están habilitados.

===Conectores internos===
[[Imagen:intel-pcb.png|left|thumb|conectores internos, vista de una placa base Intel.]]

Son conectores situados en el interior del computador, suelen estar en la placa base y en algún dispositivo (discos duros, reproductores DVD, lectores de tarjetas,....). Sirven para la transferencia de información entre la placa base y el dispositivo. También existen otros conectores para el conexionado de la placa base con los conectores frontales de la caja (audio, usb, interruptores de alimentación y led's).

Los conectores de la memoria RAM y del procesador, se verán en sendos apartados.

[[File:SATA ports.jpg|thumb|SATA ports]]

* '''[//es.wikipedia.org/wiki/Sata Serial ATA o SATA]''' es una interfaz de transferencia de datos entre la placa base y algunos dispositivos de almacenamiento, como puede ser el '''disco duro, lectores''' y regrabadores de CD/DVD/BR, Unidades de Estado Sólido u otros dispositivos de altas prestaciones que están siendo todavía desarrollados. SATA sustituye al '''[//en.wikipedia.org/wiki/Parallel_ATA P-ATA]'''. SATA proporciona '''mayores velocidades''' de transferencia de datos, conexionado '''punto a punto''' y utiliza un cable con una '''longitud máxima de 1 metro'''.
:
:Se comercializan dispositivos SATA II, a 300 MB/s de velocidades de transmisión, también conocida como Serial ATA-300 y los SATA III con tasas de transferencias de hasta 750 MB/s, son compatibles entre ellos y siempre se aplicará la velocidad menor de transferencia soportada.....

[[Archivo:MSATA SSD vs. 2.5&quot; SATA drive.JPG|thumb|left|mSATA SSD vs. disco 2.5&quot; SATA]]
* '''mSATA o mini-SATA''' es una interfaz, variante de la interfaz SATA. La interfaz mSATA es muy usada en computadoras portátiles y también en placas base actuales. Se conectan discos SSD. La interfaz mSATA se divide en dos partes: interfaz eléctrica similar al MOLEX sin alimentanción de 12V y la interfaz SATA. Existen cables para convertir una SATA y MOLEX en un mSATA.  El conector mSATA es similar en apariencia a una interfaz Mini-Tarjeta PCI Express, pero no es compatible eléctricamente ni en las señales de datos.


* [//es.wikipedia.org/wiki/Peripheral_Component_Interconnect PCI] es la versión antigua del PCI Express. Su uso es limitado a unos pocos dispositivos. No se puede utilizar en tarjetas de expansión de vídeo de alta definición o ampliación de USB 3.0 o Giga Ethernet pues su caudal es escaso.

[[Archivo:PCI-E &amp; PCI slots on DFI LanParty nF4 SLI-DR 20050531.jpg|right|250px|thumb|Slots PCI Express (de arriba a abajo: x4, x16, x1 y x16), comparado con uno tradicional PCI de 32 bits, tal como se ven en la placa [[w:DFI|DFI]] LanParty nF4 Ultra-D]]
* [//es.wikipedia.org/wiki/PCIe '''PCI Express o PCIe''']: cada ranura de expansión lleva uno, dos, cuatro, ocho o dieciséis carriles de datos entre la placa base y las tarjetas conectadas. El número de carriles se escribe con una x de prefijo (x1 para un carril simple y x16 para una tarjeta con dieciséis carriles); x16 de 500MB/s dan un máximo [[w:ancho de banda|ancho de banda]] de 8 GB/s en cada dirección para PCIE 2.x. En el uso más común de x16 para el PCIE 1.1 proporciona un ancho de banda de 4 GB/s (250 MB/s x 16) en cada dirección. En comparación con otros buses, un carril simple es aproximadamente el doble de rápido que el PCI normal; una ranura de cuatro carriles, tiene un ancho de banda comparable a la versión más rápida de PCI-X 1.0, y ocho carriles tienen un ancho de banda comparable a la versión más rápida de AGP.
:
:Una ranura PCi Express 3.0 tiene 1 GB/s direccional y 2 GB/s bidireccional, por lo que logran en el caso de x16 un máximo teórico de 16 GB/s direccionales y 32 GB/s bidireccion
:Se usa para todo tipo de tarjetas de expansión (tarjetas de red, ampliación puertos, tarjetas vídeo,etc...).

[[File:M.2 and mSATA SSDs comparison.jpg|thumb|upright=1.4|left|Comparación de un SSD tipo mSATA a la izquierda con uno M.2, 2242 SSD]]
* [//es.wikipedia.org/wiki/M.2 '''M.2''']:Utiliza la ranura física PCI Express Mini Card y sus conexiones. Las especificaciones de M.2 son más flexibles, lo que permite diferentes longitudes y anchos de los módulos. El estándar M.2 es más idóneo que el mSATA para las unidades de estado sólido en general.</text>
      <sha1>j33pugb595h6ez1dk64fevpvgoj9sk9</sha1>
    </revision>
  </page>
  <page>
    <title>Haskell</title>
    <ns>0</ns>
    <id>42615</id>
    <revision>
      <id>436373</id>
      <parentid>436312</parentid>
      <timestamp>2026-10-13T16:31:23Z</timestamp>
      <contributor>
        <username>~2026-54787-13</username>
        <id>128006</id>
      </contributor>
      <comment>/* Tutoriales que se han incorporado al Wikilibro de Haskell */</comment>
      <origin>436373</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="7759" sha1="5e85dikn19pf2r0hf5spaepb4a6p9hh" xml:space="preserve">__NOTOC__
{{traduciendo|en|Haskell}}
[[Archivo:Haskell-Logo.svg|derecha|sinmarco]]
{{Versión imprimible}}
{{Colección}}
{{Versión en PDF}}

{{Buscar en libro}}

'''Haskell''' es un [[w:Programación founcional|lenguaje de programación puramente funcional]]. Se diferencia de varias formas:

* Haskell es un lenguaje de programación funcional ''puro''. Cuando se invoca una función usando los mismos argumentos devolverá el mismo resultado cada vez.
* Haskell es ''perezoso''. Las evaluaciones se realizan solo cuando es necesario.
* Haskell proporciona un sistema de tipado moderno con características sofisticadas, como clases de tipos y tipos de datos algebraicos generalizados (muy pronto, términos como estos van a sonar bien fuera del lenguaje).

* Haskell provee un sistema tipográfico moderno con funciones de última generación, como clases tipográficas y tipos de datos algebraicos generalizados (muy pronto, términos como esos saldrán fácilmente de su boca).

Haskell es divertido de usar porque tratar con funciones puras hace que el código sea mucho más fácil de razonar, y el sistema de tipo avanzado ayuda a detectar errores tontos y profundos.

El objetivo de este libro es introducir al lector, sea este un estudiante o persona interesada en aprender el lenguaje Haskell, en dos aspectos; en primer lugar, al lenguaje Haskell desde las características más básicas a las avanzadas y en segundo lugar a la programación en general. Se insta que los programadores avanzados sean particularmente pacientes con este proceso. Es muy probable que los lenguajes con los que están familiarizados difieran mucho de Haskell, y los hábitos que provienen de esos lenguajes pueden dificultar el proceso de entendimiento de cómo se maneja la sintaxis; Haskell es simple, pero diferente. Aprender a ver el mundo a través de la perspectiva matemática de un programador funcional es una aventura en un mundo nuevo y desafiante, que trae conocimiento valioso más allá de los límites de cualquier lenguaje. Teniendo en cuenta todos estos aspectos, este libro también pretende ser una herramienta y ayuda a la hora de programar en Haskell.

== Descripción general ==
El libro está dividido en tres secciones: una unidad para principiantes, una unidad avanzada y una sección llamada Haskell en la práctica. La última sección, que cubre casos prácticos de uso, depende únicamente de la unidad para principiantes. Los programadores experimentados pueden leer la descripción general para evaluar rápidamente qué hace que Haskell sea único y diferente de otros lenguajes.

{{Información|¡Por favor contribuya! Cualquiera, independientemente de la competencia de Haskell, puede ayudar. Dedique cinco minutos a mejorar un módulo y ahorre horas de tiempo a otra persona. Revisar la [[/Notas para contribuyentes|notas para las contribuyentes]]. Incluso si te confundes con una página, cuéntanoslo en la página de discusión (Por supuesto, cortesmente).}}

== Unidad para principiantes ==
Esta sección le presenta los conceptos básicos de Haskell y algunas bibliotecas de uso común. Al final de esta unidad, debería poder escribir programas simples de Haskell. La mayoría de los capítulos incluyen ejercicios, con soluciones, para su práctica.

{|width=&quot;100%&quot; cellspacing=&quot;0&quot; cellpadding=&quot;15&quot; valign=&quot;top&quot; style=&quot;margin:0.8em 0;border:1px solid MediumAquamarine;background:honeydew&quot;
|valign=&quot;top&quot; style=&quot;border-right: 1px dashed MediumAquamarine&quot;|

=== Principios básicos de Haskell ===
*{{Capítulo de Haskell/Principios básicos de Haskell|sep=
*}}
|valign=&quot;top&quot; style=&quot;border-right: 1px dashed MediumAquamarine&quot;|

=== Haskell nivel elemental ===
*{{Capítulo de Haskell/Haskell elemental|sep=
*}}
|valign=&quot;top&quot; style=&quot;border-right: 1px dashed MediumAquamarine&quot;|

=== Haskell nivel intermedio ===
*{{Capítulo de Haskell/Haskell intermedio|sep=
*}}
|valign=&quot;top&quot;|

=== Mónadas ===
*{{Capítulo de Haskell/Mónadas|sep=*|subsep=&amp;nbsp;-&amp;nbsp;|breaksep=
**|firstsep=
*}}
|}

== Unidades avanzadas ==

Esta sección presenta conceptos de programación funcional más amplios, como diferentes estructuras de datos y teoría de tipos. También cubrirá temas más prácticos como la concurrencia.

{|width=&quot;100%&quot; cellspacing=&quot;0&quot; cellpadding=&quot;15&quot; valign=&quot;top&quot; style=&quot;margin:0.8em 0; border: 1px solid SlateBlue; background:#F7F7FF&quot;
|valign=&quot;top&quot; style=&quot;border-right: 1px dashed SlateBlue&quot;|

=== Haskell avanzado ===
*{{Capítulo de Haskell/Haskell avanzado|sep=
*}}
|valign=&quot;top&quot; style=&quot;border-right:1px dashed SlateBlue&quot;|

=== Diversión con tipos ===
*{{Capítulo de Haskell/Diversión con tipos|sep=
*}}
|valign=&quot;top&quot; style=&quot;border-right:1px dashed SlateBlue&quot;|

=== Teoría ampliada ===
*{{Capítulo de Haskell/Teoría ampliada|sep=
*}}
|valign=&quot;top&quot;|

=== Rendimiento de Haskell ===
*{{Capítulo de Haskell/Rendimiento de Haskell|sep=
*}}
|}

== Haskell en la práctica ==

Los problemas cotidianos de trabajar con Haskell incluyen elementos como conocer las bibliotecas estándar, crear interfaces gráficas y trabajar con bases de datos. Debería poder saltar directamente a esta sección desde la unidad para principiantes.

{|width=&quot;100%&quot; cellspacing=&quot;0&quot; cellpadding=&quot;15&quot; style=&quot;margin-top:0.8em;margin-bottom:0.8em;border:1px solid gold;background:cornsilk&quot;
|valign=&quot;top&quot; style=&quot;border-right: 1px dashed gold&quot;|

=== Bibliotecas de referencia ===
*{{Capítulo de Haskell/Bibliotecas de referencia|sep=*|subsep=&amp;nbsp;-&amp;nbsp;|breaksep=
**|firstsep=
*}}
|valign=&quot;top&quot; style=&quot;border-right: 1px dashed gold&quot;|

=== Prácticas generales ===
*{{Capítulo de Haskell/Prácticas generales|sep=
*}}
|valign=&quot;top&quot;|

=== Tareas especializadas ===
*{{Capítulo de Haskell/Tareas especializadas|sep=
*}}
|}

== Apéndices ==
* [[/Azúcar sintáctico/]]
* [[/Soluciones|Respuestas a ejercicios]]
* [[/Historia de Haskell/]]
* [[/Implementaciones de Haskell/]]
* [[/Autores/|Autores y agradecimientos]] (original en inglés)

== Acerca del libro ==
* [[/Notas para los contribuyentes/]]
* [[/Convenciones de estilo/]]
* [[/To do/]]
* [[:Categoría:Haskell/Plantillas|Plantillas para el wikilibro de Haskell]]
* [[/Módulos experimentales/|Módulos experimentales]]
* [[/Lista de tópicos/|Lista de tópicos]]

== Otros tutoriales de Haskell ==
* [http://www.haskell.org/haskellwiki/Meta-tutorial Haskell Meta-tutorial] - the tutorial to find other tutorials
* [http://www.learnyouahaskell.com/Chapters Learn You a Haskell for Great Good] - Tutorial aimed at beginners who may have experience in imperative programming languages but haven't programmed in a functional language before. Freely available online under a CC-BY-NC-SA license; also released as a conventional book.
* [http://book.realworldhaskell.org/ Real World Haskell] -  an O'Reilly book, available online at no charge (CC-BY-NC license). Built around case studies of practical applications.

== Tutoriales de Haskell que se han incorporado a Wikilibros  ==
Los siguientes tutoriales pueden leerse de forma independiente, pero su contenido ya se ha importado y adaptado a Wikilibros:

* [[Write Yourself a Scheme in 48 Hours]] &amp;mdash; An alternate approach to teaching Haskell (and perhaps Scheme), aimed at a more advanced audience (though not necessarily one that knows how to program!)
* [[/YAHT|Yet Another Haskell Tutorial]] &amp;mdash; is aimed at beginners and takes a practical approach to things.

== Recursos adicionales ==
* [http://www.haskell.org/haskellwiki/Learning_Haskell Learning Haskell] en haskell.org
* [http://dev.stephendiehl.com/hask/ What I Wish I Knew When Learning Haskell] - A wide-ranging collection of concise summaries of many intermediate and advanced Haskell topics. Released in the public domain.

{{Estantes|Lenguajes de programación}}</text>
      <sha1>5e85dikn19pf2r0hf5spaepb4a6p9hh</sha1>
    </revision>
  </page>
  <page>
    <title>Plantilla:Navigate</title>
    <ns>10</ns>
    <id>58912</id>
    <redirect title="Plantilla:Navegador compacto" />
    <revision>
      <id>436472</id>
      <parentid>383377</parentid>
      <timestamp>2026-10-13T23:25:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Plantilla:Navegador compacto]]</comment>
      <origin>436472</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46" sha1="qpsrvg8dxt3s8f6qf0b9iabcws2k4s2" xml:space="preserve">#REDIRECCIÓN [[Plantilla:Navegador compacto]]</text>
      <sha1>qpsrvg8dxt3s8f6qf0b9iabcws2k4s2</sha1>
    </revision>
  </page>
  <page>
    <title>Haskell/Variables y funciones</title>
    <ns>0</ns>
    <id>64935</id>
    <revision>
      <id>436486</id>
      <parentid>436345</parentid>
      <timestamp>2026-10-14T11:46:16Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Parámetros múltiples */</comment>
      <origin>436486</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21760" sha1="obbj6z7ybxsbqvf86robrcw3hb5mzg4" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

''Todos los ejemplos de este capítulo pueden guardarse en un archivo y ejecutarse usando GHC. No incluyas `Prelude&gt;` en ninguno de los ejemplos. Cuando aparezca este comando, significa que el código siguiente se ejecutó en GHCi. Cuando no aparezca el comando, basta con copiar el código completo.''

== Variables ==
En el capítulo anterior, usamos GHCi como una calculadora, algo que resulta práctico únicamente para cálculos breves. Para realizar cálculos más complejos y escribir un programa en Haskell, generalmente tenemos que seguir y comprobar los resultados intermedios.

Podemos hacerlo asignando nombres. A estos nombres los llamamos ''variables''. Cuando se ejecuta un programa, cada variable se sustituye por un ''valor'' al que hace referencia. Por ejemplo, considera lo siguiente:

{{Haskell/GHCi|1=
Prelude&gt; 3.141592653 * 5^2
78.539816325
}}

Este fue el cálculo aproximado del área de un círculo de radio &lt;code&gt;5&lt;/code&gt;, de acuerdo con la fórmula &lt;math&gt;A = \pi r^2&lt;/math&gt;. Por supuesto, resulta bastante laborioso escribir todos los dígitos de &lt;math&gt;\pi \approx 3,141592653&lt;/math&gt;, o incluso recordar los primeros cinco. Por eso, para evitar repeticiones, podemos hacer que la máquina recuerde estos valores una sola vez, de modo que podamos utilizarlos siempre que sea necesario. Esta abstracción nos permite concentrarnos en otras partes más importantes. En este ejemplo, Haskell ya dispone de una variable llamada &lt;code&gt;pi&lt;/code&gt; que almacena más de 15 dígitos de &lt;math&gt;\pi&lt;/math&gt;, lo que hace que el código sea más claro y, además, nos permite obtener resultados más precisos.

{{Haskell/GHCi|1=
Prelude&gt; pi
3.141592653589793
Prelude&gt; pi * 5^2
78.53981633974483
}}

Observa cómo la variable &lt;code&gt;pi&lt;/code&gt; y su valor, &lt;code&gt;3.141592653589793&lt;/code&gt;, se sustituyen mutuamente en los cálculos.

== Archivos de código en Haskell ==
Además de realizar cálculos ocasionalmente en GHCi, puedes guardar tu código en un archivo Haskell, que es un archivo de texto con la extensión &lt;tt&gt;.hs&lt;/tt&gt;. Se recomienda utilizar un editor de texto diseñado para la programación (consulta el [[w:Editor de texto|artículo de Wikipedia sobre editores de texto]]). La gran mayoría de ellos permiten ''resaltar la sintaxis'', es decir, colorear el código fuente para facilitar su lectura. Vim y Emacs son dos opciones bastante populares entre los programadores.

Para mantener todo organizado, crea también un directorio nuevo (una carpeta) en tu computadora para guardar los archivos Haskell que vayas creando al resolver los ejercicios de este libro. Vamos, crea un directorio llamado &lt;tt&gt;HaskellWikibook&lt;/tt&gt;, por ejemplo, y dentro de él un archivo llamado &lt;tt&gt;Varfun.hs&lt;/tt&gt; que contenga el siguiente código:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
r = 5.0
&lt;/syntaxhighlight&gt;

Este programa define la variable &lt;code&gt;r&lt;/code&gt; con el valor &lt;code&gt;5.0&lt;/code&gt;.

Nota: asegúrate de que no haya espacios en blanco al comienzo de las líneas, porque Haskell distingue los espacios de indentación.

Después, abre una terminal en el directorio &lt;tt&gt;HaskellWikibook&lt;/tt&gt; que creaste, ejecuta GHCi y carga el archivo &lt;tt&gt;Varfun.hs&lt;/tt&gt; usando el comando &lt;code&gt;:load&lt;/code&gt;:

{{Haskell/GHCi|1=
Prelude&gt; :load Varfun.hs
[1 of 1] Compiling Main             ( Varfun.hs, interpreted )
Ok, modules loaded: Main.
}}

Conviene saber que &lt;code&gt;:load&lt;/code&gt; puede abreviarse como &lt;code&gt;:l&lt;/code&gt;: &lt;code&gt;:l Varfun.hs&lt;/code&gt;.

Si GHCi devuelve un error como &lt;code&gt;Could not find module 'Varfun.hs'&lt;/code&gt;, significa que probablemente te encuentras en el directorio equivocado. Prueba el comando &lt;code&gt;:cd&lt;/code&gt; para cambiar el directorio actual desde GHCi (por ejemplo, &lt;code&gt;:cd HaskellWikibook&lt;/code&gt;).

Después de cargar el archivo en la sesión de GHCi, verás que la línea de comandos cambia de &quot;Prelude&quot; a &quot;*Main&quot;. Ahora puedes utilizar la variable &lt;code&gt;r&lt;/code&gt; que definiste en el archivo.

{{Haskell/GHCi|1=
*Main&gt; r
5.0
*Main&gt; pi * r^2
78.53981633974483
}}

Acabamos de calcular el área de un círculo de radio 5,0 utilizando la fórmula &lt;math&gt;\pi r^2&lt;/math&gt;. Lo que hicimos fue utilizar &lt;code&gt;r&lt;/code&gt;, que definimos en el archivo &lt;tt&gt;Varfun.hs&lt;/tt&gt;, y &lt;code&gt;pi&lt;/code&gt;, que ya está definida en otro lugar.

Ahora vamos a facilitar el acceso a este valor definiendo también un nombre para él. Abre nuevamente el archivo y cambia su contenido por lo siguiente:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
r = 5.0
area = pi * r ^ 2
&lt;/syntaxhighlight&gt;

Guárdalo y vuelve a cargarlo en GHCi mediante &lt;code&gt;:reload&lt;/code&gt;, o simplemente &lt;code&gt;:r&lt;/code&gt;:

{{Haskell/GHCi|1=
*Main&gt; :reload
Compiling Main             ( Varfun.hs, interpreted )
Ok, modules loaded: Main.
*Main&gt;
}}

Ahora tenemos dos variables: &lt;code&gt;r&lt;/code&gt; y &lt;code&gt;area&lt;/code&gt;.

{{Haskell/GHCi|1=
*Main&gt; area
78.53981633974483
*Main&gt; area / r
15.707963267948966
}}

{{nota|La palabra &lt;code&gt;let&lt;/code&gt; es la que deberíamos utilizar para definir nuevas variables directamente en GHCi, sin necesidad de editar un archivo de código. Aunque hacerlo de esta manera puede resultar práctico, no siempre es lo más conveniente para tareas complejas. En esos casos, es preferible utilizar archivos.}}

== Comentarios ==
Además del propio código, los archivos de código fuente pueden contener textos conocidos como ''comentarios'', que el compilador ignora. En Haskell existen dos tipos de comentarios. El primero comienza con &lt;code&gt;--&lt;/code&gt; y se extiende hasta el final de la línea:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
x = 5     -- x es 5.
y = 6     -- y es 6.
-- z = 7  -- z no está definida.
&lt;/syntaxhighlight&gt;

En este caso, &lt;code&gt;x&lt;/code&gt; e &lt;code&gt;y&lt;/code&gt; están efectivamente definidas en el código, pero &lt;code&gt;z&lt;/code&gt; no lo está.

El segundo tipo de comentario está delimitado por &lt;code&gt;{- ... -}&lt;/code&gt; y puede abarcar varias líneas:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
answer = 2 * {-
  bloque de comentario de varias líneas y...
  -} 3 {- comentario en medio de la línea -} * 7
&lt;/syntaxhighlight&gt;

Los comentarios se utilizan para explicar partes de un programa o realizar anotaciones sobre cualquier aspecto del contexto. Es importante señalar que abusar de los comentarios puede, en realidad, dificultar la lectura del propio código. Además, los comentarios desactualizados también pueden generar confusiones.

== Variables en lenguajes imperativos ==
Los lectores familiarizados con los lenguajes de programación imperativos notarán que las variables en Haskell se comportan de manera muy diferente a las variables en C, por ejemplo.

Si no tienes experiencia previa en programación, puedes saltarte esta sección, aunque puede ayudarte a comprender las situaciones en las que se compara el comportamiento de Haskell con el de otros lenguajes. Muchos libros sobre Haskell lo hacen, por ejemplo.

La ''programación imperativa'' trata las variables como posiciones en la memoria de la computadora. Este enfoque está relacionado con el funcionamiento básico de una computadora. Los programas imperativos indican explícitamente a la computadora lo que debe hacer. Los lenguajes de alto nivel, aunque pueden estar bastante alejados de estos conceptos, todavía conservan parte de ellos en el sentido de que siguen utilizando este patrón de programación «paso a paso». En contraste, la ''programación funcional'' ofrece una manera diferente de pensar, utilizando términos matemáticos y dejando de lado las instrucciones directas a la computadora, que solo son traducidas por el compilador a algo que la máquina pueda interpretar y procesar.

Veamos un ejemplo. El siguiente código no funcionaría en Haskell:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
r = 5
r = 2
&lt;/syntaxhighlight&gt;

Un programador de lenguajes imperativos interpretaría esto como: primero, definir &lt;code&gt;r = 5&lt;/code&gt; y después redefinirla como &lt;code&gt;r = 2&lt;/code&gt;. En Haskell, sin embargo, el compilador respondería con un error: «múltiples declaraciones de &lt;code&gt;r&lt;/code&gt;». Dentro de un ámbito determinado, una variable de Haskell se define una sola vez y su definición no puede cambiar.

Las variables de Haskell parecen ''invariables'', pero en realidad se comportan como variables matemáticas. En Matemáticas nunca vemos que una variable cambie de valor dentro de un mismo problema, y lo mismo sucede en Haskell.

Más precisamente, las variables de Haskell son ''inmutables'': sus valores solo varían de acuerdo con los datos que introducimos en el programa. No podemos definir &lt;code&gt;r&lt;/code&gt; de dos maneras diferentes en un mismo código, pero podemos cambiar su valor modificando el archivo. Cambiemos el código anterior por lo siguiente:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
r = 2.0
area = pi * r ^ 2
&lt;/syntaxhighlight&gt;

Por supuesto, funcionará. Hemos cambiado &lt;code&gt;r&lt;/code&gt; en el único lugar donde está definida, y eso modifica su valor en el resto del programa.

En problemas reales, los programas en Haskell dejan ''algunos'' valores sin definir en el código. Esos valores se definen más adelante, cuando el programa obtiene datos de un archivo o de una acción externa. Por ahora, sin embargo, nos limitaremos a definir variables internamente. Aprenderemos sobre las interacciones con el mundo exterior en capítulos posteriores.

Veamos otro ejemplo de la gran diferencia entre Haskell y los lenguajes imperativos:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
r = r + 1
&lt;/syntaxhighlight&gt;

En lugar de «incrementar el valor de &lt;code&gt;r&lt;/code&gt;», es decir, actualizar el valor almacenado en la memoria, este código en Haskell constituye una definición recursiva de &lt;code&gt;r&lt;/code&gt;, o sea, la define en términos de sí misma. No te preocupes, pues explicaremos la [[Haskell/Recursión|recursión]] más adelante. En este caso concreto, si &lt;code&gt;r&lt;/code&gt; ya hubiera sido definida con algún valor, el compilador devolvería un mensaje de error, como explicamos anteriormente. Si &lt;code&gt;r&lt;/code&gt; se hubiera definido con el valor 5, escribir &lt;code&gt;r = r + 1&lt;/code&gt; sería equivalente a intentar afirmar que &lt;math&gt;5 = 5 + 1&lt;/math&gt; en Matemáticas, lo cual es evidentemente incorrecto.

Como los valores no cambian dentro de un mismo programa, las variables pueden definirse en el orden que queramos. Por ejemplo, los dos códigos siguientes son exactamente equivalentes:

{|border=&quot;0&quot;
|-
||&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
 y = x * 2
 x = 3
&lt;/syntaxhighlight&gt;
||&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
 x = 3
 y = x * 2
&lt;/syntaxhighlight&gt;
|}

En Haskell no existe la noción de que «&lt;code&gt;x&lt;/code&gt; se declaró antes que &lt;code&gt;y&lt;/code&gt;», o viceversa. Por supuesto, para utilizar &lt;code&gt;y&lt;/code&gt; seguimos necesitando el valor de &lt;code&gt;x&lt;/code&gt;, pero el orden no nos importa, ni tampoco al compilador.

== Funciones ==
Modificar el programa cada vez que queramos calcular el área de un círculo diferente resulta tedioso y nos limita a un círculo por vez. Podríamos calcular dos áreas duplicando todos los cálculos en nuestro código y definiendo &lt;code&gt;r2&lt;/code&gt; y &lt;code&gt;area2&lt;/code&gt;&lt;ref group=nota&gt;Podemos observar aquí que los nombres de las variables pueden contener números y letras. Sin embargo, toda variable ''debe'' comenzar con una letra minúscula, seguida de otras letras (también mayúsculas), números, guiones bajos (_) o apóstrofos (').&lt;/ref&gt;

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
r  = 5
area  = pi * r ^ 2
r2 = 3
area2 = pi * r2 ^ 2
&lt;/syntaxhighlight&gt;

Para evitar esta repetición constante, es preferible añadir simplemente una ''función'' para calcular el área y aplicarla a diferentes radios.

Una ''función'' recibe un ''argumento'' (o ''parámetro'') y devuelve un resultado, exactamente igual que en Matemáticas. En Haskell, las funciones se definen de la misma manera que las variables, salvo que debemos indicar sus argumentos en el lado izquierdo de la expresión. Por ejemplo, el siguiente código define &lt;code&gt;area&lt;/code&gt;, cuyo argumento es &lt;code&gt;r&lt;/code&gt;:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
area r = pi * r ^ 2
&lt;/syntaxhighlight&gt;

Observa la sintaxis: primero aparece el nombre de la función (&lt;code&gt;area&lt;/code&gt;), seguido de un espacio en blanco y de su argumento (&lt;code&gt;r&lt;/code&gt;). Después aparece el signo &lt;code&gt;=&lt;/code&gt; y la definición de la función, que utiliza el argumento de entrada en su cálculo.

Ahora podemos probar diferentes valores del radio y ''llamar'' a la función con ellos. Guarda el código anterior en un archivo, ábrelo en GHCi y prueba lo siguiente:

{{Haskell/GHCi|1=
*Main&gt; area 5
78.53981633974483
*Main&gt; area 3
28.274333882308138
*Main&gt; area 17
907.9202768874502
}}

Acabamos de ''llamar'' a la función con diferentes valores y hemos calculado las áreas de tres círculos distintos.

Matemáticamente, el cálculo del área puede representarse mediante &lt;math&gt;A(r) = \pi \cdot r ^ 2&lt;/math&gt;. Para calcular las áreas, escribiríamos &lt;math&gt;A(5) = 78.54&lt;/math&gt; o &lt;math&gt;A(3) = 28.27&lt;/math&gt;. Haskell también permite utilizar paréntesis, pero por convención suelen omitirse para que el código tenga menos símbolos y sea más legible.

Aun así, los paréntesis se utilizan para agrupar ''expresiones'' (cualquier código que devuelva un valor) que deben calcularse en conjunto. Observa cómo se interpretan de manera diferente las siguientes expresiones:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
5 * 3 + 2       -- 15 + 2 = 17 (la multiplicación se realiza antes que la suma)
5 * (3 + 2)     -- 5 * 5 = 25 (los paréntesis obligan a calcular primero la suma)
area 5 * 3      -- (area 5) * 3
area (5 * 3)    -- area 15
&lt;/syntaxhighlight&gt;

Del mismo modo que la multiplicación se realiza antes que la suma, observa que las aplicaciones de funciones en Haskell tienen una precedencia mayor que cualquier operador, ya sea &lt;code&gt;+&lt;/code&gt; o &lt;code&gt;*&lt;/code&gt;, por ejemplo.

== Evaluación de expresiones ==
¿Qué sucede exactamente cuando introducimos una expresión en GHCi? Después de pulsar «Enter», se evalúa. Esto significa que cada función se sustituye por su definición y se realizan los cálculos hasta que queda un único valor final. Por ejemplo, al ejecutar &lt;code&gt;area 5&lt;/code&gt;, sucede lo siguiente:

&lt;syntaxhighlight lang=haskell&gt;
area 5                     -- todas las apariciones de 'r' a la derecha se sustituyen por '5'
pi * 5 ^ 2                 -- 'pi' se sustituye por un valor aproximado
3.141592653589793 * 5 ^ 2  -- se realiza la operación de potenciación '5 ^ 2'
3.141592653589793 * 25     -- se realiza la operación de multiplicación
78.53981633974483          -- resultado final
&lt;/syntaxhighlight&gt;

Cuando utilizamos GHCi, el resultado de ''aplicar'' o ''llamar'' a la función, siguiendo el procedimiento anterior, aparece en la pantalla.

Veamos ahora algunas funciones más:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
duplicar   x     = 2 * x
cuadruplicar x = double (double x)
cuadrado x     = x * x
mitad   x     = x / 2
&lt;/syntaxhighlight&gt;

{{Haskell/Ejercicios|1=
* Explica cómo evaluaría GHCi &lt;code&gt;cuadruplicar 5&lt;/code&gt;.
* Define una función que reste 12 a la mitad de su argumento.
}}

== Parámetros múltiples ==
Las funciones también pueden tener más de un argumento. Por ejemplo, para calcular el área de un rectángulo necesitamos su longitud y su anchura:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
areaRectang a b = a * b
&lt;/syntaxhighlight&gt;

{{Haskell/GHCi|1=
*Main&gt; areaRectang 5 10
50
}}

Otro ejemplo es el área de un triángulo, &lt;math&gt;A = \frac{bh}{2}&lt;/math&gt;:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
areaTriang b h = (b * h) / 2
&lt;/syntaxhighlight&gt;

{{Haskell/GHCi|1=
*Main&gt; areaTriang 3 9
13.5
}}

Como puedes ver, los argumentos se separan mediante espacios. Por eso, a veces es necesario utilizar paréntesis para agrupar expresiones. Por ejemplo, no podemos escribir el cuádruple de un valor de la siguiente manera:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
cuadruple x = double double x     -- error
&lt;/syntaxhighlight&gt;

Esto aplicaría la función &lt;code&gt;double&lt;/code&gt; a dos argumentos: &lt;code&gt;double&lt;/code&gt; y &lt;code&gt;x&lt;/code&gt;. Sí es posible que las ''funciones sean argumentos de otras funciones'', como veremos más adelante, pero eso no es lo que queremos hacer aquí. Para que esta función funcione, necesitamos utilizar paréntesis:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
cuadruple x = double (double x)
&lt;/syntaxhighlight&gt;

Los argumentos siempre se pasan en el orden en que aparecen. Por ejemplo:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
menos x y = x - y
&lt;/syntaxhighlight&gt;

{{Haskell/GHCi|1=
*Main&gt; menos 10 5
5
*Main&gt; menos 5 10
-5
}}

Aquí, &lt;code&gt;menos 10 5&lt;/code&gt; evalúa la expresión &lt;code&gt;10 - 5&lt;/code&gt;, mientras que &lt;code&gt;menos 5 10&lt;/code&gt; evalúa &lt;code&gt;5 - 10&lt;/code&gt;, debido al cambio en el orden de los argumentos.

{{Haskell/Ejercicios|1=
* Escribe una función para calcular el volumen de una caja.
* ¿Aproximadamente cuántas piedras se utilizaron para construir las famosas pirámides de Guiza? Pista: tendrás que estimar el volumen de la pirámide y el volumen de cada bloque de piedra.
}}

== Combinación de funciones ==
Por supuesto, puedes utilizar otras funciones para definir las tuyas, del mismo modo que ya lo has hecho utilizando la suma, &lt;code&gt;+&lt;/code&gt;, o la multiplicación, &lt;code&gt;*&lt;/code&gt;. De hecho, los operadores también se definen como funciones en Haskell. Por ejemplo, para calcular el área de un cuadrado, podemos reutilizar la función que calcula el área de un rectángulo:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
areaRetang a b = a * b
areaCuad   l   = areaRetang l l
&lt;/syntaxhighlight&gt;

{{Haskell/GHCi|1=
*Main&gt; areaCuad 5
25
}}

Al fin y al cabo, un cuadrado es un rectángulo cuyos lados son iguales.

{{Haskell/Ejercicios|1=
* Escribe una función que calcule el volumen de un cilindro. El volumen de un cilindro es el área de su base, que es un círculo, multiplicada por la altura. Como ya has programado la función que calcula el área de un círculo en este capítulo, puedes reutilizarla aquí.
}}

== Definición de funciones locales ==
=== Uso de &lt;code&gt;where&lt;/code&gt; ===
Cuando definimos una función, a veces necesitamos calcular valores intermedios que son ''locales'' y se utilizan únicamente dentro de esa función. Considera la [[w:teorema de Herón|fórmula de Herón]]: &lt;math&gt;A = \sqrt{p(p-a)(p-b)(p-c)}&lt;/math&gt;, donde &lt;math&gt;p&lt;/math&gt; es la mitad del perímetro del triángulo. Este es el cálculo del área de un triángulo cuyos lados miden &lt;code&gt;a&lt;/code&gt;, &lt;code&gt;b&lt;/code&gt; y &lt;code&gt;c&lt;/code&gt;:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
heron a b c = sqrt (s * (s - a) * (s - b) * (s - c))
    where
    s = (a + b + c) / 2
&lt;/syntaxhighlight&gt;

La variable &lt;code&gt;s&lt;/code&gt; representa la mitad del perímetro. Sería tedioso y propenso a errores tener que escribir &lt;code&gt;(a + b + c)/2&lt;/code&gt; cada vez que necesitáramos este valor dentro de &lt;code&gt;herao&lt;/code&gt;. &lt;code&gt;sqrt&lt;/code&gt; calcula la raíz cuadrada de su argumento (recuerda que significa ''square root'' en inglés).

Escribir las definiciones por separado no funcionaría. Observa:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
heron a b c = sqrt (p * (p - a) * (p - b) * (p - c))
p = (a + b + c) / 2                                   -- a, b y c no están definidas aquí
&lt;/syntaxhighlight&gt;

El compilador señalaría que &lt;code&gt;a&lt;/code&gt;, &lt;code&gt;b&lt;/code&gt; y &lt;code&gt;c&lt;/code&gt; solo están disponibles en el lado derecho de &lt;code&gt;herao&lt;/code&gt;, mientras que la definición de &lt;code&gt;s&lt;/code&gt; no forma parte del lado derecho de &lt;code&gt;herao&lt;/code&gt;. Para incluirla allí, utilizamos la palabra clave &lt;code&gt;where&lt;/code&gt;.

Observa que tanto &lt;code&gt;where&lt;/code&gt; como la definición de &lt;code&gt;s&lt;/code&gt; están indentadas con cuatro espacios en blanco. Esto es importante para delimitar qué pertenece a cada bloque. Veamos otros ejemplos del uso de &lt;code&gt;where&lt;/code&gt;:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
areaTriangTrig  a b c = c * altura / 2   -- usando trigonometría
    where
    cosAlfa  = (b ^ 2 + c ^ 2 - a ^ 2) / (2 * b * c)
    sinAlfa  = sqrt (1 - cosAlfa ^ 2)
    altura   = b * sinAlfa
areaTriangHeron a b c = resultado        -- usa la fórmula de Herón
    where
    resultado = sqrt (p * (p - a) * (p - b) * (p - c))
    p         = (a + b + c) / 2
&lt;/syntaxhighlight&gt;

== Ámbito ==
Observa atentamente el ejemplo anterior: fíjate en que utilizamos las variables &lt;code&gt;a&lt;/code&gt;, &lt;code&gt;b&lt;/code&gt; y &lt;code&gt;c&lt;/code&gt; dos veces, en cada una de las funciones definidas. ¿Cómo es posible?

Considera el siguiente procedimiento en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; let r = 0
Prelude&gt; let area r = pi * r ^ 2
Prelude&gt; area 5
78.53981633974483
}}

Sería extraño que el resultado del área fuera &lt;code&gt;0&lt;/code&gt; debido a la definición anterior de &lt;code&gt;let r = 0&lt;/code&gt;. Esto no sucede porque, la segunda vez que escribimos &lt;code&gt;r&lt;/code&gt;, nos referimos a una &lt;code&gt;r&lt;/code&gt; ''diferente''. Puede parecer confuso, pero piensa en lo siguiente: muchas personas se llaman Juan y, aun así, en una situación en la que solo hay un Juan presente, podemos decir «Juan» sin ninguna confusión. En programación, esta noción de contexto se denomina ''[[w:Ámbito (informática)|ámbito]]''.

No profundizaremos por ahora en los detalles técnicos relacionados con el ámbito, pero ten presente que el valor de un parámetro es exactamente el que se pasa a la función, independientemente del nombre que le hayas dado al definirla. Por lo tanto, elegir nombres apropiados para las variables ayuda considerablemente a que los seres humanos puedan leer el código.

== Resumen ==
# Las variables almacenan valores, que pueden ser cualquier expresión en Haskell.
# Las variables no cambian sus valores dentro de un mismo ámbito.
# Las funciones son útiles para escribir programas reutilizables.
# Las funciones pueden aceptar más de un parámetro.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>obbj6z7ybxsbqvf86robrcw3hb5mzg4</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Introducción/Generalidades</title>
    <ns>0</ns>
    <id>64947</id>
    <redirect title="Matemáticas/Números/Racionales/Clasificación" />
    <revision>
      <id>436429</id>
      <parentid>435982</parentid>
      <timestamp>2026-10-13T23:18:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Clasificación]]</comment>
      <origin>436429</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="65" sha1="afxt7wgwjflyqc7fct82gktd2yf2u8p" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Clasificación]]</text>
      <sha1>afxt7wgwjflyqc7fct82gktd2yf2u8p</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Enteros</title>
    <ns>0</ns>
    <id>64953</id>
    <redirect title="Matemáticas/Números/Enteros" />
    <revision>
      <id>436430</id>
      <parentid>435994</parentid>
      <timestamp>2026-10-13T23:18:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Enteros]]</comment>
      <origin>436430</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="47" sha1="gtsp5v0pd41h1ncbj0wed1khkk6lpwt" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Enteros]]</text>
      <sha1>gtsp5v0pd41h1ncbj0wed1khkk6lpwt</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Enteros/División</title>
    <ns>0</ns>
    <id>64954</id>
    <redirect title="Matemáticas/Números/Enteros/División" />
    <revision>
      <id>436431</id>
      <parentid>435996</parentid>
      <timestamp>2026-10-13T23:18:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Enteros/División]]</comment>
      <origin>436431</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="57" sha1="h3bqj9kerc806wjiwodqshyvwvrhdoq" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Enteros/División]]</text>
      <sha1>h3bqj9kerc806wjiwodqshyvwvrhdoq</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Enteros/Introducción</title>
    <ns>0</ns>
    <id>64955</id>
    <redirect title="Matemáticas/Números/Enteros/Introducción" />
    <revision>
      <id>436432</id>
      <parentid>435998</parentid>
      <timestamp>2026-10-13T23:18:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Enteros/Introducción]]</comment>
      <origin>436432</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="61" sha1="bh94ws56edet82qs2p4kr6r1o7knpwk" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Enteros/Introducción]]</text>
      <sha1>bh94ws56edet82qs2p4kr6r1o7knpwk</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Enteros/Números Pares e Impares</title>
    <ns>0</ns>
    <id>64956</id>
    <redirect title="Matemáticas/Números/Enteros/Números Pares e Impares" />
    <revision>
      <id>436433</id>
      <parentid>436000</parentid>
      <timestamp>2026-10-13T23:18:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Enteros/Números Pares e Impares]]</comment>
      <origin>436433</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="72" sha1="g34aejbclwosp1a7dwzwwvv57dj6d7m" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Enteros/Números Pares e Impares]]</text>
      <sha1>g34aejbclwosp1a7dwzwwvv57dj6d7m</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Enteros/Operaciones Básicas</title>
    <ns>0</ns>
    <id>64957</id>
    <redirect title="Matemáticas/Números/Enteros/Operaciones Básicas" />
    <revision>
      <id>436434</id>
      <parentid>436002</parentid>
      <timestamp>2026-10-13T23:18:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Enteros/Operaciones Básicas]]</comment>
      <origin>436434</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="68" sha1="apkp65o0xz0mcwn6jf7wz8j0dljo84e" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Enteros/Operaciones Básicas]]</text>
      <sha1>apkp65o0xz0mcwn6jf7wz8j0dljo84e</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Enteros/Propiedades Aritméticas</title>
    <ns>0</ns>
    <id>64958</id>
    <redirect title="Matemáticas/Números/Enteros/Propiedades Aritméticas" />
    <revision>
      <id>436435</id>
      <parentid>436004</parentid>
      <timestamp>2026-10-13T23:19:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Enteros/Propiedades Aritméticas]]</comment>
      <origin>436435</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="72" sha1="ntkipsnimafl4eio6y5nfuoccjq5g6e" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Enteros/Propiedades Aritméticas]]</text>
      <sha1>ntkipsnimafl4eio6y5nfuoccjq5g6e</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Enteros/Propiedades Fundamentales</title>
    <ns>0</ns>
    <id>64959</id>
    <redirect title="Matemáticas/Números/Enteros/Propiedades Fundamentales" />
    <revision>
      <id>436436</id>
      <parentid>436006</parentid>
      <timestamp>2026-10-13T23:19:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Enteros/Propiedades Fundamentales]]</comment>
      <origin>436436</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="73" sha1="mqmm5ozrbh8c9n9xq84t4zunu52z760" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Enteros/Propiedades Fundamentales]]</text>
      <sha1>mqmm5ozrbh8c9n9xq84t4zunu52z760</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Enteros/Resta o Sustracción</title>
    <ns>0</ns>
    <id>64960</id>
    <redirect title="Matemáticas/Números/Enteros/Resta o Sustracción" />
    <revision>
      <id>436437</id>
      <parentid>436008</parentid>
      <timestamp>2026-10-13T23:19:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Enteros/Resta o Sustracción]]</comment>
      <origin>436437</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="68" sha1="75rgp4j7cbhsrug4j771o2583boyk6w" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Enteros/Resta o Sustracción]]</text>
      <sha1>75rgp4j7cbhsrug4j771o2583boyk6w</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Enteros/Valor Absoluto</title>
    <ns>0</ns>
    <id>64961</id>
    <redirect title="Matemáticas/Números/Enteros/Valor Absoluto" />
    <revision>
      <id>436438</id>
      <parentid>436010</parentid>
      <timestamp>2026-10-13T23:19:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Enteros/Valor Absoluto]]</comment>
      <origin>436438</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="62" sha1="fa2kqcx7s4ghjr6fqwlol1nj6jk3r9j" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Enteros/Valor Absoluto]]</text>
      <sha1>fa2kqcx7s4ghjr6fqwlol1nj6jk3r9j</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Enteros B</title>
    <ns>0</ns>
    <id>64962</id>
    <redirect title="Matemáticas/Números/Enteros/Números Enteros B" />
    <revision>
      <id>436439</id>
      <parentid>436012</parentid>
      <timestamp>2026-10-13T23:19:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Enteros/Números Enteros B]]</comment>
      <origin>436439</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="66" sha1="62gd0u4rt8ca0mubmngmpg8wzj414zy" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Enteros/Números Enteros B]]</text>
      <sha1>62gd0u4rt8ca0mubmngmpg8wzj414zy</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales</title>
    <ns>0</ns>
    <id>64963</id>
    <redirect title="Matemáticas/Números/Naturales" />
    <revision>
      <id>436440</id>
      <parentid>436014</parentid>
      <timestamp>2026-10-13T23:19:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales]]</comment>
      <origin>436440</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49" sha1="evnvilr6sz78d6yo5cpy20nbadanf20" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales]]</text>
      <sha1>evnvilr6sz78d6yo5cpy20nbadanf20</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/División</title>
    <ns>0</ns>
    <id>64964</id>
    <redirect title="Matemáticas/Números/Naturales/División" />
    <revision>
      <id>436441</id>
      <parentid>436016</parentid>
      <timestamp>2026-10-13T23:20:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/División]]</comment>
      <origin>436441</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="59" sha1="3wbsxegul0bucrgr8l8f4c502b5umj6" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/División]]</text>
      <sha1>3wbsxegul0bucrgr8l8f4c502b5umj6</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Introducción</title>
    <ns>0</ns>
    <id>64965</id>
    <redirect title="Matemáticas/Números/Naturales/Introducción" />
    <revision>
      <id>436442</id>
      <parentid>436018</parentid>
      <timestamp>2026-10-13T23:20:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Introducción]]</comment>
      <origin>436442</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="63" sha1="7tk5x4r18i2lwayjeltxat0eqi5caqt" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Introducción]]</text>
      <sha1>7tk5x4r18i2lwayjeltxat0eqi5caqt</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Menor o Mayor</title>
    <ns>0</ns>
    <id>64966</id>
    <redirect title="Matemáticas/Números/Naturales/Menor o Mayor" />
    <revision>
      <id>436443</id>
      <parentid>436020</parentid>
      <timestamp>2026-10-13T23:20:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Menor o Mayor]]</comment>
      <origin>436443</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="63" sha1="pj7vuf3g20r9vuxt4363csw6cuu7ata" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Menor o Mayor]]</text>
      <sha1>pj7vuf3g20r9vuxt4363csw6cuu7ata</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Máximo Común Divisor</title>
    <ns>0</ns>
    <id>64967</id>
    <redirect title="Matemáticas/Números/Naturales/Máximo Común Divisor" />
    <revision>
      <id>436444</id>
      <parentid>436022</parentid>
      <timestamp>2026-10-13T23:20:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Máximo Común Divisor]]</comment>
      <origin>436444</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="72" sha1="atvj2lsx7uzbs4ef0kax5clmjwijwyw" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Máximo Común Divisor]]</text>
      <sha1>atvj2lsx7uzbs4ef0kax5clmjwijwyw</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Método para encontrar el MCM y el MCD</title>
    <ns>0</ns>
    <id>64968</id>
    <redirect title="Matemáticas/Números/Naturales/MCM y MCD" />
    <revision>
      <id>436445</id>
      <parentid>436024</parentid>
      <timestamp>2026-10-13T23:20:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/MCM y MCD]]</comment>
      <origin>436445</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="59" sha1="bhxo13kxx8wrx05nzihwhe3shzp5dpv" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/MCM y MCD]]</text>
      <sha1>bhxo13kxx8wrx05nzihwhe3shzp5dpv</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Mínimo Común Múltiplo</title>
    <ns>0</ns>
    <id>64969</id>
    <redirect title="Matemáticas/Números/Naturales/Mínimo Común Múltiplo" />
    <revision>
      <id>436446</id>
      <parentid>436026</parentid>
      <timestamp>2026-10-13T23:20:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Mínimo Común Múltiplo]]</comment>
      <origin>436446</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="74" sha1="t6tf69vh7au3zbz0wxt4m2wx9ta7zxq" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Mínimo Común Múltiplo]]</text>
      <sha1>t6tf69vh7au3zbz0wxt4m2wx9ta7zxq</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Números Pares e Impares</title>
    <ns>0</ns>
    <id>64970</id>
    <redirect title="Matemáticas/Números/Naturales/Pares e Impares" />
    <revision>
      <id>436447</id>
      <parentid>436028</parentid>
      <timestamp>2026-10-13T23:21:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Pares e Impares]]</comment>
      <origin>436447</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="65" sha1="20kbbjvfjcvycbb6w50cyopfpgi39xi" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Pares e Impares]]</text>
      <sha1>20kbbjvfjcvycbb6w50cyopfpgi39xi</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Números Primos y Compuestos</title>
    <ns>0</ns>
    <id>64971</id>
    <redirect title="Matemáticas/Números/Naturales/Primos y Compuestos" />
    <revision>
      <id>436448</id>
      <parentid>436030</parentid>
      <timestamp>2026-10-13T23:21:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Primos y Compuestos]]</comment>
      <origin>436448</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="69" sha1="57sjh7zmrpku7enn9orlrdi7kgf37d8" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Primos y Compuestos]]</text>
      <sha1>57sjh7zmrpku7enn9orlrdi7kgf37d8</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Orden</title>
    <ns>0</ns>
    <id>64972</id>
    <redirect title="Matemáticas/Números/Naturales/Orden" />
    <revision>
      <id>436449</id>
      <parentid>436032</parentid>
      <timestamp>2026-10-13T23:21:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Orden]]</comment>
      <origin>436449</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="55" sha1="s81njond9pvoj09j4d6pzctruj7cotc" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Orden]]</text>
      <sha1>s81njond9pvoj09j4d6pzctruj7cotc</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Propiedades Aritméticas</title>
    <ns>0</ns>
    <id>64973</id>
    <redirect title="Matemáticas/Números/Naturales/Operaciones Combinadas" />
    <revision>
      <id>436450</id>
      <parentid>436034</parentid>
      <timestamp>2026-10-13T23:21:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Operaciones Combinadas]]</comment>
      <origin>436450</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="72" sha1="eey9bq656qg888e64fpogkud0jhwzst" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Operaciones Combinadas]]</text>
      <sha1>eey9bq656qg888e64fpogkud0jhwzst</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Propiedades básicas</title>
    <ns>0</ns>
    <id>64974</id>
    <redirect title="Matemáticas/Números/Naturales/Propiedades básicas" />
    <revision>
      <id>436451</id>
      <parentid>436036</parentid>
      <timestamp>2026-10-13T23:21:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Propiedades básicas]]</comment>
      <origin>436451</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="70" sha1="9p6rlbjrkuvxpat6tzdymwy52jctj1p" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Propiedades básicas]]</text>
      <sha1>9p6rlbjrkuvxpat6tzdymwy52jctj1p</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Propiedades de la Adición y Multiplicación</title>
    <ns>0</ns>
    <id>64975</id>
    <redirect title="Matemáticas/Números/Naturales/Propiedades de Adición y Multiplicación" />
    <revision>
      <id>436452</id>
      <parentid>436038</parentid>
      <timestamp>2026-10-13T23:21:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Propiedades de Adición y Multiplicación]]</comment>
      <origin>436452</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="91" sha1="q3j0pipkc8j6mkni59uglaqu9sms1m6" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Propiedades de Adición y Multiplicación]]</text>
      <sha1>q3j0pipkc8j6mkni59uglaqu9sms1m6</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales/Resta o Sustracción</title>
    <ns>0</ns>
    <id>64976</id>
    <redirect title="Matemáticas/Números/Naturales/Sustracción" />
    <revision>
      <id>436453</id>
      <parentid>436040</parentid>
      <timestamp>2026-10-13T23:22:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Naturales/Sustracción]]</comment>
      <origin>436453</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="62" sha1="n5r9m7lg9ns1k9edlapiz8x12663efx" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Naturales/Sustracción]]</text>
      <sha1>n5r9m7lg9ns1k9edlapiz8x12663efx</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Naturales 2</title>
    <ns>0</ns>
    <id>64977</id>
    <redirect title="Cursos/E M T/2º Administración - Matemáticas/Unidad 5" />
    <revision>
      <id>436454</id>
      <parentid>436042</parentid>
      <timestamp>2026-10-13T23:22:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Cursos/E M T/2º Administración - Matemáticas/Unidad 5]]</comment>
      <origin>436454</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="74" sha1="n9gyb79m0oe1clvkx2gmwn4ujkvmx1f" xml:space="preserve">#REDIRECCIÓN [[Cursos/E M T/2º Administración - Matemáticas/Unidad 5]]</text>
      <sha1>n9gyb79m0oe1clvkx2gmwn4ujkvmx1f</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales</title>
    <ns>0</ns>
    <id>64978</id>
    <redirect title="Matemáticas/Números/Racionales" />
    <revision>
      <id>436455</id>
      <parentid>436044</parentid>
      <timestamp>2026-10-13T23:22:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales]]</comment>
      <origin>436455</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="50" sha1="anu3nsn9zuhg1km8aeio2c354veqsxp" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales]]</text>
      <sha1>anu3nsn9zuhg1km8aeio2c354veqsxp</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Construcción</title>
    <ns>0</ns>
    <id>64979</id>
    <redirect title="Matemáticas/Números/Racionales/Construcción" />
    <revision>
      <id>436456</id>
      <parentid>436046</parentid>
      <timestamp>2026-10-13T23:22:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Construcción]]</comment>
      <origin>436456</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="64" sha1="76yrd0fpg0peo4xv1avaf26dg1ddqhb" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Construcción]]</text>
      <sha1>76yrd0fpg0peo4xv1avaf26dg1ddqhb</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Ecuaciones</title>
    <ns>0</ns>
    <id>64980</id>
    <redirect title="Matemáticas/Números/Racionales/Ecuaciones" />
    <revision>
      <id>436457</id>
      <parentid>436048</parentid>
      <timestamp>2026-10-13T23:22:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Ecuaciones]]</comment>
      <origin>436457</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="61" sha1="82u2fc1wjisfvvspktvlevc1ob3wgmj" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Ecuaciones]]</text>
      <sha1>82u2fc1wjisfvvspktvlevc1ob3wgmj</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Expresión decimal</title>
    <ns>0</ns>
    <id>64981</id>
    <redirect title="Matemáticas/Números/Racionales/Expresión decimal" />
    <revision>
      <id>436458</id>
      <parentid>436050</parentid>
      <timestamp>2026-10-13T23:22:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Expresión decimal]]</comment>
      <origin>436458</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="69" sha1="bw4lwk3oto07odz3yz1t83vv0vymgij" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Expresión decimal]]</text>
      <sha1>bw4lwk3oto07odz3yz1t83vv0vymgij</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Historia</title>
    <ns>0</ns>
    <id>64982</id>
    <redirect title="Matemáticas/Números/Racionales/Historia" />
    <revision>
      <id>436459</id>
      <parentid>436052</parentid>
      <timestamp>2026-10-13T23:23:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Historia]]</comment>
      <origin>436459</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="59" sha1="9putoklddipxavnap3ptwsn341dk8nh" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Historia]]</text>
      <sha1>9putoklddipxavnap3ptwsn341dk8nh</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Introducción</title>
    <ns>0</ns>
    <id>64983</id>
    <redirect title="Matemáticas/Números/Racionales/Introducción" />
    <revision>
      <id>436460</id>
      <parentid>436054</parentid>
      <timestamp>2026-10-13T23:23:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Introducción]]</comment>
      <origin>436460</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="64" sha1="b2cphtvxjk37vlyvgvipazsg3byht46" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Introducción]]</text>
      <sha1>b2cphtvxjk37vlyvgvipazsg3byht46</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Multiplicación</title>
    <ns>0</ns>
    <id>64984</id>
    <redirect title="Matemáticas/Números/Racionales/Multiplicación" />
    <revision>
      <id>436461</id>
      <parentid>436056</parentid>
      <timestamp>2026-10-13T23:23:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Multiplicación]]</comment>
      <origin>436461</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="66" sha1="2qvb7654m2p5ii5rr4k1qjt3noyjh8x" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Multiplicación]]</text>
      <sha1>2qvb7654m2p5ii5rr4k1qjt3noyjh8x</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Otras operaciones</title>
    <ns>0</ns>
    <id>64985</id>
    <redirect title="Matemáticas/Números/Racionales/Otras operaciones" />
    <revision>
      <id>436462</id>
      <parentid>436058</parentid>
      <timestamp>2026-10-13T23:23:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Otras operaciones]]</comment>
      <origin>436462</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="68" sha1="piczwgysp4vbda8rcnq8u0h9f83j39f" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Otras operaciones]]</text>
      <sha1>piczwgysp4vbda8rcnq8u0h9f83j39f</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Potencias</title>
    <ns>0</ns>
    <id>64986</id>
    <redirect title="Matemáticas/Números/Racionales/Potencias" />
    <revision>
      <id>436463</id>
      <parentid>436060</parentid>
      <timestamp>2026-10-13T23:23:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Potencias]]</comment>
      <origin>436463</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="60" sha1="9uiv47c6y5t6pi84oe8vbmo73fy5vyb" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Potencias]]</text>
      <sha1>9uiv47c6y5t6pi84oe8vbmo73fy5vyb</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Potencias/Ejercicios</title>
    <ns>0</ns>
    <id>64987</id>
    <redirect title="Matemáticas/Números/Racionales/Potencias/Ejercicios" />
    <revision>
      <id>436464</id>
      <parentid>436062</parentid>
      <timestamp>2026-10-13T23:23:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Potencias/Ejercicios]]</comment>
      <origin>436464</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="71" sha1="tlt1mxx6bb86aa8dp2koesdk5ormxpa" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Potencias/Ejercicios]]</text>
      <sha1>tlt1mxx6bb86aa8dp2koesdk5ormxpa</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Propiedades</title>
    <ns>0</ns>
    <id>64988</id>
    <redirect title="Matemáticas/Números/Racionales/Propiedades" />
    <revision>
      <id>436465</id>
      <parentid>436064</parentid>
      <timestamp>2026-10-13T23:24:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Propiedades]]</comment>
      <origin>436465</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="62" sha1="lz0lz8u6fxv6hdlp9nxp1qchj3ut0tl" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Propiedades]]</text>
      <sha1>lz0lz8u6fxv6hdlp9nxp1qchj3ut0tl</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Relaciones de equivalencia</title>
    <ns>0</ns>
    <id>64989</id>
    <redirect title="Matemáticas/Números/Racionales/Relaciones de equivalencia" />
    <revision>
      <id>436466</id>
      <parentid>436066</parentid>
      <timestamp>2026-10-13T23:24:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Relaciones de equivalencia]]</comment>
      <origin>436466</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="77" sha1="bqbg6u4gwa6pcztbnghdv3wudb19d5m" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Relaciones de equivalencia]]</text>
      <sha1>bqbg6u4gwa6pcztbnghdv3wudb19d5m</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Representación decimal</title>
    <ns>0</ns>
    <id>64990</id>
    <redirect title="Matemáticas/Números/Racionales/Representación decimal" />
    <revision>
      <id>436467</id>
      <parentid>436068</parentid>
      <timestamp>2026-10-13T23:24:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Representación decimal]]</comment>
      <origin>436467</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="74" sha1="h83kmqjhodm98p1tja1z7edmzh8yaj7" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Representación decimal]]</text>
      <sha1>h83kmqjhodm98p1tja1z7edmzh8yaj7</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Suma</title>
    <ns>0</ns>
    <id>64991</id>
    <redirect title="Matemáticas/Números/Racionales/Adición" />
    <revision>
      <id>436468</id>
      <parentid>436070</parentid>
      <timestamp>2026-10-13T23:24:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Adición]]</comment>
      <origin>436468</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="59" sha1="mvh4hhe2c7pe05lpduukkfs0byc3nzi" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Adición]]</text>
      <sha1>mvh4hhe2c7pe05lpduukkfs0byc3nzi</sha1>
    </revision>
  </page>
  <page>
    <title>Números y Operaciones/Números Racionales/Valor absoluto</title>
    <ns>0</ns>
    <id>64992</id>
    <redirect title="Matemáticas/Números/Racionales/Valor absoluto" />
    <revision>
      <id>436469</id>
      <parentid>436072</parentid>
      <timestamp>2026-10-13T23:24:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Matemáticas/Números/Racionales/Valor absoluto]]</comment>
      <origin>436469</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="65" sha1="7ib2sjafxjqc3qz1zdhmdfuosrqj3rc" xml:space="preserve">#REDIRECCIÓN [[Matemáticas/Números/Racionales/Valor absoluto]]</text>
      <sha1>7ib2sjafxjqc3qz1zdhmdfuosrqj3rc</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte</title>
    <ns>0</ns>
    <id>65012</id>
    <redirect title="Historia del arte" />
    <revision>
      <id>436399</id>
      <parentid>436147</parentid>
      <timestamp>2026-10-13T23:13:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte]]</comment>
      <origin>436399</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="35" sha1="ncq9jwjm4wv1z0h4x21r0balzz4gerw" xml:space="preserve">#REDIRECCIÓN [[Historia del arte]]</text>
      <sha1>ncq9jwjm4wv1z0h4x21r0balzz4gerw</sha1>
    </revision>
  </page>
  <page>
    <title>Discusión:Historia digital del Arte</title>
    <ns>1</ns>
    <id>65013</id>
    <redirect title="Discusión:Historia del arte" />
    <revision>
      <id>436470</id>
      <parentid>436149</parentid>
      <timestamp>2026-10-13T23:24:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Discusión:Historia del arte]]</comment>
      <origin>436470</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46" sha1="plfdggs6zn1g8hkqusiy8wfg69dfbss" xml:space="preserve">#REDIRECCIÓN [[Discusión:Historia del arte]]</text>
      <sha1>plfdggs6zn1g8hkqusiy8wfg69dfbss</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Arte del próximo Oriente/Mesopotamia</title>
    <ns>0</ns>
    <id>65014</id>
    <redirect title="Historia del arte/Arte del próximo Oriente/Mesopotamia" />
    <revision>
      <id>436400</id>
      <parentid>436151</parentid>
      <timestamp>2026-10-13T23:13:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Arte del próximo Oriente/Mesopotamia]]</comment>
      <origin>436400</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="73" sha1="tteu1uyfkq9ha8h0v535ju5s41eco0r" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Arte del próximo Oriente/Mesopotamia]]</text>
      <sha1>tteu1uyfkq9ha8h0v535ju5s41eco0r</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Arte egipcio</title>
    <ns>0</ns>
    <id>65015</id>
    <redirect title="Historia del arte/Arte egipcio" />
    <revision>
      <id>436401</id>
      <parentid>436153</parentid>
      <timestamp>2026-10-13T23:13:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Arte egipcio]]</comment>
      <origin>436401</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="48" sha1="qpnevtx317xpcsbkqjoh5d30rufiyyy" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Arte egipcio]]</text>
      <sha1>qpnevtx317xpcsbkqjoh5d30rufiyyy</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Arte egipcio/Época Amarniana</title>
    <ns>0</ns>
    <id>65016</id>
    <redirect title="Historia del arte/Arte egipcio/Época Amarniana" />
    <revision>
      <id>436402</id>
      <parentid>436155</parentid>
      <timestamp>2026-10-13T23:13:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Arte egipcio/Época Amarniana]]</comment>
      <origin>436402</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="65" sha1="qy13h3qvnvjea266zbp9cso8kvk40bs" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Arte egipcio/Época Amarniana]]</text>
      <sha1>qy13h3qvnvjea266zbp9cso8kvk40bs</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Arte griego</title>
    <ns>0</ns>
    <id>65017</id>
    <redirect title="Historia del arte/Arte griego" />
    <revision>
      <id>436403</id>
      <parentid>436157</parentid>
      <timestamp>2026-10-13T23:13:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Arte griego]]</comment>
      <origin>436403</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="47" sha1="8lyawhnubqd9uxbwqgokcerglmbv004" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Arte griego]]</text>
      <sha1>8lyawhnubqd9uxbwqgokcerglmbv004</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Arte gótico/ Origen y expansión del Arte gótico</title>
    <ns>0</ns>
    <id>65018</id>
    <redirect title="Historia del arte/Arte gótico/ Origen y expansión del Arte gótico" />
    <revision>
      <id>436404</id>
      <parentid>436159</parentid>
      <timestamp>2026-10-13T23:13:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Arte gótico/ Origen y expansión del Arte gótico]]</comment>
      <origin>436404</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="86" sha1="a54qbn9semvxv24jk7zavgptwducely" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Arte gótico/ Origen y expansión del Arte gótico]]</text>
      <sha1>a54qbn9semvxv24jk7zavgptwducely</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Arte gótico/ Realismo burgués en el siglo XV</title>
    <ns>0</ns>
    <id>65019</id>
    <redirect title="Historia del arte/Arte gótico/ Realismo burgués en el siglo XV" />
    <revision>
      <id>436405</id>
      <parentid>436161</parentid>
      <timestamp>2026-10-13T23:14:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Arte gótico/ Realismo burgués en el siglo XV]]</comment>
      <origin>436405</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="82" sha1="dv5w7x031dt31uq44o9jxjkwnb10fb7" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Arte gótico/ Realismo burgués en el siglo XV]]</text>
      <sha1>dv5w7x031dt31uq44o9jxjkwnb10fb7</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Arte islámico</title>
    <ns>0</ns>
    <id>65020</id>
    <redirect title="Historia del arte/Arte islámico" />
    <revision>
      <id>436406</id>
      <parentid>436163</parentid>
      <timestamp>2026-10-13T23:14:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Arte islámico]]</comment>
      <origin>436406</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="50" sha1="d2qfmfgy1ftblcmlv7mlafifaivsaov" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Arte islámico]]</text>
      <sha1>d2qfmfgy1ftblcmlv7mlafifaivsaov</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Arte roma</title>
    <ns>0</ns>
    <id>65021</id>
    <redirect title="Historia del arte/Arte roma" />
    <revision>
      <id>436407</id>
      <parentid>436165</parentid>
      <timestamp>2026-10-13T23:14:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Arte roma]]</comment>
      <origin>436407</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45" sha1="6bvnxc4jskocv0pz83x3xwjmtgows4i" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Arte roma]]</text>
      <sha1>6bvnxc4jskocv0pz83x3xwjmtgows4i</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Arte románico</title>
    <ns>0</ns>
    <id>65022</id>
    <redirect title="Historia del arte/Arte románico" />
    <revision>
      <id>436408</id>
      <parentid>436167</parentid>
      <timestamp>2026-10-13T23:14:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Arte románico]]</comment>
      <origin>436408</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="50" sha1="r1oe33wxetf8g88lutqbvw3k5riin9n" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Arte románico]]</text>
      <sha1>r1oe33wxetf8g88lutqbvw3k5riin9n</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Barroco</title>
    <ns>0</ns>
    <id>65023</id>
    <redirect title="Historia del arte/Barroco" />
    <revision>
      <id>436409</id>
      <parentid>436169</parentid>
      <timestamp>2026-10-13T23:14:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Barroco]]</comment>
      <origin>436409</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="43" sha1="gdai9gd1r8lm1n0kf5tvekis5jba8js" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Barroco]]</text>
      <sha1>gdai9gd1r8lm1n0kf5tvekis5jba8js</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Barroco tardio y Rococó</title>
    <ns>0</ns>
    <id>65024</id>
    <redirect title="Historia del arte/Barroco tardio y Rococó" />
    <revision>
      <id>436410</id>
      <parentid>436171</parentid>
      <timestamp>2026-10-13T23:14:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Barroco tardio y Rococó]]</comment>
      <origin>436410</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="60" sha1="8we35paum8rxe8ga9ponkgp03w8qluq" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Barroco tardio y Rococó]]</text>
      <sha1>8we35paum8rxe8ga9ponkgp03w8qluq</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Bibliografía</title>
    <ns>0</ns>
    <id>65025</id>
    <redirect title="Historia del arte/Bibliografía" />
    <revision>
      <id>436411</id>
      <parentid>436173</parentid>
      <timestamp>2026-10-13T23:15:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Bibliografía]]</comment>
      <origin>436411</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49" sha1="f01wsco5uacn8siq8pf19njyrbqkays" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Bibliografía]]</text>
      <sha1>f01wsco5uacn8siq8pf19njyrbqkays</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Conceptos elementales</title>
    <ns>0</ns>
    <id>65026</id>
    <redirect title="Historia del arte/Conceptos elementales" />
    <revision>
      <id>436412</id>
      <parentid>436175</parentid>
      <timestamp>2026-10-13T23:15:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Conceptos elementales]]</comment>
      <origin>436412</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="57" sha1="sorqp1auqkf439ezwxyj6mq2ihad3j8" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Conceptos elementales]]</text>
      <sha1>sorqp1auqkf439ezwxyj6mq2ihad3j8</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Impresionismo</title>
    <ns>0</ns>
    <id>65027</id>
    <redirect title="Historia del arte/Impresionismo" />
    <revision>
      <id>436413</id>
      <parentid>436177</parentid>
      <timestamp>2026-10-13T23:15:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Impresionismo]]</comment>
      <origin>436413</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49" sha1="rutzrbuzlfqv41asrg5uijdaqkmc0dt" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Impresionismo]]</text>
      <sha1>rutzrbuzlfqv41asrg5uijdaqkmc0dt</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Introducción</title>
    <ns>0</ns>
    <id>65028</id>
    <redirect title="Historia del arte/Introducción" />
    <revision>
      <id>436414</id>
      <parentid>436179</parentid>
      <timestamp>2026-10-13T23:15:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Introducción]]</comment>
      <origin>436414</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="49" sha1="1am0yc4r0kzdqpur423dhmnr03uwudb" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Introducción]]</text>
      <sha1>1am0yc4r0kzdqpur423dhmnr03uwudb</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Manierismo</title>
    <ns>0</ns>
    <id>65029</id>
    <redirect title="Historia del arte/Manierismo" />
    <revision>
      <id>436415</id>
      <parentid>436181</parentid>
      <timestamp>2026-10-13T23:15:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Manierismo]]</comment>
      <origin>436415</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46" sha1="hf456o9pjwis2f10li34nq5848lazor" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Manierismo]]</text>
      <sha1>hf456o9pjwis2f10li34nq5848lazor</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Neoclásico</title>
    <ns>0</ns>
    <id>65030</id>
    <redirect title="Historia del arte/Neoclásico" />
    <revision>
      <id>436416</id>
      <parentid>436183</parentid>
      <timestamp>2026-10-13T23:15:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Neoclásico]]</comment>
      <origin>436416</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="47" sha1="fy3ls12lzujj0ln29jtmane6obisl06" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Neoclásico]]</text>
      <sha1>fy3ls12lzujj0ln29jtmane6obisl06</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Origen del Arte moderno</title>
    <ns>0</ns>
    <id>65031</id>
    <redirect title="Historia del arte/Origen del Arte moderno" />
    <revision>
      <id>436417</id>
      <parentid>436185</parentid>
      <timestamp>2026-10-13T23:16:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Origen del Arte moderno]]</comment>
      <origin>436417</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="59" sha1="ozfgdlqrtnthl8zt4w1v4fufdvin34z" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Origen del Arte moderno]]</text>
      <sha1>ozfgdlqrtnthl8zt4w1v4fufdvin34z</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Renacimiento</title>
    <ns>0</ns>
    <id>65032</id>
    <redirect title="Historia del arte/Renacimiento" />
    <revision>
      <id>436418</id>
      <parentid>436187</parentid>
      <timestamp>2026-10-13T23:16:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Renacimiento]]</comment>
      <origin>436418</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="48" sha1="2o8qdj4clvqc2mzqoqvc3ydgo5mezz1" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Renacimiento]]</text>
      <sha1>2o8qdj4clvqc2mzqoqvc3ydgo5mezz1</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Renacimiento/ Cinquecento</title>
    <ns>0</ns>
    <id>65033</id>
    <redirect title="Historia del arte/Renacimiento/ Cinquecento" />
    <revision>
      <id>436419</id>
      <parentid>436189</parentid>
      <timestamp>2026-10-13T23:16:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Renacimiento/ Cinquecento]]</comment>
      <origin>436419</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="61" sha1="66b2nbho5z6u3u2psirzl17itt58svm" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Renacimiento/ Cinquecento]]</text>
      <sha1>66b2nbho5z6u3u2psirzl17itt58svm</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Renacimiento/ Quattrocento</title>
    <ns>0</ns>
    <id>65034</id>
    <redirect title="Historia del arte/Renacimiento/ Quattrocento" />
    <revision>
      <id>436420</id>
      <parentid>436191</parentid>
      <timestamp>2026-10-13T23:16:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Renacimiento/ Quattrocento]]</comment>
      <origin>436420</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="62" sha1="c0w5ybpl1k7ew89fttd7v33elhd0j7y" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Renacimiento/ Quattrocento]]</text>
      <sha1>c0w5ybpl1k7ew89fttd7v33elhd0j7y</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/Romanticismo</title>
    <ns>0</ns>
    <id>65035</id>
    <redirect title="Historia del arte/Romanticismo" />
    <revision>
      <id>436421</id>
      <parentid>436193</parentid>
      <timestamp>2026-10-13T23:16:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/Romanticismo]]</comment>
      <origin>436421</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="48" sha1="5ls2vfp78cs0mazumxfyrw064gcx8h7" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/Romanticismo]]</text>
      <sha1>5ls2vfp78cs0mazumxfyrw064gcx8h7</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/ Arte del próximo Oriente/ Arte cretense</title>
    <ns>0</ns>
    <id>65036</id>
    <redirect title="Historia del arte/ Arte del próximo Oriente/ Arte cretense" />
    <revision>
      <id>436422</id>
      <parentid>436195</parentid>
      <timestamp>2026-10-13T23:16:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/ Arte del próximo Oriente/ Arte cretense]]</comment>
      <origin>436422</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="77" sha1="8mu06piratfmac1bf0iu2cfmx4eaphu" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/ Arte del próximo Oriente/ Arte cretense]]</text>
      <sha1>8mu06piratfmac1bf0iu2cfmx4eaphu</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/ Arte egipcio/El imperio antiguo</title>
    <ns>0</ns>
    <id>65037</id>
    <redirect title="Historia del arte/ Arte egipcio/El imperio antiguo" />
    <revision>
      <id>436423</id>
      <parentid>436197</parentid>
      <timestamp>2026-10-13T23:17:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/ Arte egipcio/El imperio antiguo]]</comment>
      <origin>436423</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="68" sha1="2dshs1volaxpdruixmnowunla5m5hl0" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/ Arte egipcio/El imperio antiguo]]</text>
      <sha1>2dshs1volaxpdruixmnowunla5m5hl0</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/ Arte egipcio/El imperio medio</title>
    <ns>0</ns>
    <id>65038</id>
    <redirect title="Historia del arte/ Arte egipcio/El imperio medio" />
    <revision>
      <id>436424</id>
      <parentid>436199</parentid>
      <timestamp>2026-10-13T23:17:14Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/ Arte egipcio/El imperio medio]]</comment>
      <origin>436424</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="66" sha1="7zmylelezhslou6r0cpo3h1e4pcuyfl" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/ Arte egipcio/El imperio medio]]</text>
      <sha1>7zmylelezhslou6r0cpo3h1e4pcuyfl</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/ Arte gótico/ Pintura del Trecento</title>
    <ns>0</ns>
    <id>65039</id>
    <redirect title="Historia del arte/ Arte gótico/ Pintura del Trecento" />
    <revision>
      <id>436425</id>
      <parentid>436201</parentid>
      <timestamp>2026-10-13T23:17:24Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/ Arte gótico/ Pintura del Trecento]]</comment>
      <origin>436425</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="71" sha1="k3tpr7njg5sgjhi1gt9yocbfce8e7cw" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/ Arte gótico/ Pintura del Trecento]]</text>
      <sha1>k3tpr7njg5sgjhi1gt9yocbfce8e7cw</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/ El arte prehistórico</title>
    <ns>0</ns>
    <id>65040</id>
    <redirect title="Historia del arte/ El arte prehistórico" />
    <revision>
      <id>436426</id>
      <parentid>436203</parentid>
      <timestamp>2026-10-13T23:17:34Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/ El arte prehistórico]]</comment>
      <origin>436426</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="58" sha1="mdrdicka2c68finyuywc5zk9rfgu9jm" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/ El arte prehistórico]]</text>
      <sha1>mdrdicka2c68finyuywc5zk9rfgu9jm</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/ El arte prehistórico/ Neolitico</title>
    <ns>0</ns>
    <id>65041</id>
    <redirect title="Historia del arte/ El arte prehistórico/ Neolitico" />
    <revision>
      <id>436427</id>
      <parentid>436205</parentid>
      <timestamp>2026-10-13T23:17:44Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/ El arte prehistórico/ Neolitico]]</comment>
      <origin>436427</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="69" sha1="mzvhub45dyz6j7oj9mlhsgn2ffyu9zn" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/ El arte prehistórico/ Neolitico]]</text>
      <sha1>mzvhub45dyz6j7oj9mlhsgn2ffyu9zn</sha1>
    </revision>
  </page>
  <page>
    <title>Historia digital del Arte/ El arte prehistórico/ Paleolitico</title>
    <ns>0</ns>
    <id>65042</id>
    <redirect title="Historia del arte/ El arte prehistórico/ Paleolitico" />
    <revision>
      <id>436428</id>
      <parentid>436207</parentid>
      <timestamp>2026-10-13T23:17:54Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Historia del arte/ El arte prehistórico/ Paleolitico]]</comment>
      <origin>436428</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="71" sha1="4gy7zuq2h2nxln6ln7y4eqqr5ywhjjg" xml:space="preserve">#REDIRECCIÓN [[Historia del arte/ El arte prehistórico/ Paleolitico]]</text>
      <sha1>4gy7zuq2h2nxln6ln7y4eqqr5ywhjjg</sha1>
    </revision>
  </page>
  <page>
    <title>Discusión:Historia digital del Arte/ Arte gótico/ Pintura del Trecento</title>
    <ns>1</ns>
    <id>65043</id>
    <redirect title="Discusión:Historia del arte/ Arte gótico/ Pintura del Trecento" />
    <revision>
      <id>436471</id>
      <parentid>436209</parentid>
      <timestamp>2026-10-13T23:25:04Z</timestamp>
      <contributor>
        <username>MABot</username>
        <id>20834</id>
      </contributor>
      <minor />
      <comment>Robot: corrección de redirección doble a [[Discusión:Historia del arte/ Arte gótico/ Pintura del Trecento]]</comment>
      <origin>436471</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="82" sha1="l1jy4or21sg7treu64nbztvyafpikyw" xml:space="preserve">#REDIRECCIÓN [[Discusión:Historia del arte/ Arte gótico/ Pintura del Trecento]]</text>
      <sha1>l1jy4or21sg7treu64nbztvyafpikyw</sha1>
    </revision>
  </page>
  <page>
    <title>Haskell/Valores de verdad</title>
    <ns>0</ns>
    <id>65076</id>
    <revision>
      <id>436376</id>
      <parentid>436344</parentid>
      <timestamp>2026-10-13T16:45:27Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Guardas y where */</comment>
      <origin>436376</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="13998" sha1="pspr2hxhowd1h1t8xmdb107gv3dfbgc" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

== Igualdad y otras comparaciones ==
En el capítulo anterior, usamos signos de igualdad para definir variables y funciones en Haskell, como se muestra en el siguiente código:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
r = 5
&lt;/syntaxhighlight&gt;

Esto significa que, durante la evaluación del programa, todas las apariciones de &lt;code&gt;r&lt;/code&gt; se sustituyen por &lt;code&gt;5&lt;/code&gt; dentro del mismo ámbito. De manera similar, al evaluar

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
f x = x + 3
&lt;/syntaxhighlight&gt;

todas las apariciones de &lt;code&gt;f&lt;/code&gt; seguidas de un número (el argumento de &lt;code&gt;f&lt;/code&gt;) se sustituyen por ese valor más tres.

En Matemáticas, el signo de igualdad se usa de manera diferente. Consideremos el siguiente problema:

{{Haskell/Ejercicios|1=
Resuelve el siguiente problema: &lt;math&gt;x+3=5&lt;/math&gt;.
}}

En este caso, el problema no consiste en representar &lt;math&gt;5&lt;/math&gt; como si fuera &lt;math&gt;x+3&lt;/math&gt;, o viceversa. En realidad, tenemos una ''proposición'' que afirma que un número &lt;math&gt;x&lt;/math&gt;, al sumarle 3, da como resultado 5. Resolver la ecuación significa encontrar el valor de &lt;math&gt;x&lt;/math&gt;, si existe alguno, que haga verdadera la proposición. En este sencillo ejemplo, una simple manipulación algebraica nos muestra que &lt;math&gt;x=2&lt;/math&gt;, es decir, &lt;math&gt;2&lt;/math&gt; es el número que satisface la proposición, ya que &lt;math&gt;2+3=5&lt;/math&gt;.

Comparar valores para comprobar si son iguales resulta bastante útil en programación. De hecho, es algo muy elemental y necesario. En Haskell, estas pruebas se parecen bastante a una ecuación. Sin embargo, como el signo igual ya se utiliza para definir algo, Haskell emplea un signo de igualdad ''doble'', &lt;code&gt;==&lt;/code&gt;, para realizar comparaciones. Veamos:

{{Haskell/GHCi|1=
Prelude&gt; 2 + 3 == 5
True
}}

Aquí, GHCi devuelve &lt;code&gt;True&lt;/code&gt; (''verdadero'', en inglés) porque &lt;math&gt;2 + 3&lt;/math&gt; es igual a &lt;math&gt;5&lt;/math&gt;. ¿Y si la ecuación no fuera verdadera?

{{Haskell/GHCi|1=
Prelude&gt; 7 + 3 == 5
False
}}

El resultado es &lt;code&gt;False&lt;/code&gt; (''falso'', en inglés). Ahora vamos a utilizar la función &lt;code&gt;f&lt;/code&gt; que definimos al comienzo de este capítulo:

{{Haskell/GHCi|1=
Prelude&gt; let f x = x + 3
Prelude&gt; f 2 == 5
True
}}

Como era de esperar. Puesto que &lt;code&gt;f 2&lt;/code&gt; se evalúa como &lt;code&gt;2 + 3&lt;/code&gt;, cuyo resultado es &lt;code&gt;5&lt;/code&gt;, lo lógico es que &lt;code&gt;5 == 5&lt;/code&gt; devuelva &lt;code&gt;True&lt;/code&gt;.

También podemos comparar dos valores numéricos para averiguar cuál es mayor. Haskell dispone de varios operadores para estas pruebas: &lt;code&gt;&lt;&lt;/code&gt;, para ''menor que''; &lt;code&gt;&gt;&lt;/code&gt;, para ''mayor que''; &lt;code&gt;&lt;=&lt;/code&gt;, para ''menor o igual que''; y &lt;code&gt;&gt;=&lt;/code&gt;, para ''mayor o igual que''. Estas pruebas funcionan exactamente igual que &lt;code&gt;==&lt;/code&gt;, que significa ''igual a''. Por ejemplo, podríamos utilizar &lt;code&gt;&lt;&lt;/code&gt; junto con la función &lt;code&gt;area&lt;/code&gt; del capítulo anterior para comprobar si un círculo de cierto radio tiene un área menor que otro valor.

{{Haskell/GHCi|1=
Prelude&gt; let area r = pi * r ^ 2
Prelude&gt; area 5 &lt; 50
False
}}

== Valores booleanos ==
¿Qué sucede cuando GHCi tiene que determinar si estas comparaciones son verdaderas o falsas? Consideremos un caso diferente. Si introducimos una expresión aritmética en GHCi, esta se ''evalúa'' y el resultado numérico aparece en pantalla:

{{Haskell/GHCi|1=
Prelude&gt; 2 + 2
4
}}

Si sustituimos la expresión aritmética por su valor final en una comparación, sucede algo parecido:

{{Haskell/GHCi|1=
Prelude&gt; 2 == 2
True
}}

Mientras que el «4» devuelto en el primer caso representa el recuento de alguna cosa, «True» es un ''valor'' que representa la verdad de una determinada proposición. Estos valores se conocen como '''booleanos'''.&lt;ref group=nota&gt;Este término se eligió en homenaje al matemático británico [[w:George Boole|George Boole]].&lt;/ref&gt; Naturalmente, solo hay dos valores posibles, que ya se nos han presentado: &lt;code&gt;True&lt;/code&gt; y &lt;code&gt;False&lt;/code&gt;.

== Introducción a los tipos de datos ==
&lt;code&gt;True&lt;/code&gt; y &lt;code&gt;False&lt;/code&gt; son valores reales, no una simple analogía. En Haskell, los valores booleanos tienen el mismo ''estatus'' que los valores numéricos, y podemos manipularlos de manera similar. Veamos un ejemplo sencillo:

{{Haskell/GHCi|1=
Prelude&gt; True == True
True
Prelude&gt; True == False
False
}}

En efecto, &lt;code&gt;True&lt;/code&gt; es igual a &lt;code&gt;True&lt;/code&gt;, y &lt;code&gt;True&lt;/code&gt; no es igual a &lt;code&gt;False&lt;/code&gt;. Ahora bien, ¿es posible determinar si &lt;code&gt;2&lt;/code&gt; es igual a &lt;code&gt;True&lt;/code&gt;?

{{Haskell/GHCi|1=
Prelude&gt; 2 == True

&lt;interactive&gt;:1:0:
    No instance for (Num Bool)
      arising from the literal ‘2’ at &lt;interactive&gt;:1:0
    Possible fix: add an instance declaration for (Num Bool)
    In the first argument of ‘(==)’, namely ‘2’
    In the expression: 2 == True
    In an equation for ‘it’: it = 2 == True
}}

El compilador produce un error. En realidad, la pregunta original ni siquiera tiene sentido. No se puede comparar un número con algo que no es un número, ni un valor booleano con algo que no es booleano. Haskell incorpora esta noción en el propio lenguaje, y el mensaje de error anterior, aunque es largo y un poco intimidante, expresa precisamente eso: a la izquierda de &lt;code&gt;==&lt;/code&gt; hay un número (&lt;code&gt;Num&lt;/code&gt;), por lo que se esperaba también un número a la derecha. Sin embargo, un valor booleano (&lt;code&gt;Bool&lt;/code&gt;) no es un número, de modo que la prueba de igualdad falla.

Queda claro, entonces, que los valores se agrupan en '''tipos''', que establecen los límites de lo que podemos o no hacer con ellos. &lt;code&gt;True&lt;/code&gt; y &lt;code&gt;False&lt;/code&gt; son valores del tipo &lt;code&gt;Bool&lt;/code&gt;. El caso de &lt;code&gt;2&lt;/code&gt; es algo más complicado, porque en informática existen varios tipos de números, al igual que en Matemáticas, aunque no sean equivalentes. Pero, en definitiva, sigue siendo un dato numérico (&lt;code&gt;Num&lt;/code&gt;). En general, esta característica restrictiva resulta muy valiosa, porque podemos aprovecharla para controlar el comportamiento de nuestros programas y establecer reglas que impidan utilizarlos con tipos de datos que ''no tienen sentido''. De este modo, garantizamos el funcionamiento correcto de lo que desarrollamos. Volveremos a tratar los tipos más adelante, ya que constituyen una parte importante del lenguaje Haskell.

== Operadores infijos ==
Una prueba de igualdad, como &lt;code&gt;2 == 2&lt;/code&gt;, también es una expresión, al igual que una operación aritmética, como &lt;code&gt;2 + 2&lt;/code&gt;. Ambos casos se evalúan básicamente de la misma manera. Cuando escribimos &lt;code&gt;2 == 2&lt;/code&gt; en una sesión de GHCi, este «responde» con &lt;code&gt;True&lt;/code&gt;, porque simplemente ha evaluado la expresión. En realidad, el operador &lt;code&gt;==&lt;/code&gt; es una función de dos argumentos (el de la izquierda y el de la derecha de la igualdad). Sin embargo, su uso es diferente: Haskell permite escribir las funciones de dos argumentos como ''operadores infijos'', es decir, situados ''entre'' sus dos argumentos. Cuando el nombre de una función está formado por caracteres no alfanuméricos (&lt;code&gt;==&lt;/code&gt;, por ejemplo), utilizarla como operador infijo es la forma más habitual. Si queremos utilizarla de la manera convencional, es decir, como un ''operador prefijo'' (con el nombre de la función antes de los argumentos), debemos encerrarla entre paréntesis. Veamos:

{{Haskell/GHCi|1=
Prelude&gt; 4 + 9 == 13
True
Prelude&gt; (==) (4 + 9) 13
True
}}

También es posible transformar un valor booleano en otro mediante la ''negación''. &lt;code&gt;not&lt;/code&gt; es la función de negación: transforma &lt;code&gt;True&lt;/code&gt; en &lt;code&gt;False&lt;/code&gt;, y &lt;code&gt;False&lt;/code&gt; en &lt;code&gt;True&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; not (5 * 2 == 10)
False
}}

Haskell ya dispone del operador de desigualdad: &lt;code&gt;/=&lt;/code&gt;, que significa ''no es igual a''. Sin embargo, podríamos definirlo fácilmente mediante &lt;code&gt;not&lt;/code&gt; y &lt;code&gt;==&lt;/code&gt;:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
x /= y = not (x == y)
&lt;/syntaxhighlight&gt;

Observa que podemos utilizar la notación de operadores infijos incluso al definirlos. Además, un operador puede definirse a partir de cualquier símbolo [[w:ASCII|ASCII]].

=== Otras operaciones booleanas ===
Existen otras operaciones booleanas muy útiles y necesarias: ''o'' e ''y''.

La operación ''A o B'' da como resultado verdadero si ''A'', ''B'' o ambos son verdaderos. En Haskell se representa mediante el operador &lt;code&gt;(||)&lt;/code&gt;:

{{Haskell/GHCi|1=
Prelude&gt; True {{!!}} True
True
Prelude&gt; True {{!!}} False
True
Prelude&gt; False {{!!}} True
True
Prelude&gt; False {{!!}} False
False
}}

La operación ''A y B'' da como resultado verdadero si ''A'' y ''B'' son verdaderos. En Haskell se representa mediante el operador &lt;code&gt;(&amp;&amp;)&lt;/code&gt;:

{{Haskell/GHCi|1=
Prelude&gt; True &amp;&amp; True
True
Prelude&gt; True &amp;&amp; False
False
Prelude&gt; False &amp;&amp; True
False
Prelude&gt; False &amp;&amp; False
False
}}

== Guardas ==
Los programas escritos en Haskell suelen utilizar operadores booleanos mediante una sintaxis muy cómoda y abreviada. Cuando una misma lógica se expresa con una sintaxis diferente, hablamos de [[w:Azúcar sintáctico|''azúcar sintáctico'']]. Esto significa que el código resulta más «agradable al paladar humano». Conviene recordar este término, porque aparece con frecuencia en los materiales sobre Haskell.

Uno de estos «azúcares» son las ''guardas'', que utilizan valores booleanos para facilitar la implementación de funciones de una manera muy sencilla. Primero, vamos a implementar la función de valor absoluto para números reales, también llamada [[w:Función modular|función modular o módulo]]. Su definición matemática establece que, si un número es positivo, su módulo es el propio número; si es negativo, su módulo es su opuesto, es decir, cero menos ese número.

&lt;math&gt;\text{abs}(x) = |x| = \begin{cases} x, &amp; \mbox{si } x \ge 0 \\ -x, &amp; \mbox{si } x &lt; 0. \end{cases} &lt;/math&gt;

En esta función, la expresión utilizada para calcular &lt;math&gt;|x|&lt;/math&gt; depende del propio valor de &lt;math&gt;x&lt;/math&gt;. Si &lt;math&gt;x \ge 0&lt;/math&gt; es verdadero, utilizamos la primera expresión; si es falso, utilizamos la segunda. Para expresar este proceso de decisión en Haskell, empleamos guardas. La función quedaría así:&lt;ref group=nota&gt;Esta función ya está disponible en las bibliotecas estándar de Haskell con el nombre &lt;code&gt;abs&lt;/code&gt;. No es necesario volver a implementarla.&lt;/ref&gt;

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
absoluto x
    | x &lt; 0     = 0 - x
    | otherwise = x
&lt;/syntaxhighlight&gt;

Es interesante observar que el código anterior se parece bastante a la definición matemática. Veámoslo por partes:

* Comenzamos con una definición normal de una función. Primero escribimos el nombre, &lt;code&gt;absoluto&lt;/code&gt;, y después especificamos la cantidad de argumentos que acepta: &lt;code&gt;x&lt;/code&gt;.

* En lugar de escribir el signo &lt;code&gt;=&lt;/code&gt; y comenzar la definición, escribimos dos alternativas de comportamiento justo debajo.&lt;ref group=nota&gt;En realidad, podríamos escribirlo todo en una sola línea, como &lt;code&gt;f x | caso 1 | caso 2&lt;/code&gt;, pero siempre es preferible dividir el código en varias líneas para facilitar la lectura.&lt;/ref&gt; Estas alternativas son las que llamamos ''guardas''. Debemos recordar que la indentación (los espacios en blanco antes de &lt;code&gt;|&lt;/code&gt;) no es opcional: sirve para indicar que las guardas pertenecen al ámbito de la definición de &lt;code&gt;absoluto&lt;/code&gt;.

* Cada guarda comienza con una barra vertical, &lt;code&gt;|&lt;/code&gt;. Después de ella, escribimos una expresión que dé como resultado un valor booleano, también llamada condición booleana o ''predicado''. A continuación, aparece el resto de la definición, que comienza con &lt;code&gt;=&lt;/code&gt;. La definición indicada en una guarda solo se evaluará si su predicado resulta ser &lt;code&gt;True&lt;/code&gt;.

* El caso de &lt;code&gt;otherwise&lt;/code&gt; se evalúa cuando ninguna de las condiciones anteriores es verdadera. En este ejemplo, si &lt;code&gt;x&lt;/code&gt; no es menor que cero, entonces necesariamente es mayor o igual que cero. Por tanto, el predicado de la última guarda podría ser &lt;code&gt;x &gt;= 0&lt;/code&gt;, pero lo habitual es utilizar &lt;code&gt;otherwise&lt;/code&gt; para abarcar todos los casos que no se hayan contemplado en las guardas anteriores.

{{nota|No hay nada mágico detrás de &lt;code&gt;otherwise&lt;/code&gt;. En realidad, se define simplemente como &lt;code&gt;otherwise {{=}} True&lt;/code&gt;. Esto significa que, siempre que se evalúe &lt;code&gt;otherwise&lt;/code&gt;, devolverá &lt;code&gt;True&lt;/code&gt; y, por tanto, se ejecutará la definición indicada en su guarda.}}

Observa que escribimos &lt;code&gt;0 - x&lt;/code&gt; en lugar de &lt;code&gt;-x&lt;/code&gt;. Esto se debe a que &lt;code&gt;-&lt;/code&gt; ''no es'' una función de un argumento que devuelva &lt;code&gt;0 - x&lt;/code&gt;. En realidad, se trata de una abreviatura sintáctica. Aunque resulta muy útil, suele causar conflictos cuando se utiliza junto con la función &lt;code&gt;(-)&lt;/code&gt;, que es el operador de resta. Haz una prueba en GHCi: calcula 3 menos -4 sin utilizar paréntesis. Para evitar este tipo de problemas, hemos decidido escribir explícitamente &lt;code&gt;0 - x&lt;/code&gt;.

== Guardas y &lt;code&gt;where&lt;/code&gt; ==
Es bastante habitual utilizar &lt;code&gt;where&lt;/code&gt; dentro de una función con guardas. Por ejemplo, para determinar cuántas soluciones reales tiene una [[w:Ecuación cuadrática|ecuación de segundo grado]] de la forma &lt;math&gt;ax^2+bx+c=0&lt;/math&gt;, debemos calcular su discriminante, &lt;math&gt;\Delta = b^2 - 4ac&lt;/math&gt;. Si es mayor que cero, hay dos raíces reales; si es igual a cero, hay una; y si es menor que cero, no hay ninguna. Una función de Haskell llamada &lt;code&gt;numSolsReais&lt;/code&gt;, que calcule esta cantidad, podría escribirse así:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
numSolsReales a b c
    | delta &gt; 0  = 2
    | delta == 0 = 1
    | otherwise = 0
        where
        delta = b^2 - 4*a*c
&lt;/syntaxhighlight&gt;

== Notas ==
&lt;references group=nota/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>pspr2hxhowd1h1t8xmdb107gv3dfbgc</sha1>
    </revision>
    <revision>
      <id>436377</id>
      <parentid>436376</parentid>
      <timestamp>2026-10-13T16:45:50Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Guardas y where */</comment>
      <origin>436377</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="13999" sha1="jp0gon7se8yihj1adkfl2z4aa7f0pzj" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

== Igualdad y otras comparaciones ==
En el capítulo anterior, usamos signos de igualdad para definir variables y funciones en Haskell, como se muestra en el siguiente código:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
r = 5
&lt;/syntaxhighlight&gt;

Esto significa que, durante la evaluación del programa, todas las apariciones de &lt;code&gt;r&lt;/code&gt; se sustituyen por &lt;code&gt;5&lt;/code&gt; dentro del mismo ámbito. De manera similar, al evaluar

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
f x = x + 3
&lt;/syntaxhighlight&gt;

todas las apariciones de &lt;code&gt;f&lt;/code&gt; seguidas de un número (el argumento de &lt;code&gt;f&lt;/code&gt;) se sustituyen por ese valor más tres.

En Matemáticas, el signo de igualdad se usa de manera diferente. Consideremos el siguiente problema:

{{Haskell/Ejercicios|1=
Resuelve el siguiente problema: &lt;math&gt;x+3=5&lt;/math&gt;.
}}

En este caso, el problema no consiste en representar &lt;math&gt;5&lt;/math&gt; como si fuera &lt;math&gt;x+3&lt;/math&gt;, o viceversa. En realidad, tenemos una ''proposición'' que afirma que un número &lt;math&gt;x&lt;/math&gt;, al sumarle 3, da como resultado 5. Resolver la ecuación significa encontrar el valor de &lt;math&gt;x&lt;/math&gt;, si existe alguno, que haga verdadera la proposición. En este sencillo ejemplo, una simple manipulación algebraica nos muestra que &lt;math&gt;x=2&lt;/math&gt;, es decir, &lt;math&gt;2&lt;/math&gt; es el número que satisface la proposición, ya que &lt;math&gt;2+3=5&lt;/math&gt;.

Comparar valores para comprobar si son iguales resulta bastante útil en programación. De hecho, es algo muy elemental y necesario. En Haskell, estas pruebas se parecen bastante a una ecuación. Sin embargo, como el signo igual ya se utiliza para definir algo, Haskell emplea un signo de igualdad ''doble'', &lt;code&gt;==&lt;/code&gt;, para realizar comparaciones. Veamos:

{{Haskell/GHCi|1=
Prelude&gt; 2 + 3 == 5
True
}}

Aquí, GHCi devuelve &lt;code&gt;True&lt;/code&gt; (''verdadero'', en inglés) porque &lt;math&gt;2 + 3&lt;/math&gt; es igual a &lt;math&gt;5&lt;/math&gt;. ¿Y si la ecuación no fuera verdadera?

{{Haskell/GHCi|1=
Prelude&gt; 7 + 3 == 5
False
}}

El resultado es &lt;code&gt;False&lt;/code&gt; (''falso'', en inglés). Ahora vamos a utilizar la función &lt;code&gt;f&lt;/code&gt; que definimos al comienzo de este capítulo:

{{Haskell/GHCi|1=
Prelude&gt; let f x = x + 3
Prelude&gt; f 2 == 5
True
}}

Como era de esperar. Puesto que &lt;code&gt;f 2&lt;/code&gt; se evalúa como &lt;code&gt;2 + 3&lt;/code&gt;, cuyo resultado es &lt;code&gt;5&lt;/code&gt;, lo lógico es que &lt;code&gt;5 == 5&lt;/code&gt; devuelva &lt;code&gt;True&lt;/code&gt;.

También podemos comparar dos valores numéricos para averiguar cuál es mayor. Haskell dispone de varios operadores para estas pruebas: &lt;code&gt;&lt;&lt;/code&gt;, para ''menor que''; &lt;code&gt;&gt;&lt;/code&gt;, para ''mayor que''; &lt;code&gt;&lt;=&lt;/code&gt;, para ''menor o igual que''; y &lt;code&gt;&gt;=&lt;/code&gt;, para ''mayor o igual que''. Estas pruebas funcionan exactamente igual que &lt;code&gt;==&lt;/code&gt;, que significa ''igual a''. Por ejemplo, podríamos utilizar &lt;code&gt;&lt;&lt;/code&gt; junto con la función &lt;code&gt;area&lt;/code&gt; del capítulo anterior para comprobar si un círculo de cierto radio tiene un área menor que otro valor.

{{Haskell/GHCi|1=
Prelude&gt; let area r = pi * r ^ 2
Prelude&gt; area 5 &lt; 50
False
}}

== Valores booleanos ==
¿Qué sucede cuando GHCi tiene que determinar si estas comparaciones son verdaderas o falsas? Consideremos un caso diferente. Si introducimos una expresión aritmética en GHCi, esta se ''evalúa'' y el resultado numérico aparece en pantalla:

{{Haskell/GHCi|1=
Prelude&gt; 2 + 2
4
}}

Si sustituimos la expresión aritmética por su valor final en una comparación, sucede algo parecido:

{{Haskell/GHCi|1=
Prelude&gt; 2 == 2
True
}}

Mientras que el «4» devuelto en el primer caso representa el recuento de alguna cosa, «True» es un ''valor'' que representa la verdad de una determinada proposición. Estos valores se conocen como '''booleanos'''.&lt;ref group=nota&gt;Este término se eligió en homenaje al matemático británico [[w:George Boole|George Boole]].&lt;/ref&gt; Naturalmente, solo hay dos valores posibles, que ya se nos han presentado: &lt;code&gt;True&lt;/code&gt; y &lt;code&gt;False&lt;/code&gt;.

== Introducción a los tipos de datos ==
&lt;code&gt;True&lt;/code&gt; y &lt;code&gt;False&lt;/code&gt; son valores reales, no una simple analogía. En Haskell, los valores booleanos tienen el mismo ''estatus'' que los valores numéricos, y podemos manipularlos de manera similar. Veamos un ejemplo sencillo:

{{Haskell/GHCi|1=
Prelude&gt; True == True
True
Prelude&gt; True == False
False
}}

En efecto, &lt;code&gt;True&lt;/code&gt; es igual a &lt;code&gt;True&lt;/code&gt;, y &lt;code&gt;True&lt;/code&gt; no es igual a &lt;code&gt;False&lt;/code&gt;. Ahora bien, ¿es posible determinar si &lt;code&gt;2&lt;/code&gt; es igual a &lt;code&gt;True&lt;/code&gt;?

{{Haskell/GHCi|1=
Prelude&gt; 2 == True

&lt;interactive&gt;:1:0:
    No instance for (Num Bool)
      arising from the literal ‘2’ at &lt;interactive&gt;:1:0
    Possible fix: add an instance declaration for (Num Bool)
    In the first argument of ‘(==)’, namely ‘2’
    In the expression: 2 == True
    In an equation for ‘it’: it = 2 == True
}}

El compilador produce un error. En realidad, la pregunta original ni siquiera tiene sentido. No se puede comparar un número con algo que no es un número, ni un valor booleano con algo que no es booleano. Haskell incorpora esta noción en el propio lenguaje, y el mensaje de error anterior, aunque es largo y un poco intimidante, expresa precisamente eso: a la izquierda de &lt;code&gt;==&lt;/code&gt; hay un número (&lt;code&gt;Num&lt;/code&gt;), por lo que se esperaba también un número a la derecha. Sin embargo, un valor booleano (&lt;code&gt;Bool&lt;/code&gt;) no es un número, de modo que la prueba de igualdad falla.

Queda claro, entonces, que los valores se agrupan en '''tipos''', que establecen los límites de lo que podemos o no hacer con ellos. &lt;code&gt;True&lt;/code&gt; y &lt;code&gt;False&lt;/code&gt; son valores del tipo &lt;code&gt;Bool&lt;/code&gt;. El caso de &lt;code&gt;2&lt;/code&gt; es algo más complicado, porque en informática existen varios tipos de números, al igual que en Matemáticas, aunque no sean equivalentes. Pero, en definitiva, sigue siendo un dato numérico (&lt;code&gt;Num&lt;/code&gt;). En general, esta característica restrictiva resulta muy valiosa, porque podemos aprovecharla para controlar el comportamiento de nuestros programas y establecer reglas que impidan utilizarlos con tipos de datos que ''no tienen sentido''. De este modo, garantizamos el funcionamiento correcto de lo que desarrollamos. Volveremos a tratar los tipos más adelante, ya que constituyen una parte importante del lenguaje Haskell.

== Operadores infijos ==
Una prueba de igualdad, como &lt;code&gt;2 == 2&lt;/code&gt;, también es una expresión, al igual que una operación aritmética, como &lt;code&gt;2 + 2&lt;/code&gt;. Ambos casos se evalúan básicamente de la misma manera. Cuando escribimos &lt;code&gt;2 == 2&lt;/code&gt; en una sesión de GHCi, este «responde» con &lt;code&gt;True&lt;/code&gt;, porque simplemente ha evaluado la expresión. En realidad, el operador &lt;code&gt;==&lt;/code&gt; es una función de dos argumentos (el de la izquierda y el de la derecha de la igualdad). Sin embargo, su uso es diferente: Haskell permite escribir las funciones de dos argumentos como ''operadores infijos'', es decir, situados ''entre'' sus dos argumentos. Cuando el nombre de una función está formado por caracteres no alfanuméricos (&lt;code&gt;==&lt;/code&gt;, por ejemplo), utilizarla como operador infijo es la forma más habitual. Si queremos utilizarla de la manera convencional, es decir, como un ''operador prefijo'' (con el nombre de la función antes de los argumentos), debemos encerrarla entre paréntesis. Veamos:

{{Haskell/GHCi|1=
Prelude&gt; 4 + 9 == 13
True
Prelude&gt; (==) (4 + 9) 13
True
}}

También es posible transformar un valor booleano en otro mediante la ''negación''. &lt;code&gt;not&lt;/code&gt; es la función de negación: transforma &lt;code&gt;True&lt;/code&gt; en &lt;code&gt;False&lt;/code&gt;, y &lt;code&gt;False&lt;/code&gt; en &lt;code&gt;True&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; not (5 * 2 == 10)
False
}}

Haskell ya dispone del operador de desigualdad: &lt;code&gt;/=&lt;/code&gt;, que significa ''no es igual a''. Sin embargo, podríamos definirlo fácilmente mediante &lt;code&gt;not&lt;/code&gt; y &lt;code&gt;==&lt;/code&gt;:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
x /= y = not (x == y)
&lt;/syntaxhighlight&gt;

Observa que podemos utilizar la notación de operadores infijos incluso al definirlos. Además, un operador puede definirse a partir de cualquier símbolo [[w:ASCII|ASCII]].

=== Otras operaciones booleanas ===
Existen otras operaciones booleanas muy útiles y necesarias: ''o'' e ''y''.

La operación ''A o B'' da como resultado verdadero si ''A'', ''B'' o ambos son verdaderos. En Haskell se representa mediante el operador &lt;code&gt;(||)&lt;/code&gt;:

{{Haskell/GHCi|1=
Prelude&gt; True {{!!}} True
True
Prelude&gt; True {{!!}} False
True
Prelude&gt; False {{!!}} True
True
Prelude&gt; False {{!!}} False
False
}}

La operación ''A y B'' da como resultado verdadero si ''A'' y ''B'' son verdaderos. En Haskell se representa mediante el operador &lt;code&gt;(&amp;&amp;)&lt;/code&gt;:

{{Haskell/GHCi|1=
Prelude&gt; True &amp;&amp; True
True
Prelude&gt; True &amp;&amp; False
False
Prelude&gt; False &amp;&amp; True
False
Prelude&gt; False &amp;&amp; False
False
}}

== Guardas ==
Los programas escritos en Haskell suelen utilizar operadores booleanos mediante una sintaxis muy cómoda y abreviada. Cuando una misma lógica se expresa con una sintaxis diferente, hablamos de [[w:Azúcar sintáctico|''azúcar sintáctico'']]. Esto significa que el código resulta más «agradable al paladar humano». Conviene recordar este término, porque aparece con frecuencia en los materiales sobre Haskell.

Uno de estos «azúcares» son las ''guardas'', que utilizan valores booleanos para facilitar la implementación de funciones de una manera muy sencilla. Primero, vamos a implementar la función de valor absoluto para números reales, también llamada [[w:Función modular|función modular o módulo]]. Su definición matemática establece que, si un número es positivo, su módulo es el propio número; si es negativo, su módulo es su opuesto, es decir, cero menos ese número.

&lt;math&gt;\text{abs}(x) = |x| = \begin{cases} x, &amp; \mbox{si } x \ge 0 \\ -x, &amp; \mbox{si } x &lt; 0. \end{cases} &lt;/math&gt;

En esta función, la expresión utilizada para calcular &lt;math&gt;|x|&lt;/math&gt; depende del propio valor de &lt;math&gt;x&lt;/math&gt;. Si &lt;math&gt;x \ge 0&lt;/math&gt; es verdadero, utilizamos la primera expresión; si es falso, utilizamos la segunda. Para expresar este proceso de decisión en Haskell, empleamos guardas. La función quedaría así:&lt;ref group=nota&gt;Esta función ya está disponible en las bibliotecas estándar de Haskell con el nombre &lt;code&gt;abs&lt;/code&gt;. No es necesario volver a implementarla.&lt;/ref&gt;

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
absoluto x
    | x &lt; 0     = 0 - x
    | otherwise = x
&lt;/syntaxhighlight&gt;

Es interesante observar que el código anterior se parece bastante a la definición matemática. Veámoslo por partes:

* Comenzamos con una definición normal de una función. Primero escribimos el nombre, &lt;code&gt;absoluto&lt;/code&gt;, y después especificamos la cantidad de argumentos que acepta: &lt;code&gt;x&lt;/code&gt;.

* En lugar de escribir el signo &lt;code&gt;=&lt;/code&gt; y comenzar la definición, escribimos dos alternativas de comportamiento justo debajo.&lt;ref group=nota&gt;En realidad, podríamos escribirlo todo en una sola línea, como &lt;code&gt;f x | caso 1 | caso 2&lt;/code&gt;, pero siempre es preferible dividir el código en varias líneas para facilitar la lectura.&lt;/ref&gt; Estas alternativas son las que llamamos ''guardas''. Debemos recordar que la indentación (los espacios en blanco antes de &lt;code&gt;|&lt;/code&gt;) no es opcional: sirve para indicar que las guardas pertenecen al ámbito de la definición de &lt;code&gt;absoluto&lt;/code&gt;.

* Cada guarda comienza con una barra vertical, &lt;code&gt;|&lt;/code&gt;. Después de ella, escribimos una expresión que dé como resultado un valor booleano, también llamada condición booleana o ''predicado''. A continuación, aparece el resto de la definición, que comienza con &lt;code&gt;=&lt;/code&gt;. La definición indicada en una guarda solo se evaluará si su predicado resulta ser &lt;code&gt;True&lt;/code&gt;.

* El caso de &lt;code&gt;otherwise&lt;/code&gt; se evalúa cuando ninguna de las condiciones anteriores es verdadera. En este ejemplo, si &lt;code&gt;x&lt;/code&gt; no es menor que cero, entonces necesariamente es mayor o igual que cero. Por tanto, el predicado de la última guarda podría ser &lt;code&gt;x &gt;= 0&lt;/code&gt;, pero lo habitual es utilizar &lt;code&gt;otherwise&lt;/code&gt; para abarcar todos los casos que no se hayan contemplado en las guardas anteriores.

{{nota|No hay nada mágico detrás de &lt;code&gt;otherwise&lt;/code&gt;. En realidad, se define simplemente como &lt;code&gt;otherwise {{=}} True&lt;/code&gt;. Esto significa que, siempre que se evalúe &lt;code&gt;otherwise&lt;/code&gt;, devolverá &lt;code&gt;True&lt;/code&gt; y, por tanto, se ejecutará la definición indicada en su guarda.}}

Observa que escribimos &lt;code&gt;0 - x&lt;/code&gt; en lugar de &lt;code&gt;-x&lt;/code&gt;. Esto se debe a que &lt;code&gt;-&lt;/code&gt; ''no es'' una función de un argumento que devuelva &lt;code&gt;0 - x&lt;/code&gt;. En realidad, se trata de una abreviatura sintáctica. Aunque resulta muy útil, suele causar conflictos cuando se utiliza junto con la función &lt;code&gt;(-)&lt;/code&gt;, que es el operador de resta. Haz una prueba en GHCi: calcula 3 menos -4 sin utilizar paréntesis. Para evitar este tipo de problemas, hemos decidido escribir explícitamente &lt;code&gt;0 - x&lt;/code&gt;.

== Guardas y &lt;code&gt;where&lt;/code&gt; ==
Es bastante habitual utilizar &lt;code&gt;where&lt;/code&gt; dentro de una función con guardas. Por ejemplo, para determinar cuántas soluciones reales tiene una [[w:Ecuación cuadrática|ecuación de segundo grado]] de la forma &lt;math&gt;ax^2+bx+c=0&lt;/math&gt;, debemos calcular su discriminante, &lt;math&gt;\Delta = b^2 - 4ac&lt;/math&gt;. Si es mayor que cero, hay dos raíces reales; si es igual a cero, hay una; y si es menor que cero, no hay ninguna. Una función de Haskell llamada &lt;code&gt;numSolsReales&lt;/code&gt;, que calcule esta cantidad, podría escribirse así:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
numSolsReales a b c
    | delta &gt; 0  = 2
    | delta == 0 = 1
    | otherwise = 0
        where
        delta = b^2 - 4*a*c
&lt;/syntaxhighlight&gt;

== Notas ==
&lt;references group=nota/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>jp0gon7se8yihj1adkfl2z4aa7f0pzj</sha1>
    </revision>
  </page>
  <page>
    <title>Haskell/Tipos básicos</title>
    <ns>0</ns>
    <id>65086</id>
    <revision>
      <id>436374</id>
      <timestamp>2026-10-13T16:42:29Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>Página creada con «{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}  En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.  == Introducción == Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación…»</comment>
      <origin>436374</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21139" sha1="26sgp9rev6j9f6c1h9bak276owf7fdg" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{nota|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| Juan
| Román
| Calle del Livramento, 77, Cortiço, Río de Janeiro
| 218444
|-
| Severino
| Retirante
| Av. Capibaribe-Río, 1025, Recife
| 813586
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;Juan&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle del Livramento, 77, Cortiço, Río de Janeiro&lt;/tt&gt; y &lt;tt&gt;218444&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Ejercicio|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanoVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanoVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) {{=}} 2&lt;/code&gt;.
# &lt;code&gt;({{!!}})&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x {{!!}} y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

[[en:Haskell/Type basics]]</text>
      <sha1>26sgp9rev6j9f6c1h9bak276owf7fdg</sha1>
    </revision>
    <revision>
      <id>436375</id>
      <parentid>436374</parentid>
      <timestamp>2026-10-13T16:43:06Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <origin>436375</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21154" sha1="5thcw1ulmgyfh091hudl2m0vle99180" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{nota|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| Juan
| Román
| Calle del Livramento, 77, Cortiço, Río de Janeiro
| 218444
|-
| Severino
| Retirante
| Av. Capibaribe-Río, 1025, Recife
| 813586
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;Juan&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle del Livramento, 77, Cortiço, Río de Janeiro&lt;/tt&gt; y &lt;tt&gt;218444&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Ejercicio|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanoVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanoVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) {{=}} 2&lt;/code&gt;.
# &lt;code&gt;({{!!}})&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x {{!!}} y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>5thcw1ulmgyfh091hudl2m0vle99180</sha1>
    </revision>
    <revision>
      <id>436378</id>
      <parentid>436375</parentid>
      <timestamp>2026-10-13T16:47:00Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Ejemplo: abrirVentana */</comment>
      <origin>436378</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21156" sha1="dw2827vhiavnl02gghzy98erx2gaisn" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{nota|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| Juan
| Román
| Calle del Livramento, 77, Cortiço, Río de Janeiro
| 218444
|-
| Severino
| Retirante
| Av. Capibaribe-Río, 1025, Recife
| 813586
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;Juan&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle del Livramento, 77, Cortiço, Río de Janeiro&lt;/tt&gt; y &lt;tt&gt;218444&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Ejercicio|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) {{=}} 2&lt;/code&gt;.
# &lt;code&gt;({{!!}})&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x {{!!}} y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>dw2827vhiavnl02gghzy98erx2gaisn</sha1>
    </revision>
    <revision>
      <id>436379</id>
      <parentid>436378</parentid>
      <timestamp>2026-10-13T16:47:30Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Caracteres y cadenas de caracteres */</comment>
      <origin>436379</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21164" sha1="frp6pu29vmsfyv87quj8waqeghpkaui" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{nota|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| Juan
| Román
| Calle del Livramento, 77, Cortiço, Río de Janeiro
| 218444
|-
| Severino
| Retirante
| Av. Capibaribe-Río, 1025, Recife
| 813586
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;Juan&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle del Livramento, 77, Cortiço, Río de Janeiro&lt;/tt&gt; y &lt;tt&gt;218444&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicio|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) {{=}} 2&lt;/code&gt;.
# &lt;code&gt;({{!!}})&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x {{!!}} y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>frp6pu29vmsfyv87quj8waqeghpkaui</sha1>
    </revision>
    <revision>
      <id>436380</id>
      <parentid>436379</parentid>
      <timestamp>2026-10-13T16:47:48Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Caracteres y cadenas de caracteres */</comment>
      <origin>436380</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21165" sha1="pjuwzc8vtrh00a1ktum1tad25w4pdxo" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{nota|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| Juan
| Román
| Calle del Livramento, 77, Cortiço, Río de Janeiro
| 218444
|-
| Severino
| Retirante
| Av. Capibaribe-Río, 1025, Recife
| 813586
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;Juan&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle del Livramento, 77, Cortiço, Río de Janeiro&lt;/tt&gt; y &lt;tt&gt;218444&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicios|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) {{=}} 2&lt;/code&gt;.
# &lt;code&gt;({{!!}})&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x {{!!}} y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>pjuwzc8vtrh00a1ktum1tad25w4pdxo</sha1>
    </revision>
    <revision>
      <id>436381</id>
      <parentid>436380</parentid>
      <timestamp>2026-10-13T16:56:24Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Introducción */</comment>
      <origin>436381</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21191" sha1="jqqu0smcwuldm8p0u92vc0b751kyx8b" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{nota|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| José
| Martínez
| Calle de Embajadores, 77, Lavapiés, Madrid, España.
| 184344
|-
| Juan
| José
| Carrer de la Marina, 1025, El Poblenou, Barcelona, España.
| 724931
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;José&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle de Embajadores, 77, Lavapiés, Madrid, España&lt;/tt&gt; y &lt;tt&gt;184344&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicios|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) {{=}} 2&lt;/code&gt;.
# &lt;code&gt;({{!!}})&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x {{!!}} y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>jqqu0smcwuldm8p0u92vc0b751kyx8b</sha1>
    </revision>
    <revision>
      <id>436388</id>
      <parentid>436381</parentid>
      <timestamp>2026-10-13T17:36:10Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <origin>436388</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21201" sha1="4czuogofcpvq7lvi9iddz38mgqdkaje" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{Nota al margen|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| José
| Martínez
| Calle de Embajadores, 77, Lavapiés, Madrid, España.
| 184344
|-
| Juan
| José
| Carrer de la Marina, 1025, El Poblenou, Barcelona, España.
| 724931
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;José&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle de Embajadores, 77, Lavapiés, Madrid, España&lt;/tt&gt; y &lt;tt&gt;184344&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicios|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) {{=}} 2&lt;/code&gt;.
# &lt;code&gt;({{!!}})&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x {{!!}} y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>4czuogofcpvq7lvi9iddz38mgqdkaje</sha1>
    </revision>
    <revision>
      <id>436393</id>
      <parentid>436388</parentid>
      <timestamp>2026-10-13T17:48:27Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Introducción */</comment>
      <origin>436393</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21206" sha1="67xaf3rqnt9b6n69n8w02a9pd9fam9m" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{Nota al margen|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| José
| Martínez
| Calle de Embajadores, 77, Lavapiés, Madrid, España.
| 184344
|-
| Juan
| Rodríguez
| Carrer de la Marina, 1025, El Poblenou, Barcelona, España.
| 724931
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;José&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle de Embajadores, 77, Lavapiés, Madrid, España&lt;/tt&gt; y &lt;tt&gt;184344&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicios|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) {{=}} 2&lt;/code&gt;.
# &lt;code&gt;({{!!}})&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x {{!!}} y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>67xaf3rqnt9b6n69n8w02a9pd9fam9m</sha1>
    </revision>
    <revision>
      <id>436476</id>
      <parentid>436393</parentid>
      <timestamp>2026-10-14T10:28:08Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Ejemplo: abrirVentana */</comment>
      <origin>436476</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21183" sha1="nkcegdz7ua2ncvddbpyl5iskys9ga9j" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{Nota al margen|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| José
| Martínez
| Calle de Embajadores, 77, Lavapiés, Madrid, España.
| 184344
|-
| Juan
| Rodríguez
| Carrer de la Marina, 1025, El Poblenou, Barcelona, España.
| 724931
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;José&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle de Embajadores, 77, Lavapiés, Madrid, España&lt;/tt&gt; y &lt;tt&gt;184344&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicios|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) {{=}} 2&lt;/code&gt;.
# ||: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x || y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>nkcegdz7ua2ncvddbpyl5iskys9ga9j</sha1>
    </revision>
    <revision>
      <id>436477</id>
      <parentid>436476</parentid>
      <timestamp>2026-10-14T10:29:16Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Ejemplo: abrirVentana */</comment>
      <origin>436477</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21209" sha1="fhf74iwi7li097zbb84r6h0yzjugzfr" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{Nota al margen|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| José
| Martínez
| Calle de Embajadores, 77, Lavapiés, Madrid, España.
| 184344
|-
| Juan
| Rodríguez
| Carrer de la Marina, 1025, El Poblenou, Barcelona, España.
| 724931
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;José&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle de Embajadores, 77, Lavapiés, Madrid, España&lt;/tt&gt; y &lt;tt&gt;184344&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicios|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) {{=}} 2&lt;/code&gt;.
# &lt;code&gt;||&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x &lt;code&gt;||&lt;/code&gt; y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>fhf74iwi7li097zbb84r6h0yzjugzfr</sha1>
    </revision>
    <revision>
      <id>436478</id>
      <parentid>436477</parentid>
      <timestamp>2026-10-14T10:31:02Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Ejemplo: abrirVentana */</comment>
      <origin>436478</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21218" sha1="diovl3jn32s4fq3humqq97gzjyqj889" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{Nota al margen|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| José
| Martínez
| Calle de Embajadores, 77, Lavapiés, Madrid, España.
| 184344
|-
| Juan
| Rodríguez
| Carrer de la Marina, 1025, El Poblenou, Barcelona, España.
| 724931
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;José&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle de Embajadores, 77, Lavapiés, Madrid, España&lt;/tt&gt; y &lt;tt&gt;184344&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicios|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 {{=}} -4&lt;/code&gt;; &lt;code&gt;negativo (-2) &lt;code&gt;=&lt;/code&gt; 2&lt;/code&gt;.
# &lt;code&gt;||&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y {{=}} not x &lt;code&gt;||&lt;/code&gt; y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>diovl3jn32s4fq3humqq97gzjyqj889</sha1>
    </revision>
    <revision>
      <id>436479</id>
      <parentid>436478</parentid>
      <timestamp>2026-10-14T10:36:45Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Ejemplo: abrirVentana */</comment>
      <origin>436479</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21218" sha1="nq1lvgw4rmh9zfi6zl2ykj8o99zma9e" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{Nota al margen|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| José
| Martínez
| Calle de Embajadores, 77, Lavapiés, Madrid, España.
| 184344
|-
| Juan
| Rodríguez
| Carrer de la Marina, 1025, El Poblenou, Barcelona, España.
| 724931
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;José&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle de Embajadores, 77, Lavapiés, Madrid, España&lt;/tt&gt; y &lt;tt&gt;184344&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicios|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 = -4&lt;/code&gt;; &lt;code&gt;negativo (-2) = 2&lt;/code&gt;.
# &lt;code&gt;&lt;nowiki&gt;||&lt;/nowiki&gt;&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y = not x &lt;nowiki&gt;||&lt;/nowiki&gt; y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>nq1lvgw4rmh9zfi6zl2ykj8o99zma9e</sha1>
    </revision>
    <revision>
      <id>436480</id>
      <parentid>436479</parentid>
      <timestamp>2026-10-14T10:41:24Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Ejemplo: abrirVentana */</comment>
      <origin>436480</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21333" sha1="plc9s597oe5t1bkixnywscyoijz7ncz" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{Nota al margen|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| José
| Martínez
| Calle de Embajadores, 77, Lavapiés, Madrid, España.
| 184344
|-
| Juan
| Rodríguez
| Carrer de la Marina, 1025, El Poblenou, Barcelona, España.
| 724931
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;José&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle de Embajadores, 77, Lavapiés, Madrid, España&lt;/tt&gt; y &lt;tt&gt;184344&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicios|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
{{Nota al margen|side=derecha|Una biblioteca es una colección de código común utilizado por muchos programas.}}
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 = -4&lt;/code&gt;; &lt;code&gt;negativo (-2) = 2&lt;/code&gt;.
# &lt;code&gt;&lt;nowiki&gt;||&lt;/nowiki&gt;&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y = not x &lt;nowiki&gt;||&lt;/nowiki&gt; y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>plc9s597oe5t1bkixnywscyoijz7ncz</sha1>
    </revision>
    <revision>
      <id>436482</id>
      <parentid>436480</parentid>
      <timestamp>2026-10-14T10:44:07Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>/* Ejemplo: abrirVentana */</comment>
      <origin>436482</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21335" sha1="1dc2lcsimtseqrrscbbrmx44rmrcn48" xml:space="preserve">{{Haskell/Minitoc|capítulo=Principios básicos de Haskell}}

En programación, los '''tipos''' se utilizan para agrupar valores similares, con características comunes, dentro de una determinada categoría. En Haskell, su sistema de tipos es una herramienta poderosa que permite evitar muchos errores triviales en un programa.

== Introducción ==
Cuando se crea un programa, generalmente hay que trabajar con distintas entidades. Por ejemplo, consideremos la operación &lt;math&gt;2 + 3&lt;/math&gt;. ¿Qué son 2 y 3? Números. ¿Y el signo más que aparece entre ellos? No es un número, sino un símbolo que representa la operación de suma que queremos realizar entre 2 y 3.

Ahora imaginemos un programa que nos pide nuestro nombre y nos saluda con un mensaje que dice «Hola». Ni nuestro nombre ni el mensaje son números, sino palabras. Por lo tanto, son texto. En programación, cuando nos referimos a texto, generalmente hablamos de ''String'', que significa «hilo» o «cadena» en inglés. Es una forma abreviada de decir «cadena de caracteres».

{{Nota al margen|En Haskell, existe una regla según la cual el nombre de cualquier tipo debe comenzar con una letra mayúscula. A partir de aquí, seguiremos siempre esta regla.}}

Una base de datos es un buen ejemplo para ilustrar los distintos tipos de datos que existen. Imaginemos que tenemos una tabla de contactos, como una agenda. Su contenido podría ser el siguiente:

{|class=&quot;wikitable&quot;
| Primer nombre
| Apellido
| Dirección postal
| Número de teléfono
|-
| José
| Martínez
| Calle de Embajadores, 77, Lavapiés, Madrid, España.
| 184344
|-
| Juan
| Rodríguez
| Carrer de la Marina, 1025, El Poblenou, Barcelona, España.
| 724931
|}

Los campos de cada registro contienen valores diferentes. &lt;tt&gt;José&lt;/tt&gt; es un valor, mientras que &lt;tt&gt;Calle de Embajadores, 77, Lavapiés, Madrid, España&lt;/tt&gt; y &lt;tt&gt;184344&lt;/tt&gt; son otros dos. En cuanto a sus tipos, «Primer nombre» y «Apellido» contienen texto, por lo que sus valores son del tipo String.

A primera vista, también podríamos clasificar «Dirección postal» como texto. Sin embargo, existen distintas formas de interpretar una dirección como esta. La primera palabra podría ser el nombre de un edificio o de una calle, mientras que los números que aparecen a continuación podrían indicar el número del inmueble o de su parcela. Las palabras siguientes podrían corresponder al barrio o a la ciudad. También es posible que la dirección comience con «Apartado postal», en cuyo caso ni siquiera indicaría un domicilio de entrega, sino únicamente un apartado de correspondencia en una oficina postal. Por lo tanto, cada parte de una dirección tiene un significado propio.

En principio, podríamos decir que una dirección es un String. De hecho, lo es, pero al tratarla únicamente como texto perderíamos información importante. Cuando definimos algo como String, indicamos que se trata de una simple secuencia de caracteres. En cambio, si podemos incluirlo en una categoría más específica, dispondremos de mucha más información sobre su contenido. Por ejemplo, si sabemos que un String representa una dirección, podremos interpretarlo y manipularlo de una manera más apropiada.

La misma lógica puede aplicarse a los números de teléfono. Podemos especificar un tipo llamado NumeroTelefono y, cuando encontremos un valor de ese tipo, podremos buscar patrones como los códigos de área o de país. Otra razón para no tratarlos como números comunes es que no tiene sentido realizar operaciones aritméticas con ellos: ¿qué esperamos obtener al multiplicar un NumeroTelefono por 100 o dividirlo por la mitad? Es posible que el resultado ni siquiera sea un número de teléfono válido. Además, no es aceptable perder, omitir ni redondear sus cifras por ese mismo motivo.

=== La utilidad de los tipos ===
Pero ¿por qué nos ayuda a programar separar y categorizar las cosas? Una vez definidos los tipos, podemos especificar qué operaciones se pueden realizar con sus valores y cuáles no. Esto resulta especialmente útil para evitar errores en programas extensos.

== Usando el comando interactivo &lt;code&gt;:type&lt;/code&gt; ==
Exploremos el funcionamiento de los tipos mediante una sesión de GHCi. Podemos consultar el tipo de una expresión con el comando &lt;code&gt;:type&lt;/code&gt; o su abreviatura &lt;code&gt;:t&lt;/code&gt;. Probémoslo con valores booleanos y expresiones booleanas:

{{Haskell/GHCi|1=
Prelude&gt; :type True
True :: Bool
Prelude&gt; :type False
False :: Bool
Prelude&gt; :t (3 &lt; 5)
(3 &lt; 5) :: Bool
}}

El símbolo &lt;tt&gt;::&lt;/tt&gt; aparece en todos los resultados. Se lee como «es del tipo» y va seguido de una ''firma de tipo'' o ''anotación de tipo''.

El comando &lt;code&gt;:t&lt;/code&gt; nos muestra que los valores verdadero (&lt;code&gt;True&lt;/code&gt;) y falso (&lt;code&gt;False&lt;/code&gt;) son del tipo &lt;code&gt;Bool&lt;/code&gt;. Incluso las expresiones tienen un tipo definido: cuando se evalúan, producen un valor de tipo &lt;code&gt;Bool&lt;/code&gt;. Quizá esto ya esté claro, pero conviene señalar que &lt;code&gt;Bool&lt;/code&gt; es el tipo de dato elegido para representar valores de verdadero o falso. Por ejemplo, permite indicar si se encontró un valor o si se pulsó un botón.

== Caracteres y ''cadenas de caracteres'' ==

Probemos ahora &lt;code&gt;:t&lt;/code&gt; con otros valores. En Haskell, un único carácter se representa encerrándolo entre comillas simples:

{{Haskell/GHCi|1=
Prelude&gt; :t 'H'
'H' :: Char
}}

Por lo tanto, los caracteres son del tipo &lt;code&gt;Char&lt;/code&gt;, abreviatura de ''character'' (carácter, en inglés). Para representar una cadena de caracteres en lugar de uno solo, debemos utilizar comillas dobles:

{{Haskell/GHCi|1=
Prelude&gt; :t &quot;Hola, mundo&quot;
&quot;Hola, mundo&quot; :: [Char]
}}

De nuevo aparece &lt;code&gt;Char&lt;/code&gt;, pero esta vez entre corchetes. &lt;code&gt;[Char]&lt;/code&gt; significa una ''lista'' de caracteres. Haskell considera que toda cadena de caracteres es una lista. Las listas son muy importantes en Haskell, y hablaremos de ellas más adelante.

{{Haskell/Ejercicios|1=
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;&quot;H&quot;&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas dobles. ¿Qué sucede y por qué?
# Usa &lt;code&gt;:type&lt;/code&gt; seguido de un valor como &lt;code&gt;'Hola, mundo'&lt;/code&gt; en GHCi. Observa que aquí utilizamos comillas simples. ¿Qué sucede y por qué?
}}

Haskell nos permite crear ''sinónimos de tipos'', que funcionan como los sinónimos del lenguaje humano: palabras diferentes que tienen el mismo significado. Estos sinónimos son nombres alternativos para los tipos. Por ejemplo, &lt;tt&gt;String&lt;/tt&gt; está definido como sinónimo de &lt;tt&gt;[Char]&lt;/tt&gt;, por lo que podemos utilizar uno u otro indistintamente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
&quot;Hola, mundo&quot; :: String
&lt;/syntaxhighlight&gt;

El código anterior es perfectamente válido. Para las personas, resulta mucho más claro leer &lt;code&gt;String&lt;/code&gt; que leer &lt;code&gt;[Char]&lt;/code&gt; e interpretar que se trata de una lista de caracteres y, por lo tanto, de una cadena de caracteres.

== Tipos de las funciones ==

Hasta ahora hemos visto los tipos de algunos valores (cadenas de caracteres, valores booleanos, caracteres, etc.). También hemos visto que los tipos nos ayudan a categorizar y describir determinados valores de una forma más conveniente. Ahora veremos qué hace que el sistema de tipos de Haskell sea tan importante y poderoso: las ''funciones'' también tienen tipos.

=== Ejemplo ===
Podemos invertir un valor booleano mediante la función &lt;code&gt;not&lt;/code&gt;, como ya vimos. Para conocer el tipo de una función, debemos tener en cuenta dos cosas: los tipos de sus argumentos y el tipo del valor que devuelve, es decir, el tipo de su salida. En el caso de &lt;code&gt;not&lt;/code&gt;, es muy sencillo: recibe un valor de tipo &lt;code&gt;Bool&lt;/code&gt; y devuelve otro del mismo tipo. En Haskell, utilizamos la siguiente notación:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
not :: Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Esta línea puede leerse así: «&lt;tt&gt;not&lt;/tt&gt; es del tipo que recibe valores de tipo &lt;tt&gt;Bool&lt;/tt&gt; y devuelve valores de tipo &lt;tt&gt;Bool&lt;/tt&gt;». En otras palabras, es una función que transforma un valor de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la entrada) en otro de tipo &lt;tt&gt;Bool&lt;/tt&gt; (la salida).

En GHCi también podemos utilizar &lt;code&gt;:t&lt;/code&gt; con las funciones:

{{Haskell/GHCi|1=
Prelude&gt; :t not
not :: Bool -&gt; Bool
}}

Por lo tanto, el tipo de una función se describe mediante el tipo de su entrada y el de su salida.

=== Ejemplo: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt; ===
La representación del texto siempre ha sido un problema para las computadoras. En su nivel más básico, una computadora solo puede interpretar datos binarios: unos y ceros. Para representar un texto, cada carácter debe convertirse primero en un número, que después puede expresarse en forma binaria para que la computadora lo interprete. La conversión a binario es una tarea sencilla para la máquina, por lo que aquí solo nos interesa la conversión de un carácter a su representación numérica.

Una forma sencilla de realizar esta tarea sería enumerar todos los caracteres posibles. Por ejemplo, podríamos hacer corresponder la letra «a» con el número 1, la «b» con el 2, la «c» con el 3, y así sucesivamente. Haskell ya dispone de una codificación de caracteres, y sería tedioso consultar su tabla cada vez que necesitáramos conocer los valores numéricos. Por comodidad, contamos con dos funciones que realizan estas conversiones: &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;No es exactamente así como funcionan &lt;code&gt;chr&lt;/code&gt; y &lt;code&gt;ord&lt;/code&gt;, pero esta descripción es válida por ahora.&lt;/ref&gt; Investiguemos sus tipos:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
chr :: Int -&gt; Char
ord :: Char -&gt; Int
&lt;/syntaxhighlight&gt;

Como ya sabemos qué significa &lt;code&gt;Char&lt;/code&gt;, expliquemos &lt;code&gt;Int&lt;/code&gt;. Este tipo representa números enteros y es solo uno de los varios tipos numéricos definidos en Haskell. De hecho, Haskell dispone de más de un tipo para representar números enteros. La firma de tipo de &lt;code&gt;chr&lt;/code&gt; nos indica que recibe un argumento de tipo &lt;code&gt;Int&lt;/code&gt;, es decir, un número entero, y produce un resultado de tipo &lt;code&gt;Char&lt;/code&gt;. En el caso de &lt;code&gt;ord&lt;/code&gt;, sucede lo contrario: recibe un argumento de tipo &lt;code&gt;Char&lt;/code&gt; y devuelve uno de tipo &lt;code&gt;Int&lt;/code&gt;. Al analizar ambas firmas, queda claro cuál de las funciones convierte un carácter en un número (&lt;code&gt;ord&lt;/code&gt;) y cuál realiza la operación inversa (&lt;code&gt;chr&lt;/code&gt;).

Veamos algunos ejemplos. Estas funciones no están disponibles de forma predeterminada al abrir una sesión de GHCi, por lo que debemos cargar el módulo &lt;code&gt;Data.Char&lt;/code&gt;, donde están definidas, mediante el comando &lt;code&gt;:module Data.Char&lt;/code&gt; o su abreviatura &lt;code&gt;:m&lt;/code&gt;.

{{Haskell/GHCi|1=
Prelude&gt; :m Data.Char
Prelude Data.Char&gt; chr 97
'a'
Prelude Data.Char&gt; chr 98
'b'
Prelude Data.Char&gt; ord 'c'
99
}}

=== Funciones con más de un argumento ===
¿Cuál sería el tipo de una función con más de un argumento?

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

&lt;code&gt;xor&lt;/code&gt; es la función lógica «o exclusivo», que evalúa si exactamente uno de sus argumentos es &lt;code&gt;True&lt;/code&gt;. Si ambos son verdaderos o ambos son falsos, devuelve &lt;code&gt;False&lt;/code&gt;.

El método básico para describir el tipo de una función con varios argumentos consiste en escribir los tipos de cada argumento en secuencia (primero el de &lt;code&gt;p&lt;/code&gt;, después el de &lt;code&gt;q&lt;/code&gt;, por ejemplo) y añadir al final el tipo del resultado. Después, basta con intercalar los tipos mediante el símbolo &lt;code&gt;-&gt;&lt;/code&gt;.&lt;ref group=&quot;nota&quot;&gt;Trataremos este tema con más detalle en el capítulo sobre [[Haskell/Funciones de alta orden|funciones de orden superior]].&lt;/ref&gt;

&lt;ol&gt;
&lt;li&gt;
Escribe los tipos de los argumentos de entrada en secuencia y, al final, el tipo de salida. La definición de &lt;code&gt;xor&lt;/code&gt; nos indica que sus argumentos se evalúan como &lt;code&gt;True&lt;/code&gt; o &lt;code&gt;False&lt;/code&gt;. Por lo tanto, ambos deben ser del tipo &lt;code&gt;Bool&lt;/code&gt;. La salida también es de tipo &lt;code&gt;Bool&lt;/code&gt;:

&lt;pre&gt;
Bool                    Bool                    Bool
^^^^ p es de tipo Bool  ^^^^ q es de tipo Bool  ^^^^ la salida también es de tipo Bool
&lt;/pre&gt;
&lt;/li&gt;
&lt;li&gt;
Intercala los tipos mediante &lt;code&gt;-&gt;&lt;/code&gt;:

&lt;pre&gt;Bool -&gt; Bool -&gt; Bool&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;

Por lo tanto, la firma de tipo de &lt;code&gt;xor&lt;/code&gt; es:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
&lt;/syntaxhighlight&gt;

Puede leerse así: «&lt;tt&gt;xor&lt;/tt&gt; es del tipo que recibe dos valores &lt;tt&gt;Bool&lt;/tt&gt; y devuelve un valor &lt;tt&gt;Bool&lt;/tt&gt;».

=== Ejemplo: &lt;code&gt;abrirVentana&lt;/code&gt; ===
{{Nota al margen|margen=derecha|Una biblioteca es una colección de código común utilizado por muchos programas.}}
A medida que profundizamos en nuestros conocimientos de programación, algunos términos técnicos se vuelven habituales. Uno de ellos es el de ''bibliotecas'', que son conjuntos de código destinados a un propósito determinado y que pueden utilizarse en distintos programas. Uno de los tipos de bibliotecas más comunes es el de las GUI (''&lt;u&gt;G&lt;/u&gt;raphical &lt;u&gt;U&lt;/u&gt;ser &lt;u&gt;I&lt;/u&gt;nterface'', o «interfaz gráfica de usuario», en español). En este tipo de bibliotecas podemos encontrar funciones para crear botones y menús, así como para gestionar la interacción con el ratón y el teclado. Una posible función sería &lt;code&gt;abrirVentana&lt;/code&gt;, que probablemente abriría una ventana nueva al ejecutarse. La firma de tipo de una función como esta podría ser:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
abrirVentana :: TituloVentana -&gt; TamanioVentana -&gt; Ventana
&lt;/syntaxhighlight&gt;

No necesitamos conocer en profundidad la definición de estos tipos, pero sus nombres nos ayudan a entender qué se necesita para crear una ventana. También es muy probable que estén definidos en la propia biblioteca que contiene la función &lt;code&gt;abrirVentana&lt;/code&gt;.

Analicémoslo por partes. Recordemos lo que explicamos en la [[#Funciones con más de un argumento|sección anterior]]: el último tipo descrito en la firma de una función es el de su salida. Por lo tanto, ¿cuántos argumentos necesita &lt;code&gt;abrirVentana&lt;/code&gt;? Dos. ¿Cuáles son sus tipos? &lt;code&gt;TituloVentana&lt;/code&gt; y &lt;code&gt;TamanioVentana&lt;/code&gt;. ¿Y cuál es el tipo de la salida? &lt;code&gt;Ventana&lt;/code&gt;. Así, podemos entender que «&lt;code&gt;abrirVentana&lt;/code&gt; es una función que crea una ventana nueva y que, para hacerlo, necesita un título y un tamaño».

Observa que no es necesario haber utilizado una función para comprender qué hace. Cuando utilizamos tipos cuyos nombres son suficientemente claros, la firma de la función nos da pistas sobre su funcionamiento. Es una buena práctica probar las funciones con &lt;code&gt;:t&lt;/code&gt; en GHCi antes de utilizarlas. Cuanto más lo hagas, mejor será tu intuición para interpretar los tipos de las funciones.

{{Haskell/Ejercicios|1=
Intenta deducir las anotaciones de tipo de las siguientes funciones. Si alguna de ellas involucra números, supón que son del tipo Int.

# &lt;code&gt;negativo&lt;/code&gt;: una función que recibe un Int y devuelve su opuesto (con el signo invertido). Ejemplos: &lt;code&gt;negativo 4 = -4&lt;/code&gt;; &lt;code&gt;negativo (-2) = 2&lt;/code&gt;.
# &lt;code&gt;&lt;nowiki&gt;||&lt;/nowiki&gt;&lt;/code&gt;: la función lógica «o». Recibe dos valores booleanos y comprueba si al menos uno de ellos es verdadero. Si es así, devuelve verdadero; de lo contrario, devuelve falso.
# &lt;code&gt;diasEnElMes&lt;/code&gt;: una función que calcula la cantidad de días de un mes determinado. Recibe un valor que indica si el año es bisiesto y el número del mes, del 1 al 12.
# &lt;code&gt;f x y = not x &lt;nowiki&gt;||&lt;/nowiki&gt; y&lt;/code&gt;
# &lt;code&gt;g x = (2*x - 1)^2&lt;/code&gt;
}}

== Anotaciones de tipo en archivos de código ==
Ahora que ya comprendemos un poco qué son los tipos y cómo pueden ayudarnos, veamos cómo incluir este tipo de anotaciones en el código fuente de un programa. Consideremos la función &lt;code&gt;xor&lt;/code&gt; que definimos anteriormente. Si queremos definirla en un archivo y anotar su tipo, basta con escribir lo siguiente:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
xor :: Bool -&gt; Bool -&gt; Bool
xor p q = (p || q) &amp;&amp; not (p &amp;&amp; q)
&lt;/syntaxhighlight&gt;

Eso es todo. Para mayor claridad, es habitual colocar la anotación inmediatamente antes de la definición de la función, por lo que se recomienda seguir esta convención.

Además de facilitar la comprensión del funcionamiento de una función, las anotaciones de tipo también son fundamentales para que el compilador interprete correctamente el código, como veremos a continuación.

=== Inferencia de tipos ===
Como dijimos antes, las funciones tienen tipos. Es importante destacar que ''siempre'' los tienen. Entonces, ¿cómo pudimos escribir las funciones del capítulo anterior sin especificar ninguna firma? Esto es posible porque el compilador puede ''inferir'' el tipo de una función basándose en las operaciones que realiza. Veamos el siguiente caso:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

&lt;code&gt;ehL&lt;/code&gt; es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;, y devuelve el resultado de la expresión &lt;code&gt;c == 'l'&lt;/code&gt;. Aunque no hayamos anotado explícitamente el tipo de &lt;code&gt;c&lt;/code&gt; ni el de la salida, podemos intentar deducir la firma de tipo de &lt;code&gt;ehL&lt;/code&gt;. Veamos cómo hacerlo:

* Es una función que recibe un argumento, &lt;code&gt;c&lt;/code&gt;. Toda función en Haskell tiene una salida.

&lt;pre&gt;
_ -&gt; _
&lt;/pre&gt;

* La salida es el resultado de la operación &lt;code&gt;c == 'l'&lt;/code&gt;. Como ya vimos, &lt;code&gt;(==)&lt;/code&gt; es un operador de comparación de igualdad, y estas comparaciones suelen producir una respuesta de verdadero o falso, que puede representarse mediante el tipo &lt;code&gt;Bool&lt;/code&gt;. De hecho, ya vimos el operador &lt;code&gt;(==)&lt;/code&gt; en [[Haskell/Verdadero o falso|Verdadero o falso]], por lo que sabemos con certeza que su resultado es de tipo &lt;code&gt;Bool&lt;/code&gt;.

&lt;pre&gt;
_ -&gt; Bool
&lt;/pre&gt;

* El operador &lt;code&gt;(==)&lt;/code&gt; compara &lt;code&gt;c&lt;/code&gt; con &lt;code&gt;'l'&lt;/code&gt;. No tiene sentido comparar valores de tipos incompatibles. El valor &lt;code&gt;'l'&lt;/code&gt; es de tipo &lt;code&gt;Char&lt;/code&gt;, por lo que &lt;code&gt;c&lt;/code&gt; también debe ser de ese tipo.

&lt;pre&gt;
Char -&gt; Bool
&lt;/pre&gt;

Si quieres comprobar lo que acabamos de deducir, define &lt;code&gt;ehL&lt;/code&gt; en GHCi sin especificar una firma y utiliza después &lt;code&gt;:t&lt;/code&gt; para consultar su tipo:

{{Haskell/GHCi|1=
Prelude&gt; let ehL c = c == 'l'
Prelude&gt; :t ehL
ehL :: Char -&gt; Bool
}}

El compilador realiza un proceso bastante parecido para determinar el tipo de una función. Sin embargo, el resultado puede no ser la firma que esperas o deseas, e incluso puede ocurrir que no consiga determinar una firma válida. Por eso, se recomienda escribir siempre las anotaciones de tipo de las funciones:

&lt;syntaxhighlight lang=&quot;haskell&quot;&gt;
ehL :: Char -&gt; Bool
ehL c = c == 'l'
&lt;/syntaxhighlight&gt;

También existen otras buenas razones para incluirlas en el código:

* '''Documentación:''' como ya vimos, las anotaciones de tipo ayudan a comprender qué hace una función. ''Documentar'' un programa consiste precisamente en describir qué hacen sus partes y cómo funcionan. Por supuesto, los comentarios también ayudan, pero en Haskell las anotaciones de tipo son tan importantes como ellos.

* '''''Depuración'' (''debugging''):''' muchos errores de los programas, conocidos como ''bugs'', se producen al utilizar una función de manera incorrecta. Las anotaciones de tipo ayudan tanto al programador como al compilador a comprobar si una función se está utilizando correctamente, verificando los tipos de las entradas y salidas. Cuando declaramos las anotaciones y se produce un error de incompatibilidad de tipos, el compilador muestra un mensaje que indica dónde está el problema. Si omitimos los tipos, el compilador puede inferir una firma que funcione en una parte del programa, pero que provoque otros errores inesperados durante la ejecución o errores de compilación en otras partes.

Veamos un ejemplo sencillo de depuración. Prueba lo siguiente en GHCi:

{{Haskell/GHCi|1=
Prelude&gt; &quot;hola&quot; ++ &quot; mundo&quot;
&quot;hola mundo&quot;
Prelude&gt; &quot;hola&quot; + &quot; mundo&quot;

&lt;interactive&gt;:2:1: error:
    * No instance for (Num [Char]) arising from a use of `+'
    * In the expression: &quot;hola&quot; + &quot; mundo&quot;
      In an equation for `it': it = &quot;hola&quot; + &quot; mundo&quot;
}}

Acabamos de introducir el operador &lt;code&gt;(++)&lt;/code&gt;, que sirve para concatenar las dos cadenas de caracteres &lt;code&gt;&quot;hola&quot;&lt;/code&gt; y &lt;code&gt;&quot; mundo&quot;&lt;/code&gt;. Si, por un error de escritura, utilizamos &lt;tt&gt;+&lt;/tt&gt; en lugar de &lt;tt&gt;++&lt;/tt&gt;, aparecerá el mensaje de error anterior. En resumen, el mensaje nos indica que el operador &lt;code&gt;(+)&lt;/code&gt; solo está definido para valores pertenecientes a la clase de tipos &lt;code&gt;Num&lt;/code&gt;, mientras que estamos intentando aplicarlo a valores de tipo &lt;code&gt;[Char]&lt;/code&gt;, es decir, cadenas de caracteres.

Es importante señalar que la comprobación de tipos no evita por completo todos los errores. De hecho, todavía podemos escribir una función de una manera que no produzca el resultado deseado. Sin embargo, reflexionar sobre las operaciones que podemos realizar con cada tipo de dato nos ayuda a razonar mejor sobre la lógica de nuestros programas.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;

{{AutoCat}}

[[Categoría:Libro:Haskell]]</text>
      <sha1>1dc2lcsimtseqrrscbbrmx44rmrcn48</sha1>
    </revision>
  </page>
  <page>
    <title>Categoría:Wikilibros:Plantillas de sustitución de caracteres</title>
    <ns>14</ns>
    <id>65088</id>
    <revision>
      <id>436385</id>
      <timestamp>2026-10-13T17:12:44Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>Página creada con «[[Categoría:Plantillas de utilidad]]»</comment>
      <origin>436385</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="37" sha1="mxtuoknlmsbun74hqiins3tlxf1bjsi" xml:space="preserve">[[Categoría:Plantillas de utilidad]]</text>
      <sha1>mxtuoknlmsbun74hqiins3tlxf1bjsi</sha1>
    </revision>
  </page>
  <page>
    <title>Categoría:Plantillas de utilidad</title>
    <ns>14</ns>
    <id>65089</id>
    <revision>
      <id>436386</id>
      <timestamp>2026-10-13T17:13:21Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>Página creada con «[[Categoría:Wikilibros:Plantillas]]»</comment>
      <origin>436386</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="36" sha1="d4d3mdquvv1bbrqmhqw5pvvzr4cjecx" xml:space="preserve">[[Categoría:Wikilibros:Plantillas]]</text>
      <sha1>d4d3mdquvv1bbrqmhqw5pvvzr4cjecx</sha1>
    </revision>
  </page>
  <page>
    <title>Plantilla:Nota al margen</title>
    <ns>10</ns>
    <id>65090</id>
    <revision>
      <id>436389</id>
      <timestamp>2026-10-13T17:38:50Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>Página creada con «&lt;div bgcolor=&quot;#f0f0ff&quot; style=&quot;float:{{{side|left}}}; width:17ex; border: 1px solid #C6C9FF; padding: 1em; margin:1em; font-style:italic;&quot;&gt;{{{1}}}&lt;/div&gt;&lt;noinclude&gt;{{Documentación}}[[Categoría:Plantillas de información|{{PAGENAME}}}]]&lt;/noinclude&gt;»</comment>
      <origin>436389</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="247" sha1="01ely9nb1p98d7zrih4a0q5ymzz6ke6" xml:space="preserve">&lt;div bgcolor=&quot;#f0f0ff&quot; style=&quot;float:{{{side|left}}}; width:17ex; border: 1px solid #C6C9FF; padding: 1em; margin:1em; font-style:italic;&quot;&gt;{{{1}}}&lt;/div&gt;&lt;noinclude&gt;{{Documentación}}[[Categoría:Plantillas de información|{{PAGENAME}}}]]&lt;/noinclude&gt;</text>
      <sha1>01ely9nb1p98d7zrih4a0q5ymzz6ke6</sha1>
    </revision>
    <revision>
      <id>436481</id>
      <parentid>436389</parentid>
      <timestamp>2026-10-14T10:43:14Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <origin>436481</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="252" sha1="8noh49tngyhqh0yz677zmw5pdrmc6lg" xml:space="preserve">&lt;div bgcolor=&quot;#f0f0ff&quot; style=&quot;float:{{{side|izquierda}}}; width:17ex; border: 1px solid #C6C9FF; padding: 1em; margin:1em; font-style:italic;&quot;&gt;{{{1}}}&lt;/div&gt;&lt;noinclude&gt;{{Documentación}}[[Categoría:Plantillas de información|{{PAGENAME}}}]]&lt;/noinclude&gt;</text>
      <sha1>8noh49tngyhqh0yz677zmw5pdrmc6lg</sha1>
    </revision>
    <revision>
      <id>436483</id>
      <parentid>436481</parentid>
      <timestamp>2026-10-14T10:48:14Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <origin>436483</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="254" sha1="63uhe5oig2ebipidrt8m8g6w9d2y8k8" xml:space="preserve">&lt;div bgcolor=&quot;#f0f0ff&quot; style=&quot;float:{{{margen|izquierda}}}; width:17ex; border: 1px solid #C6C9FF; padding: 1em; margin:1em; font-style:italic;&quot;&gt;{{{1}}}&lt;/div&gt;&lt;noinclude&gt;{{Documentación}}[[Categoría:Plantillas de información|{{PAGENAME}}}]]&lt;/noinclude&gt;</text>
      <sha1>63uhe5oig2ebipidrt8m8g6w9d2y8k8</sha1>
    </revision>
    <revision>
      <id>436484</id>
      <parentid>436483</parentid>
      <timestamp>2026-10-14T10:51:15Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <origin>436484</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="299" sha1="si4p2ufy00edbyna8vt0m6mmwoshzwb" xml:space="preserve">&lt;div style=&quot;float:{{#switch:{{lc:{{{margen|izquierda}}}}}|derecha|right=right|#default=left}}; background-color:#f0f0ff; width:17ex; border:1px solid #C6C9FF; padding:1em; margin:1em; font-style:italic;&quot;&gt;{{{1}}}&lt;/div&gt;&lt;noinclude&gt;{{Documentación}}[[Categoría:Plantillas de información]]&lt;/noinclude&gt;</text>
      <sha1>si4p2ufy00edbyna8vt0m6mmwoshzwb</sha1>
    </revision>
    <revision>
      <id>436485</id>
      <parentid>436484</parentid>
      <timestamp>2026-10-14T10:52:51Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <origin>436485</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="273" sha1="roixc6nj9c3lxxrcae914efh524ah0e" xml:space="preserve">&lt;div style=&quot;float:{{#switch:{{lc:{{{margen|izquierda}}}}}|derecha|right=right|#default=left}}; width:17ex; border:1px solid #C6C9FF; padding:1em; margin:1em; font-style:italic;&quot;&gt;{{{1}}}&lt;/div&gt;&lt;noinclude&gt;{{Documentación}}[[Categoría:Plantillas de información]]&lt;/noinclude&gt;</text>
      <sha1>roixc6nj9c3lxxrcae914efh524ah0e</sha1>
    </revision>
  </page>
  <page>
    <title>Plantilla:Nota al margen/uso</title>
    <ns>10</ns>
    <id>65091</id>
    <revision>
      <id>436390</id>
      <timestamp>2026-10-13T17:40:26Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <comment>Página creada con «&lt;templatedata&gt; { 	&quot;params&quot;: { 		&quot;1&quot;: { 			&quot;label&quot;: &quot;content&quot;, 			&quot;description&quot;: &quot;Content of the note.&quot;, 			&quot;type&quot;: &quot;string&quot;, 			&quot;required&quot;: true 		}, 		&quot;side&quot;: { 			&quot;description&quot;: &quot;Which side of the page to display this note at.&quot;, 			&quot;type&quot;: &quot;string&quot;, 			&quot;suggestedvalues&quot;: [ 				&quot;left&quot;, 				&quot;right&quot; 			], 			&quot;default&quot;: &quot;left&quot; 		} 	}, 	&quot;description&quot;: &quot;Display a small note on either the left or right side of the screen.&quot; } &lt;/templatedata&gt;»</comment>
      <origin>436390</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="439" sha1="qjp4hweqn5chu5i4s243lut7t9tdtcb" xml:space="preserve">&lt;templatedata&gt;
{
	&quot;params&quot;: {
		&quot;1&quot;: {
			&quot;label&quot;: &quot;content&quot;,
			&quot;description&quot;: &quot;Content of the note.&quot;,
			&quot;type&quot;: &quot;string&quot;,
			&quot;required&quot;: true
		},
		&quot;side&quot;: {
			&quot;description&quot;: &quot;Which side of the page to display this note at.&quot;,
			&quot;type&quot;: &quot;string&quot;,
			&quot;suggestedvalues&quot;: [
				&quot;left&quot;,
				&quot;right&quot;
			],
			&quot;default&quot;: &quot;left&quot;
		}
	},
	&quot;description&quot;: &quot;Display a small note on either the left or right side of the screen.&quot;
}
&lt;/templatedata&gt;</text>
      <sha1>qjp4hweqn5chu5i4s243lut7t9tdtcb</sha1>
    </revision>
    <revision>
      <id>436391</id>
      <parentid>436390</parentid>
      <timestamp>2026-10-13T17:41:20Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <origin>436391</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="461" sha1="br17tujnol6nw4w14qgdr4t39o56vdb" xml:space="preserve">&lt;templatedata&gt;
{
	&quot;params&quot;: {
		&quot;1&quot;: {
			&quot;label&quot;: &quot;contenido&quot;,
			&quot;description&quot;: &quot;Contenido de la nota.&quot;,
			&quot;type&quot;: &quot;string&quot;,
			&quot;required&quot;: true
		},
		&quot;side&quot;: {
			&quot;description&quot;: &quot;En qué lado de la página se mostrará esta nota.&quot;,
			&quot;type&quot;: &quot;string&quot;,
			&quot;suggestedvalues&quot;: [
				&quot;izquierda&quot;,
				&quot;derecha&quot;
			],
			&quot;default&quot;: &quot;izquierda&quot;
		}
	},
	&quot;description&quot;: &quot;Muestra una pequeña nota en el lado izquierdo o derecho de la pantalla.&quot;
}
&lt;/templatedata&gt;</text>
      <sha1>br17tujnol6nw4w14qgdr4t39o56vdb</sha1>
    </revision>
    <revision>
      <id>436392</id>
      <parentid>436391</parentid>
      <timestamp>2026-10-13T17:41:42Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>119502</id>
      </contributor>
      <origin>436392</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="463" sha1="m9i5p0c6452acssblbktfgh97buoich" xml:space="preserve">&lt;templatedata&gt;
{
	&quot;params&quot;: {
		&quot;1&quot;: {
			&quot;label&quot;: &quot;contenido&quot;,
			&quot;description&quot;: &quot;Contenido de la nota.&quot;,
			&quot;type&quot;: &quot;string&quot;,
			&quot;required&quot;: true
		},
		&quot;margen&quot;: {
			&quot;description&quot;: &quot;En qué lado de la página se mostrará esta nota.&quot;,
			&quot;type&quot;: &quot;string&quot;,
			&quot;suggestedvalues&quot;: [
				&quot;izquierda&quot;,
				&quot;derecha&quot;
			],
			&quot;default&quot;: &quot;izquierda&quot;
		}
	},
	&quot;description&quot;: &quot;Muestra una pequeña nota en el lado izquierdo o derecho de la pantalla.&quot;
}
&lt;/templatedata&gt;</text>
      <sha1>m9i5p0c6452acssblbktfgh97buoich</sha1>
    </revision>
  </page>
  <page>
    <title>Usuario discusión:Luciérnaga de conocimiento</title>
    <ns>3</ns>
    <id>65093</id>
    <revision>
      <id>436473</id>
      <timestamp>2026-10-13T23:41:33Z</timestamp>
      <contributor>
        <username>Mazbel</username>
        <id>57931</id>
      </contributor>
      <comment>Página creada con «{{subst:Bienvenida}}~~~~ == Creación de plantillas == Hola, Luciérnaga de conocimiento:  Te escribo respecto de la creación y utilización de plantillas, principalmente en el libro Haskell. Es necesario revisar su utilidad, evitar duplicaciones y respetar las decisiones comunitarias de borrado.  '''1. Plantillas redundantes y necesidad de justificar su creación'''  En el caso de [[:Plantilla:Haskell/Minitoc]], en el resumen de borrado, señalé que existe :Plant…»</comment>
      <origin>436473</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="7807" sha1="behlez922vwc5xpg4rnptzcb85deyu4" xml:space="preserve">
{| width=&quot;100%&quot; cellspacing=&quot;0&quot; cellpadding=&quot;6&quot; style=&quot;font-size:95%; line-height: 15px; color: var(--color-base); background:var(--background-color-option-yellow, #faf6ed); border: 1px solid var(--border-color-subtle, #faecc8); border-radius: 2px;&quot;
|-
| colspan=&quot;4&quot; style=&quot;color: var(--color-base);background: var(--background-color-content-removed, #faecc8)&quot; |&lt;span style=&quot;font-size: 120%&quot;&gt;'''Hola, {{BASEPAGENAME}}.''' Te damos la bienvenida a Wikilibros en español&lt;/span&gt;
|-
| colspan=&quot;4&quot; | Gracias por participar en el proyecto. Esperamos que la colaboración te resulte agradable y que aproveches tu estancia por aquí. 
|-
| colspan=&quot;4&quot; | [[w:Wikilibros|Wikilibros]] es una colección de libros de texto de contenido libre que surgió en julio de 2003; desde entonces se han establecido varios principios definidos por la comunidad. Por favor, tómate un tiempo para '''explorar los temas siguientes''', antes de comenzar a editar en Wikilibros.
|-
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Crystal Clear app lassist.png|30x30px
default [[Wikilibros:Bienvenida]]
desc none
&lt;/imagemap&gt;
| [[Wikilibros:Bienvenida|'''Página de bienvenida''']].
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Nuvola apps kpdf2.svg|30x30px
default [[Wikilibros:Manual]]
desc none
&lt;/imagemap&gt;
| [[Manual de Wikilibros|'''Manual'''.&lt;br&gt;Manual general de Wikilibros]].
|-
| width=&quot;8%&quot;  align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Crystal Clear app kedit.png|30x30px
default [[Wikilibros:Zona de pruebas]]
desc none
&lt;/imagemap&gt;
| width=&quot;38%&quot; | [[Wikilibros:Zona de pruebas|'''Zona de pruebas'''.&lt;br&gt;Para que realices pruebas de edición]].
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Nuvola apps khelpcenter.png|30x30px
default [[Ayuda:Cómo empezar una página]]
desc none
&lt;/imagemap&gt;
| [[Wikilibros:Ayuda|'''Ayuda'''&lt;br /&gt;Página con enlaces útiles. ]]
|-
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Nuvola apps important yellow.svg|30x30px
default [[Wikilibros:Lo que Wikilibros no es]]
desc none
&lt;/imagemap&gt;
| [[Wikilibros:Lo que Wikilibros no es|'''Cosas que no se deben hacer'''.&lt;br&gt;Resumen de errores más comunes a evitar]].
| width=&quot;8%&quot;  align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Crystal Clear action apply.png|30x30px
default [[w:Ayuda:Cómo se edita una página]]
desc none
&lt;/imagemap&gt;
| [[Manual wiki/Edición|'''Aprende a editar páginas'''.&lt;br&gt;Guía de edición de páginas wiki]].
|-
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Crystal Clear app file-manager.png|30x30px
default [[Wikilibros:Políticas y orientaciones]]
desc none
&lt;/imagemap&gt;
| [[Wikilibros:Políticas y orientaciones|'''Las políticas de Wikilibros'''.&lt;br&gt;Estándares y reglas aprobadas por la comunidad]].
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Nuvola apps ksirc.png|30x30px
default [[Manual wiki]]
desc none
&lt;/imagemap&gt;
| [[Ayuda:Preguntas frecuentes|'''Preguntas frecuentes'''.&lt;br&gt;Lo que mucha gente pregunta]].
|-
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Nuvola apps kteatime.png|30x30px
default [[Wikilibros:Café]]
desc none
&lt;/imagemap&gt;
| [[Wikilibros:Café|'''Café'''.&lt;br&gt;Donde puedes preguntar a otros wikilibristas]].
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Curly Brackets.svg|30x30px
default [[w:Ayuda:Referencia rápida]]
desc none
&lt;/imagemap&gt;
| [[w:Ayuda:Referencia rápida| '''Referencia rápida'''.&lt;br&gt;Un resumen sobre cómo utilizar el wikicódigo]]
|-
| colspan=&quot;4&quot; style=&quot;color: var(--color-base); border-top:1px solid var(--background-color-content-removed, #faecc8);&quot; |
[[Imagen:Signature button.png|right]]
Ésta es tu '''página de discusión''', en la cual puedes recibir mensajes de otros wikilibristas. Para contactar con otro wikilibrista debes escribirle '''en su página de discusión''', o usar [[Plantilla:Respuesta a|la plantilla de respuesta]]; si no, no será notificado. Al final del mensaje debes firmar escribiendo cuatro &lt;code&gt;&lt;nowiki&gt;~~~~&lt;/nowiki&gt;&lt;/code&gt; o presionando el botón mostrado en la imagen. Recuerda que ''los libros no se firman''.
|} Esperamos que pases buenos momentos en Wikilibros.
[[Usuario:Mazbel|&lt;span style=&quot;font-weight:bold; font-family:cursive, serif;&quot;&gt;Mazbel&lt;/span&gt;]] [[Usuario discusión:Mazbel|&lt;span style=&quot;font-size:small; font-family:cursive, serif;&quot;&gt;(Discusión)&lt;/span&gt;]] 23:41 13 oct 2026 (UTC)
== Creación de plantillas ==
Hola, Luciérnaga de conocimiento:

Te escribo respecto de la creación y utilización de plantillas, principalmente en el libro Haskell. Es necesario revisar su utilidad, evitar duplicaciones y respetar las decisiones comunitarias de borrado.

'''1. Plantillas redundantes y necesidad de justificar su creación'''

En el caso de [[:Plantilla:Haskell/Minitoc]], en el resumen de borrado, señalé que existe [[:Plantilla:+ÍndiceSección]] para el mismo propósito. Antes de crear otra plantilla, comprueba si la existente permite resolver lo que necesitas. Si presenta alguna limitación, explica en la discusión del libro qué función adicional buscas y por qué no puede incorporarse a la solución disponible.

Respecto de [[:Plantilla:Color de texto por defecto]], [[:Plantilla:Encabezado3 oculto]] y [[:Plantilla:Haskell/GHCi]], conviene justificar qué ventaja concreta aporta cada una. Una plantilla puede ser útil para reutilizar código o mantener un formato uniforme; sin embargo, cuando únicamente introduce un fragmento sencillo que puede escribirse directamente y no aporta una ventaja de mantenimiento, corresponde valorar su simplificación. El objetivo es mantener el libro comprensible y fácil de editar para cualquier colaborador. Por favor, documenta la finalidad de estas plantillas y revisa si existen alternativas antes de crear otras equivalentes.

'''2. Consultas de borrado'''

[[:Plantilla:!!]] fue incluida expresamente en [[Wikilibros:Consultas de borrado/Archivo/2026#Cinco plantillas sin uso y obsoletas|la consulta de borrado sobre cinco plantillas sin uso y obsoletas]], cerrada el 19 de julio de 2026 con resultado de eliminar. La decisión también abarcó sus páginas de uso.

No corresponde recrear una plantilla manteniendo el problema que motivó su eliminación. Si consideras que existe una necesidad técnica nueva que justifica recuperarla, solicita su restauración en el [[WL:TAB|tablón de bibliotecarios]] y explica qué ha cambiado respecto de los argumentos de la consulta. La recreación de páginas borradas por consulta, en contra del criterio que llevó a su eliminación, está contemplada en el criterio G10 de [[Wikilibros:Política de borrado]].

'''3. Ejercicios y enfoque del proyecto'''

En cuanto a [[:Plantilla:Haskell/Ejercicios]], es importante distinguir la pertinencia de los ejercicios de la necesidad de utilizar una plantilla para presentarlos.

Wikilibros está orientado a la elaboración colaborativa de libros de texto, manuales y otros materiales instructivos. Los ejercicios pueden formar parte de un libro cuando complementan sus explicaciones y mantienen una relación clara con los contenidos.  Si el propósito es desarrollar un curso con actividades, evaluaciones, seguimiento o participación de estudiantes, conviene valorar [[:v:Portada|Wikiversidad]], cuyo enfoque resulta más adecuado para ese tipo de proyecto educativo. En cualquier caso, la creación de una plantilla específica debe aportar una utilidad que justifique su mantenimiento.

Te pido que revises estas cuestiones y que, antes de volver a crear una plantilla eliminada o introducir otra que duplique una función existente, plantees la necesidad en la página de discusión correspondiente o en el [[WL:Café|café]], así podremos acordar una solución útil para el libro y coherente con las decisiones de la comunidad.

Saludos. --[[Usuario:Mazbel|&lt;span style=&quot;font-weight:bold; font-family:cursive, serif;&quot;&gt;Mazbel&lt;/span&gt;]] [[Usuario discusión:Mazbel|&lt;span style=&quot;font-size:small; font-family:cursive, serif;&quot;&gt;(Discusión)&lt;/span&gt;]] 23:41 13 oct 2026 (UTC)</text>
      <sha1>behlez922vwc5xpg4rnptzcb85deyu4</sha1>
    </revision>
    <revision>
      <id>436475</id>
      <parentid>436473</parentid>
      <timestamp>2026-10-14T07:26:41Z</timestamp>
      <contributor>
        <username>Antimundo</username>
        <id>74354</id>
      </contributor>
      <comment>/* Creación de plantillas */ Respuesta</comment>
      <origin>436475</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="8159" sha1="c4t2d6oj3suk3mnue6r9flh8jeb37g1" xml:space="preserve">
{| width=&quot;100%&quot; cellspacing=&quot;0&quot; cellpadding=&quot;6&quot; style=&quot;font-size:95%; line-height: 15px; color: var(--color-base); background:var(--background-color-option-yellow, #faf6ed); border: 1px solid var(--border-color-subtle, #faecc8); border-radius: 2px;&quot;
|-
| colspan=&quot;4&quot; style=&quot;color: var(--color-base);background: var(--background-color-content-removed, #faecc8)&quot; |&lt;span style=&quot;font-size: 120%&quot;&gt;'''Hola, {{BASEPAGENAME}}.''' Te damos la bienvenida a Wikilibros en español&lt;/span&gt;
|-
| colspan=&quot;4&quot; | Gracias por participar en el proyecto. Esperamos que la colaboración te resulte agradable y que aproveches tu estancia por aquí. 
|-
| colspan=&quot;4&quot; | [[w:Wikilibros|Wikilibros]] es una colección de libros de texto de contenido libre que surgió en julio de 2003; desde entonces se han establecido varios principios definidos por la comunidad. Por favor, tómate un tiempo para '''explorar los temas siguientes''', antes de comenzar a editar en Wikilibros.
|-
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Crystal Clear app lassist.png|30x30px
default [[Wikilibros:Bienvenida]]
desc none
&lt;/imagemap&gt;
| [[Wikilibros:Bienvenida|'''Página de bienvenida''']].
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Nuvola apps kpdf2.svg|30x30px
default [[Wikilibros:Manual]]
desc none
&lt;/imagemap&gt;
| [[Manual de Wikilibros|'''Manual'''.&lt;br&gt;Manual general de Wikilibros]].
|-
| width=&quot;8%&quot;  align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Crystal Clear app kedit.png|30x30px
default [[Wikilibros:Zona de pruebas]]
desc none
&lt;/imagemap&gt;
| width=&quot;38%&quot; | [[Wikilibros:Zona de pruebas|'''Zona de pruebas'''.&lt;br&gt;Para que realices pruebas de edición]].
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Nuvola apps khelpcenter.png|30x30px
default [[Ayuda:Cómo empezar una página]]
desc none
&lt;/imagemap&gt;
| [[Wikilibros:Ayuda|'''Ayuda'''&lt;br /&gt;Página con enlaces útiles. ]]
|-
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Nuvola apps important yellow.svg|30x30px
default [[Wikilibros:Lo que Wikilibros no es]]
desc none
&lt;/imagemap&gt;
| [[Wikilibros:Lo que Wikilibros no es|'''Cosas que no se deben hacer'''.&lt;br&gt;Resumen de errores más comunes a evitar]].
| width=&quot;8%&quot;  align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Crystal Clear action apply.png|30x30px
default [[w:Ayuda:Cómo se edita una página]]
desc none
&lt;/imagemap&gt;
| [[Manual wiki/Edición|'''Aprende a editar páginas'''.&lt;br&gt;Guía de edición de páginas wiki]].
|-
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Crystal Clear app file-manager.png|30x30px
default [[Wikilibros:Políticas y orientaciones]]
desc none
&lt;/imagemap&gt;
| [[Wikilibros:Políticas y orientaciones|'''Las políticas de Wikilibros'''.&lt;br&gt;Estándares y reglas aprobadas por la comunidad]].
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Nuvola apps ksirc.png|30x30px
default [[Manual wiki]]
desc none
&lt;/imagemap&gt;
| [[Ayuda:Preguntas frecuentes|'''Preguntas frecuentes'''.&lt;br&gt;Lo que mucha gente pregunta]].
|-
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Nuvola apps kteatime.png|30x30px
default [[Wikilibros:Café]]
desc none
&lt;/imagemap&gt;
| [[Wikilibros:Café|'''Café'''.&lt;br&gt;Donde puedes preguntar a otros wikilibristas]].
| align=&quot;right&quot; | &lt;imagemap&gt;
Imagen:Curly Brackets.svg|30x30px
default [[w:Ayuda:Referencia rápida]]
desc none
&lt;/imagemap&gt;
| [[w:Ayuda:Referencia rápida| '''Referencia rápida'''.&lt;br&gt;Un resumen sobre cómo utilizar el wikicódigo]]
|-
| colspan=&quot;4&quot; style=&quot;color: var(--color-base); border-top:1px solid var(--background-color-content-removed, #faecc8);&quot; |
[[Imagen:Signature button.png|right]]
Ésta es tu '''página de discusión''', en la cual puedes recibir mensajes de otros wikilibristas. Para contactar con otro wikilibrista debes escribirle '''en su página de discusión''', o usar [[Plantilla:Respuesta a|la plantilla de respuesta]]; si no, no será notificado. Al final del mensaje debes firmar escribiendo cuatro &lt;code&gt;&lt;nowiki&gt;~~~~&lt;/nowiki&gt;&lt;/code&gt; o presionando el botón mostrado en la imagen. Recuerda que ''los libros no se firman''.
|} Esperamos que pases buenos momentos en Wikilibros.
[[Usuario:Mazbel|&lt;span style=&quot;font-weight:bold; font-family:cursive, serif;&quot;&gt;Mazbel&lt;/span&gt;]] [[Usuario discusión:Mazbel|&lt;span style=&quot;font-size:small; font-family:cursive, serif;&quot;&gt;(Discusión)&lt;/span&gt;]] 23:41 13 oct 2026 (UTC)
== Creación de plantillas ==
Hola, Luciérnaga de conocimiento:

Te escribo respecto de la creación y utilización de plantillas, principalmente en el libro Haskell. Es necesario revisar su utilidad, evitar duplicaciones y respetar las decisiones comunitarias de borrado.

'''1. Plantillas redundantes y necesidad de justificar su creación'''

En el caso de [[:Plantilla:Haskell/Minitoc]], en el resumen de borrado, señalé que existe [[:Plantilla:+ÍndiceSección]] para el mismo propósito. Antes de crear otra plantilla, comprueba si la existente permite resolver lo que necesitas. Si presenta alguna limitación, explica en la discusión del libro qué función adicional buscas y por qué no puede incorporarse a la solución disponible.

Respecto de [[:Plantilla:Color de texto por defecto]], [[:Plantilla:Encabezado3 oculto]] y [[:Plantilla:Haskell/GHCi]], conviene justificar qué ventaja concreta aporta cada una. Una plantilla puede ser útil para reutilizar código o mantener un formato uniforme; sin embargo, cuando únicamente introduce un fragmento sencillo que puede escribirse directamente y no aporta una ventaja de mantenimiento, corresponde valorar su simplificación. El objetivo es mantener el libro comprensible y fácil de editar para cualquier colaborador. Por favor, documenta la finalidad de estas plantillas y revisa si existen alternativas antes de crear otras equivalentes.

'''2. Consultas de borrado'''

[[:Plantilla:!!]] fue incluida expresamente en [[Wikilibros:Consultas de borrado/Archivo/2026#Cinco plantillas sin uso y obsoletas|la consulta de borrado sobre cinco plantillas sin uso y obsoletas]], cerrada el 19 de julio de 2026 con resultado de eliminar. La decisión también abarcó sus páginas de uso.

No corresponde recrear una plantilla manteniendo el problema que motivó su eliminación. Si consideras que existe una necesidad técnica nueva que justifica recuperarla, solicita su restauración en el [[WL:TAB|tablón de bibliotecarios]] y explica qué ha cambiado respecto de los argumentos de la consulta. La recreación de páginas borradas por consulta, en contra del criterio que llevó a su eliminación, está contemplada en el criterio G10 de [[Wikilibros:Política de borrado]].

'''3. Ejercicios y enfoque del proyecto'''

En cuanto a [[:Plantilla:Haskell/Ejercicios]], es importante distinguir la pertinencia de los ejercicios de la necesidad de utilizar una plantilla para presentarlos.

Wikilibros está orientado a la elaboración colaborativa de libros de texto, manuales y otros materiales instructivos. Los ejercicios pueden formar parte de un libro cuando complementan sus explicaciones y mantienen una relación clara con los contenidos.  Si el propósito es desarrollar un curso con actividades, evaluaciones, seguimiento o participación de estudiantes, conviene valorar [[:v:Portada|Wikiversidad]], cuyo enfoque resulta más adecuado para ese tipo de proyecto educativo. En cualquier caso, la creación de una plantilla específica debe aportar una utilidad que justifique su mantenimiento.

Te pido que revises estas cuestiones y que, antes de volver a crear una plantilla eliminada o introducir otra que duplique una función existente, plantees la necesidad en la página de discusión correspondiente o en el [[WL:Café|café]], así podremos acordar una solución útil para el libro y coherente con las decisiones de la comunidad.

Saludos. --[[Usuario:Mazbel|&lt;span style=&quot;font-weight:bold; font-family:cursive, serif;&quot;&gt;Mazbel&lt;/span&gt;]] [[Usuario discusión:Mazbel|&lt;span style=&quot;font-size:small; font-family:cursive, serif;&quot;&gt;(Discusión)&lt;/span&gt;]] 23:41 13 oct 2026 (UTC)

:Concuerdo con @[[Usuario:Mazbel|Mazbel]] y te agradezco que escribas este comentario porque iba a escribir yo lo mismo. Un saludo e igualmente le doy la bienvenida cordialmente a @[[Usuario:Luciérnaga de conocimiento|Luciérnaga de conocimiento]] [[Usuario:Antimundo|Antimundo]] ([[Usuario discusión:Antimundo|discusión]]) 07:26 14 oct 2026 (UTC)</text>
      <sha1>c4t2d6oj3suk3mnue6r9flh8jeb37g1</sha1>
    </revision>
  </page>
</mediawiki>