Introdução à Química/Hidrocarbonetos

<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="pt">
  <siteinfo>
    <sitename>Wikilivros</sitename>
    <dbname>ptwikibooks</dbname>
    <base>https://pt.wikibooks.org/wiki/Wikilivros:P%C3%A1gina_principal</base>
    <generator>MediaWiki 1.47.0-wmf.23</generator>
    <case>first-letter</case>
    <namespaces>
      <namespace key="-2" case="first-letter">Multimédia</namespace>
      <namespace key="-1" case="first-letter">Especial</namespace>
      <namespace key="0" case="first-letter" />
      <namespace key="1" case="first-letter">Discussão</namespace>
      <namespace key="2" case="first-letter">Utilizador</namespace>
      <namespace key="3" case="first-letter">Utilizador Discussão</namespace>
      <namespace key="4" case="first-letter">Wikilivros</namespace>
      <namespace key="5" case="first-letter">Wikilivros Discussão</namespace>
      <namespace key="6" case="first-letter">Ficheiro</namespace>
      <namespace key="7" case="first-letter">Ficheiro Discussão</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">MediaWiki Discussão</namespace>
      <namespace key="10" case="first-letter">Predefinição</namespace>
      <namespace key="11" case="first-letter">Predefinição Discussão</namespace>
      <namespace key="12" case="first-letter">Ajuda</namespace>
      <namespace key="13" case="first-letter">Ajuda Discussão</namespace>
      <namespace key="14" case="first-letter">Categoria</namespace>
      <namespace key="15" case="first-letter">Categoria Discussão</namespace>
      <namespace key="90" case="first-letter">Tópico</namespace>
      <namespace key="91" case="first-letter">Tópico discussão</namespace>
      <namespace key="92" case="first-letter">Resumo</namespace>
      <namespace key="93" case="first-letter">Resumo discussão</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 Discussão</namespace>
      <namespace key="1728" case="first-letter">Evento</namespace>
      <namespace key="1729" case="first-letter">Evento Discussão</namespace>
      <namespace key="2600" case="first-letter">Topic</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Introdução à Química/Hidrocarbonetos</title>
    <ns>0</ns>
    <id>2152</id>
    <revision>
      <id>589289</id>
      <parentid>486278</parentid>
      <timestamp>2026-10-11T23:05:38Z</timestamp>
      <contributor>
        <username>Innerstream</username>
        <id>73072</id>
      </contributor>
      <minor />
      <origin>589289</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="13884" sha1="8aj907374u8ktc2wnnugl5s2jg58shr" xml:space="preserve">Hidrocarboneto é um composto químico constituído apenas por átomos de carbono e de hidrogênio.

Os hidrocarbonetos naturais são compostos químicos constituídos por átomos de carbono (C) e de hidrogênio (H), aos quais se podem juntar átomos de oxigênio (O), nitrogênio (N) e enxofre (S) dando origem aos compostos orgânicos, classificados de acordo com seus grupos funcionais. São conhecidos alguns milhares de hidrocarbonetos. As diferentes características físicas são uma consequência das diferentes composições moleculares. Contudo, todos os hidrocarbonetos apresentam uma propriedade comum: oxidam-se facilmente libertando calor.

Hidrocarbonetos líquidos geologicamente extraídos são chamados de petróleo (literalmente &quot;óleo de pedra&quot;) ou óleo mineral, enquanto hidrocarbonetos geológicos gasosos são chamados de gás natural. Todos são importantes fontes de combustível. Hidrocarbonetos são de grande importância econômica porque constituem a maioria dos combustíveis fósseis (carvão, petróleo,gás natural, etc.); vários outros produtos como biocombustíveis, plásticos, ceras, solventes e óleos são compostos orgânicos cuja estrutura básica é formada por hidrocarbonetos (mas que não são hidrocarbonetos por possuírem outros átomos além do carbono e hidrogênio).

== Introdução ==
Os hidrocarbonetos são classificados de acordo com sua saturação, que posteriormente servirá para nomeá-lo. O primeiro passo é verificar a presença de ligações duplas e triplas. Se houver, é necessário [[Introdução à Química/Cadeias carbônicas|numerar os átomos de carbono da cadeia principal]]. De acordo com a quantidade de insaturações encontradas, o hidrocarboneto receberá uma respectiva classificação. É preciso, ainda, observar a presença de ciclos. A relação entre as ligações, com os respectivos grupos de hidrocarbonetos, está listada abaixo:
{| {{prettytable}} width=&quot;30%&quot;
! width=&quot;25%&quot; |Triplas
! width=&quot;25%&quot; |Duplas
! width=&quot;25%&quot; |Acíclico
! width=&quot;25%&quot; |Cíclico
|-
|&lt;center&gt;0&lt;/center&gt;
|&lt;center&gt;0&lt;/center&gt;
|Alcano
|Ciclano
|-
|&lt;center&gt;1&lt;/center&gt;
|&lt;center&gt;0&lt;/center&gt;
|Alcino
|Ciclino&lt;nowiki&gt;*&lt;/nowiki&gt;
|-
|&lt;center&gt;2&lt;/center&gt;
|&lt;center&gt;0&lt;/center&gt;
|Alcadiino
!
|-
|&lt;center&gt;3&lt;/center&gt;
|&lt;center&gt;0&lt;/center&gt;
|Alcatriino&lt;nowiki&gt;*&lt;/nowiki&gt;
!
|-
|&lt;center&gt;0&lt;/center&gt;
|&lt;center&gt;1&lt;/center&gt;
|Alceno
|Cicleno
|-
|&lt;center&gt;0&lt;/center&gt;
|&lt;center&gt;2&lt;/center&gt;
|Alcadieno
|Ciclodieno&lt;nowiki&gt;*&lt;/nowiki&gt;
|-
|&lt;center&gt;0&lt;/center&gt;
|&lt;center&gt;3&lt;/center&gt;
|Alcatrieno&lt;nowiki&gt;*&lt;/nowiki&gt;
|Ciclotrieno&lt;nowiki&gt;*&lt;/nowiki&gt;
|}
&lt;nowiki&gt;*&lt;/nowiki&gt;Compostos raros

Há duas formas de se obter um hidrocarboneto qualquer, pela fórmula estrutural - em que cada estrutura representa um hidrocarboneto -,e pela fórmula molecular (cada fórmula pode identificar diversos hidrocarbonetos).

== Pela fórmula estrutural ==
Utilizando-se da fórmula estrutural, é fácil identificar o hidrocarboneto. Veja alguns exemplos abaixo:
&lt;gallery&gt;
File:Pentan Skelett.svg|Cadeia acíclica&lt;br&gt;Nenhuma ligação tripla&lt;br&gt;Nenhuma ligação dupla&lt;br&gt;'''Alcano'''
File:1-Butene.svg|Cadeia acíclica&lt;br&gt;Nenhuma ligação tripla&lt;br&gt;Uma ligação dupla&lt;br&gt;'''Alceno'''
File:1,7-Octadiene.svg|Cadeia acíclica&lt;br&gt;Nenhuma ligação tripla&lt;br&gt;Duas ligações duplas&lt;br&gt;'''Alcadieno'''
File:3-hexyne.png|Cadeia acíclica&lt;br&gt;Uma ligação tripla&lt;br&gt;Nenhuma ligação dupla&lt;br&gt;'''Alcino'''
|Cadeia cíclica&lt;br&gt;Nenhuma ligação tripla&lt;br&gt;Duas ligações duplas&lt;br&gt;'''Ciclodieno'''
File:Cyclohexyne.svg|Cadeia cíclica&lt;br&gt;Uma ligação tripla&lt;br&gt;Nenhuma ligação dupla&lt;br&gt;'''Ciclino'''
File:Vinylacetylene-2D-skeletal.png|Cadeia acíclica&lt;br&gt;Uma ligação tripla&lt;br&gt;Uma ligação dupla&lt;br&gt;'''Alceno/Alcino'''
&lt;/gallery&gt;

== Pela fórmula molecular ==
Considerando-se a fórmula molecular, encontraremos todas as possibilidade de hidrocarbonetos com tal fórmula. Para isto, utiliza-se a seguinte equação:
:&lt;math&gt;a + 2C - H = 4x + 2y&lt;/math&gt;

Onde:
*'''a''' corresponde a 2 nos compostos acíclicos e 0 nos cíclicos;
*'''C''' é a quantidade de átomos de carbono da substância;
*'''H''' a quantia de hidrogênios;
*'''x''' o número de ligações triplas;
*'''y''' o número de ligações duplas do hidrocarboneto.

A tabela abaixo exibe a classificação conforme os resultados obtidos:
{| {{prettytable}} width=&quot;30%&quot;
! width=&quot;25%&quot; |''x''&lt;br&gt;[triplas]
! width=&quot;25%&quot; |''y''&lt;br&gt;[duplas]
! width=&quot;25%&quot; |Acíclico&lt;br&gt;a=2
! width=&quot;25%&quot; |Cíclico&lt;br&gt;a=0
|-
|&lt;center&gt;0&lt;/center&gt;
|&lt;center&gt;0&lt;/center&gt;
|Alcano
|Ciclano
|-
|&lt;center&gt;1&lt;/center&gt;
|&lt;center&gt;0&lt;/center&gt;
|Alcino
|Ciclino&lt;nowiki&gt;*&lt;/nowiki&gt;
|-
|&lt;center&gt;2&lt;/center&gt;
|&lt;center&gt;0&lt;/center&gt;
|Alcadiino
!
|-
|&lt;center&gt;3&lt;/center&gt;
|&lt;center&gt;0&lt;/center&gt;
|Alcatriino&lt;nowiki&gt;*&lt;/nowiki&gt;
!
|-
|&lt;center&gt;0&lt;/center&gt;
|&lt;center&gt;1&lt;/center&gt;
|Alceno
|Cicleno
|-
|&lt;center&gt;0&lt;/center&gt;
|&lt;center&gt;2&lt;/center&gt;
|Alcadieno
|Ciclodieno&lt;nowiki&gt;*&lt;/nowiki&gt;
|-
|&lt;center&gt;0&lt;/center&gt;
|&lt;center&gt;3&lt;/center&gt;
|Alcatrieno&lt;nowiki&gt;*&lt;/nowiki&gt;
|Ciclotrieno&lt;nowiki&gt;*&lt;/nowiki&gt;
|}
&lt;nowiki&gt;*&lt;/nowiki&gt;Compostos raros

Existem substâncias híbridas, isto é, possuem características de mais de um grupo de hidrocarbonetos. Apresentam, logo, ligações duplas e triplas (valores para ''x'' e ''y''), como é o caso do vinilacetileno (x = 1; y = 1). Se à esquerda da equação o resulado for negativo, o composto não existe. Além disto, ''x'' e ''y'' sempre pertencem ao conjunto dos números naturais.

{{Quadro||pontilhado=sim
|1 = Exemplos
|2 = &lt;br&gt;
{{ênfase|'''1)''' Suponhamos que o composto C&lt;sub&gt;8&lt;/sub&gt;H&lt;sub&gt;14&lt;/sub&gt; não seja ramificado e seja acíclico, qual suas possíveis classificações?}}
[[Imagem:Oct-1-yne.svg|thumb|150px|right|C&lt;sub&gt;8&lt;/sub&gt;H&lt;sub&gt;14&lt;/sub&gt; (1; 0)]]
[[Imagem:1,7-octadieen.png|thumb|150px|right|C&lt;sub&gt;8&lt;/sub&gt;H&lt;sub&gt;14&lt;/sub&gt; (0; 2)]]
Por ser acíclico, assume o valor 2 para ''a'':
:&lt;math&gt;2 + 2 \times 8 - 14 = 4x + 2y&lt;/math&gt;
:&lt;math&gt;4 = 4x + 2y&lt;/math&gt;
Estabelecendo os possíveis pares ordenados que satisfaçam a equação, teremos:
:&lt;math&gt;4 = (1; 0), (0; 2)&lt;/math&gt;
Portanto, tal hidrocarboneto pode ser um alcino ou um alcadieno.

{{ênfase|'''2)''' Sabendo que o composto C&lt;sub&gt;5&lt;/sub&gt;H&lt;sub&gt;12&lt;/sub&gt; é normal, qual sua classificação?}}
Primeiramente consideraremos como acíclico:
:&lt;math&gt;2 + 2 \times 5 - 12 = 4x + 2y&lt;/math&gt;
:&lt;math&gt;0 = 4x + 2y&lt;/math&gt;
[[Ficheiro:Pentane-2D-Skeletal.svg|right|150px|thumb|C&lt;sub&gt;5&lt;/sub&gt;H&lt;sub&gt;12&lt;/sub&gt; (0; 0)]]
:&lt;math&gt;0 = (0;0)&lt;/math&gt;
Agora ''a'' adota o valor de zero, se tratando de um hidrocarboneto cíclico:
:&lt;math&gt;0 + 2 \times 5 - 12 = 4x + 2y&lt;/math&gt;
:&lt;math&gt;-2 = 4x + 2y&lt;/math&gt;
Assim, o hidrocarboneto C&lt;sub&gt;5&lt;/sub&gt;H&lt;sub&gt;12&lt;/sub&gt; de cadeia normal, nunca será cíclico (já que o resultado foi menor que zero), e sempre será um alcano.
}}
=== Regra das ligações triplas ===
Dependendo dos valores encontrados para x, o composto não existirá: 
*Para que um composto acíclico, em que C é par e &lt;math&gt;\frac C x = 2&lt;/math&gt;, seja real, obrigatoriamente, y = 0;
*Para qualquer outro composto, seja cíclico, acíclico com C ímpar ou acíclico com C par e &lt;math&gt;\frac C x &gt; 2&lt;/math&gt;, seja real:
:&lt;math&gt;C - 1 \ge 2x + y&lt;/math&gt;

{{Quadro||pontilhado=sim
|1 = Exemplos
|2 = &lt;br&gt;
{{ênfase|'''3)''' O composto C&lt;sub&gt;3&lt;/sub&gt;H&lt;sub&gt;3&lt;/sub&gt;, de cadeia normal, existe?}}
:&lt;math&gt;2 + 2 \times 3 - 3 = x + y&lt;/math&gt;
:&lt;math&gt;5 = (1;1), (0;3)&lt;/math&gt;
Aplicando-se a regra das ligações triplas:
:&lt;math&gt;2 \ge 2x + y&lt;/math&gt;
Substituindo-se pelos pares ordenados:
:&lt;math&gt;2 \times 1 + 1 = 3&lt;/math&gt;
:&lt;math&gt;2 \times 0 + 3 = 3&lt;/math&gt;
Deste modo, não existe C&lt;sub&gt;3&lt;/sub&gt;H&lt;sub&gt;3&lt;/sub&gt;, pois 3 &gt; 2.
{{ênfase|'''4)''' Quais as possíveis insaturações para o composto C&lt;sub&gt;6&lt;/sub&gt;H&lt;sub&gt;2&lt;/sub&gt;, sendo este de cadeia normal?}}
:&lt;math&gt;2 + 2 \times 6 - 2 = x + y&lt;/math&gt;
:&lt;math&gt;12 = (3;0), (2;2), (1;4), (0;6)&lt;/math&gt;
Para o primeiro par ordenado, teremos:
:&lt;math&gt;\frac 6 3 = 2&lt;/math&gt;
Portanto, a combinação (3; 0) é possível. Aos demais pares:
:&lt;math&gt;5 \ge 2 \times 2 + 2 = 6&lt;/math&gt;
:&lt;math&gt;5 \ge 2 \times 1 + 4 = 6&lt;/math&gt;
:&lt;math&gt;5 \ge 2 \times 0 + 6 = 6&lt;/math&gt;
Como 6 &gt; 5, os pares (2;2), (1;4) e (0;6) são impossíveis para esta substância.

Resta verificar se o par (3;0) é possível no caso de ser cíclico:
:&lt;math&gt;5 \ge 2 \times 3 + 0 = 6&lt;/math&gt;
Conclui-se que, para uma cadeia normal, C&lt;sub&gt;6&lt;/sub&gt;H&lt;sub&gt;2&lt;/sub&gt; obrigatoriamente é um alcatriino.
}}

== Aromáticos ==
Os hidrocarbonetos aromáticos são aqueles que apresentam um anel benzênico, portanto, todos são cíclicos. Os aromáticos normalmente são designados por uma nomenclatura popular, pois a nomenclatura sistemática da IUPAC é um tanto grande para estes. Confira abaixo os principais hidrocarbonetos aromáticos e sua respectiva nomenclatura popular e sistemática:
&lt;gallery&gt;
Ficheiro:Benzene-aromatic-3D-balls.png|'''Benzeno'''
Ficheiro:Naphthalene-3D-balls.png|'''Naftaleno''' (biciclo[4.4.0]deca-1,3,5,7,9-penteno)
Ficheiro:Anthracene-3D-balls.png|'''Antraceno'''
Ficheiro:Phenanthrene-3D-balls.png|'''Fenantreno'''
Ficheiro:Tetracene-3D-balls.png|'''Tetraceno'''
Ficheiro:Pyrene-3D-balls.png|'''Pireno'''
Ficheiro:Triphenylene-3D-balls.png|'''Trifenileno'''
&lt;/gallery&gt;

== Nomenclatura ==
Os compostos da química orgânica têm a seguinte nomenclatura:
{{ênfase|&lt;center&gt;'''PREFIXO + RAIZ + SUFIXO'''&lt;/center&gt;}}

O prefixo é indicado pela quantidade de átomos de carbono na cadeia:
[[Imagem:Methan Lewis.svg|150px|right|thumb|Por ter apenas um carbono, o composto acima recebe o prefixo ''met-'']]
*1 carbono - '''met'''
*2 carbonos - '''et'''
*3 carbonos - '''prop'''
*4 carbonos - '''but'''
*5 carbonos - '''pent'''
*6 carbonos - '''hex'''
*7 carbonos - '''hept'''
*8 carbonos - '''oct'''
*9 carbonos - '''non'''
*10 carbonos - '''dec'''

Cada grupo de hidrocarbonetos tem uma raiz própria:
[[Imagem:Methan Lewis.svg|150px|right|thumb|Não tendo insaturações, recebe a raiz ''-an-'' e o sufixo ''-o'' por ser hidrocarboneto: '''metano''']]
{| {{prettytable}} width=&quot;20%&quot;
! width=&quot;10%&quot;| Grupo (par ordenado)
! width=&quot;10%&quot;| Raiz
|-
|Alcanos (0;0)
|'''an'''
|-
|Alcinos (1;0)
|'''in'''
|-
|Alcadiinos (2;0)
|'''diin'''
|-
|Alcatriinos (3;0)
|'''triin'''
|-
|Alcenos (0;1)
|'''en'''
|-
|Alcadienos (0;2)
|'''dien'''
|-
|Alcatrienos (0;3)
|'''trien'''
|}

Em compostos mistos, todas as raizes devem estar presentes no nome. Para os cíclicos, basta acrescentar o morfema '''ciclo''' antes do prefixo. Acíclicos que não sejam alcanos (0,0) e cíclicos que não sejam ciclanos (0,0), ciclinos (1,0) e ciclenos (0,1) devem exibir a posição da insaturação na cadeia.

O sufixo comum a todos hidrocarbonetos é o sufixo '''o'''.

{{ênfase|'''5)''' Quais os possíveis nomes do composto C&lt;sub&gt;8&lt;/sub&gt;H&lt;sub&gt;14&lt;/sub&gt;?}}
:O composto tem os pares ordenados (1;0) e (0;2), já calculados no primeiro exemplo. Assim, para (1;0):
*'''Prefixo''': ''oct''
*'''Raiz''': ''in''
*'''Sufixo''': ''o''
O composto recebe o nome de ''oct-n-ino'' para ''n'' a posição da insaturação da cadeia:
{| class=&quot;caixaPP&quot; style=&quot;padding:10px 10px 10px 10px; width:100%; border-color: #712F26;&quot;
|&lt;center&gt;
{|
|
&lt;math&gt;\underbrace{ \mathbf{CH} {\color{Red}\equiv}  \mathbf{C} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_3} }_{ }&lt;/math&gt;
|
&lt;math&gt;\underbrace{ \mathbf{CH_3} -  \mathbf{C} {\color{Red}\equiv} \mathbf{C} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_3} }_{ }&lt;/math&gt;
|-
|&lt;center&gt;'''Oct-1-ino'''&lt;/center&gt;&lt;br&gt;
|&lt;center&gt;'''Oct-2-ino'''&lt;/center&gt;&lt;br&gt;
|-
|
&lt;math&gt;\underbrace{ \mathbf{CH_3} -  \mathbf{CH_2} - \mathbf{C} {\color{Red}\equiv} \mathbf{C} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_3} }_{ }&lt;/math&gt;
|
&lt;math&gt;\underbrace{ \mathbf{CH_3} -  \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{C} {\color{Red}\equiv} \mathbf{C} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_3} }_{ }&lt;/math&gt;
|-
|&lt;center&gt;'''Oct-3-ino'''&lt;/center&gt;
|&lt;center&gt;'''Oct-4-ino'''&lt;/center&gt;
|}
&lt;/center&gt;
|}

Para (0;2):
*'''Prefixo''': ''octa''
*'''Raiz''': ''dien''
*'''Sufixo''': ''o''
O composto recebe o nome de ''octa-m,n-dieno'' para ''m'' e ''n'' a posição das insaturações da cadeia. Alguns exemplos:
{| class=&quot;caixaPP&quot; style=&quot;padding:10px 10px 10px 10px; width:100%; border-color: #712F26;&quot;
|&lt;center&gt;
{|
|
&lt;math&gt;\underbrace{ \mathbf{CH_2} {\color{Red}=}  \mathbf{C} {\color{Red}=} \mathbf{CH} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_3} }_{ }&lt;/math&gt;
|
&lt;math&gt;\underbrace{ \mathbf{CH_2} {\color{Red}=}  \mathbf{CH} - \mathbf{CH_2} - \mathbf{CH} {\color{Red}=} \mathbf{CH} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_3} }_{ }&lt;/math&gt;
|-
|&lt;center&gt;'''Octa-1,2-dieno'''&lt;/center&gt;&lt;br&gt;
|&lt;center&gt;'''Octa-1,4-dieno'''&lt;/center&gt;&lt;br&gt;
|-
|
&lt;math&gt;\underbrace{ \mathbf{CH_3} -  \mathbf{CH} {\color{Red}=} \mathbf{CH} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH} {\color{Red}=} \mathbf{CH_2} }_{ }&lt;/math&gt;
|
&lt;math&gt;\underbrace{ \mathbf{CH_3} -  \mathbf{CH_2} - \mathbf{CH_2} - \mathbf{CH} {\color{Red}=} \mathbf{CH} - \mathbf{CH} {\color{Red}=} \mathbf{CH} - \mathbf{CH_3} }_{ }&lt;/math&gt;
|-
|&lt;center&gt;'''Octa-2,7-dieno'''&lt;/center&gt;
|&lt;center&gt;'''Octa-2,4-dieno'''&lt;/center&gt;
|}
&lt;/center&gt;
|}

Veja mais exemplos:
&lt;gallery&gt;
File:Pentan Skelett.svg|5C = ''pent''&lt;br&gt;(0;0) = ''an''&lt;br&gt;hidrocarboneto = ''o''&lt;br&gt;'''Pentano'''
File:1-Butene.svg|4C = ''but''&lt;br&gt;(0;1) = ''1-en''&lt;br&gt;hidrocarboneto = ''o''&lt;br&gt;'''But-1-eno'''
File:2-Butene.svg|4C = ''but''&lt;br&gt;(0;1) = ''2-en''&lt;br&gt;hidrocarboneto = ''o''&lt;br&gt;'''But-2-eno'''
File:1,7-octadieen.png|8C = ''oct''&lt;br&gt;(0;2) = ''1,7-dien''&lt;br&gt;hidrocarboneto = ''o''&lt;br&gt;'''Octa-1,7-dieno'''
File:3-hexyne.png|6C = ''hex''&lt;br&gt;(1;0) = ''3-in''&lt;br&gt;hidrocarboneto = ''o''&lt;br&gt;'''Hex-3-ino'''
File:Cyclohexyne.svg|6C = ''hex''&lt;br&gt;(1;0) = ''in''&lt;br&gt;hidrocarboneto = ''o''&lt;br&gt;'''Ciclo-hexino'''
File:Vinylacetylene-2D-skeletal.png|4C = ''but''&lt;br&gt;(1;1) = 1-en-3-in&lt;br&gt;hidrocarboneto = ''o''&lt;br&gt;'''But-1-en-3-ino'''
&lt;/gallery&gt;


{{AutoCat}}</text>
      <sha1>8aj907374u8ktc2wnnugl5s2jg58shr</sha1>
    </revision>
  </page>
  <page>
    <title>Haskell/Instalação e aritmética</title>
    <ns>0</ns>
    <id>29708</id>
    <revision>
      <id>589292</id>
      <parentid>448709</parentid>
      <timestamp>2026-10-12T00:15:24Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>67836</id>
      </contributor>
      <origin>589292</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4899" sha1="nf95pvqktly231n30n2iteo0wi1cjbo" xml:space="preserve">== Instalando o Haskell ==
Haskell é uma ''linguagem de programação'', isto é, uma linguagem na qual os seres humanos podem expressar como os computadores devem se comportar. É como escrever uma receita de cozinha: você escreve a receita e o computador a executa.

Para executar programas em Haskell, você precisa de um programa especial chamado ''compilador'' de Haskell. Um compilador recebe o código escrito em Haskell e o traduz para ''código de máquina'', uma linguagem mais elementar que o computador entende. Usando a analogia da cozinha, você escreve uma receita (seu programa em Haskell) e um cozinheiro (um programa compilador) faz o trabalho de combinar os ingredientes reais para preparar um prato comestível (um arquivo executável). Naturalmente, não é fácil obter a receita a partir do prato pronto (assim como não é possível obter o código Haskell a partir do executável depois que ele é compilado).

Para começar, visite [https://www.haskell.org/downloads haskell.org/downloads] para consultar as instruções mais recentes. Atualmente, o método recomendado é usar [https://haskell.org/ghcup GHCup]. Use-o para instalar a versão mais recente recomendada do GHC, &lt;code&gt;cabal&lt;/code&gt; (não &lt;code&gt;stack&lt;/code&gt;) e o servidor de linguagem Haskell. Você deve usar &lt;code&gt;cabal&lt;/code&gt; para instalar qualquer biblioteca Haskell de que precisar. Abordaremos o uso de &lt;code&gt;cabal&lt;/code&gt; em detalhes em [[Haskell/Packaging]]

{{body note|1=
Usuários de Linux:

'''É fortemente desaconselhado instalar qualquer componente relacionado ao Haskell usando os repositórios de pacotes e o gerenciador de pacotes do sistema (a menos que você esteja usando Fedora ou NixOS). Especificamente, distribuições como Arch Linux e Debian gerenciam os pacotes Haskell muito mal, o que prejudica a experiência com as ferramentas de desenvolvimento. Use GHCup e Cabal, conforme indicado acima.'''
}}

Para testar apenas alguns conceitos básicos de Haskell sem baixar e instalar nada, existe um [https://play.haskell.org/ ambiente de testes] que inclui alguns pacotes por padrão. A maioria das instruções deste Wikilivro também funcionará nesse ambiente, embora ele não aceite entradas do usuário.

== Primeiro código ==

Após a instalação, escreveremos nosso primeiro código em Haskell usando o programa chamado '''GHCi''' (o 'i' significa ''interativo''). Dependendo do seu sistema operacional, siga estas etapas:

No Windows: clique em Iniciar, depois em Executar, digite 'cmd' e pressione Enter. Em seguida, digite &lt;code&gt;ghci&lt;/code&gt; e pressione Enter novamente.

No MacOS: abra o aplicativo &quot;Terminal&quot;, localizado na pasta &quot;Aplicativos/Utilitários&quot;, digite &lt;code&gt;ghci&lt;/code&gt; na janela que aparecerá e pressione Enter.

No Linux: abra um terminal e execute &lt;code&gt;ghci&lt;/code&gt;.

Você deverá obter uma saída semelhante à seguinte:

&lt;pre&gt;
GHCi, version 8.10.7: http://www.haskell.org/ghc/  :? for help
Prelude&gt; 
&lt;/pre&gt;

A primeira parte indica a versão do GHCi e informa como obter ajuda no próprio GHCi. A parte &lt;code&gt;Prelude&gt;&lt;/code&gt; é conhecida como ''prompt''. É nesse local que você digita os comandos, e o GHCi responde com os resultados. O prompt também informa que o módulo atualmente carregado é &lt;code&gt;Prelude&lt;/code&gt;, que dá acesso à maioria das funções predefinidas.

Agora vamos experimentar algumas operações aritméticas básicas:

{{Haskell/GHCi|1=
Prelude&gt; 2 + 2
4
Prelude&gt; 5 + 4 * 3
17
Prelude&gt; 2 ^ 5
32
}}

Esses operadores correspondem aos encontrados na maioria das outras linguagens de programação: &lt;code&gt;+&lt;/code&gt; é a adição, &lt;code&gt;*&lt;/code&gt; é a multiplicação e &lt;code&gt;^&lt;/code&gt; é a exponenciação (elevar um número a uma potência, ou seja, &lt;math&gt;a ^ b&lt;/math&gt;). Como mostra o segundo exemplo, Haskell segue a ordem convencional das operações matemáticas (por exemplo, a multiplicação é efetuada antes da adição).

Agora você já sabe usar Haskell como uma calculadora. Na verdade, Haskell é ''sempre'' uma calculadora — só que muito poderosa, capaz de trabalhar não apenas com números, mas também com outros objetos, como caracteres, listas, funções, árvores e até mesmo outros programas (se você ainda não conhece esses termos, não se preocupe).

Para sair do GHCi quando terminar, use &lt;code&gt;&lt;/code&gt; (ou simplesmente &lt;code&gt;&lt;/code&gt;):

{{Haskell/GHCi|
Prelude&gt; 
Leaving GHCi.
}}

O GHCi é um ambiente de desenvolvimento poderoso. À medida que avançarmos, aprenderemos a carregar arquivos com código-fonte no GHCi e a avaliar diferentes partes deles.

Se tudo estiver claro até aqui (caso contrário, use a página de discussão e ajude a melhorar este Wikilivro!), você estará pronto para o próximo capítulo, no qual apresentaremos alguns dos conceitos básicos de Haskell e criaremos nossas primeiras funções em Haskell.

{{Auto category}}

{{AutoCat}}
[[Categoria:Livro/Haskell/Arquivo]]</text>
      <sha1>nf95pvqktly231n30n2iteo0wi1cjbo</sha1>
    </revision>
    <revision>
      <id>589293</id>
      <parentid>589292</parentid>
      <timestamp>2026-10-12T00:15:40Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>67836</id>
      </contributor>
      <origin>589293</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4897" sha1="2lt55ckel7zr96eokdhkn17rqvcrb6o" xml:space="preserve">== Instalando o Haskell ==
Haskell é uma ''linguagem de programação'', isto é, uma linguagem na qual os seres humanos podem expressar como os computadores devem se comportar. É como escrever uma receita de cozinha: você escreve a receita e o computador a executa.

Para executar programas em Haskell, você precisa de um programa especial chamado ''compilador'' de Haskell. Um compilador recebe o código escrito em Haskell e o traduz para ''código de máquina'', uma linguagem mais elementar que o computador entende. Usando a analogia da cozinha, você escreve uma receita (seu programa em Haskell) e um cozinheiro (um programa compilador) faz o trabalho de combinar os ingredientes reais para preparar um prato comestível (um arquivo executável). Naturalmente, não é fácil obter a receita a partir do prato pronto (assim como não é possível obter o código Haskell a partir do executável depois que ele é compilado).

Para começar, visite [https://www.haskell.org/downloads haskell.org/downloads] para consultar as instruções mais recentes. Atualmente, o método recomendado é usar [https://haskell.org/ghcup GHCup]. Use-o para instalar a versão mais recente recomendada do GHC, &lt;code&gt;cabal&lt;/code&gt; (não &lt;code&gt;stack&lt;/code&gt;) e o servidor de linguagem Haskell. Você deve usar &lt;code&gt;cabal&lt;/code&gt; para instalar qualquer biblioteca Haskell de que precisar. Abordaremos o uso de &lt;code&gt;cabal&lt;/code&gt; em detalhes em [[Haskell/Packaging]]

{{body note|1=
Usuários de Linux:

'''É fortemente desaconselhado instalar qualquer componente relacionado ao Haskell usando os repositórios de pacotes e o gerenciador de pacotes do sistema (a menos que você esteja usando Fedora ou NixOS). Especificamente, distribuições como Arch Linux e Debian gerenciam os pacotes Haskell muito mal, o que prejudica a experiência com as ferramentas de desenvolvimento. Use GHCup e Cabal, conforme indicado acima.'''
}}

Para testar apenas alguns conceitos básicos de Haskell sem baixar e instalar nada, existe um [https://play.haskell.org/ ambiente de testes] que inclui alguns pacotes por padrão. A maioria das instruções deste Wikilivro também funcionará nesse ambiente, embora ele não aceite entradas do usuário.

== Primeiro código ==

Após a instalação, escreveremos nosso primeiro código em Haskell usando o programa chamado '''GHCi''' (o 'i' significa ''interativo''). Dependendo do seu sistema operacional, siga estas etapas:

No Windows: clique em Iniciar, depois em Executar, digite 'cmd' e pressione Enter. Em seguida, digite &lt;code&gt;ghci&lt;/code&gt; e pressione Enter novamente.

No MacOS: abra o aplicativo &quot;Terminal&quot;, localizado na pasta &quot;Aplicativos/Utilitários&quot;, digite &lt;code&gt;ghci&lt;/code&gt; na janela que aparecerá e pressione Enter.

No Linux: abra um terminal e execute &lt;code&gt;ghci&lt;/code&gt;.

Você deverá obter uma saída semelhante à seguinte:

&lt;pre&gt;
GHCi, version 8.10.7: http://www.haskell.org/ghc/  :? for help
Prelude&gt; 
&lt;/pre&gt;

A primeira parte indica a versão do GHCi e informa como obter ajuda no próprio GHCi. A parte &lt;code&gt;Prelude&gt;&lt;/code&gt; é conhecida como ''prompt''. É nesse local que você digita os comandos, e o GHCi responde com os resultados. O prompt também informa que o módulo atualmente carregado é &lt;code&gt;Prelude&lt;/code&gt;, que dá acesso à maioria das funções predefinidas.

Agora vamos experimentar algumas operações aritméticas básicas:

{{HaskellGHCi|1=
Prelude&gt; 2 + 2
4
Prelude&gt; 5 + 4 * 3
17
Prelude&gt; 2 ^ 5
32
}}

Esses operadores correspondem aos encontrados na maioria das outras linguagens de programação: &lt;code&gt;+&lt;/code&gt; é a adição, &lt;code&gt;*&lt;/code&gt; é a multiplicação e &lt;code&gt;^&lt;/code&gt; é a exponenciação (elevar um número a uma potência, ou seja, &lt;math&gt;a ^ b&lt;/math&gt;). Como mostra o segundo exemplo, Haskell segue a ordem convencional das operações matemáticas (por exemplo, a multiplicação é efetuada antes da adição).

Agora você já sabe usar Haskell como uma calculadora. Na verdade, Haskell é ''sempre'' uma calculadora — só que muito poderosa, capaz de trabalhar não apenas com números, mas também com outros objetos, como caracteres, listas, funções, árvores e até mesmo outros programas (se você ainda não conhece esses termos, não se preocupe).

Para sair do GHCi quando terminar, use &lt;code&gt;&lt;/code&gt; (ou simplesmente &lt;code&gt;&lt;/code&gt;):

{{HaskellGHCi|
Prelude&gt; 
Leaving GHCi.
}}

O GHCi é um ambiente de desenvolvimento poderoso. À medida que avançarmos, aprenderemos a carregar arquivos com código-fonte no GHCi e a avaliar diferentes partes deles.

Se tudo estiver claro até aqui (caso contrário, use a página de discussão e ajude a melhorar este Wikilivro!), você estará pronto para o próximo capítulo, no qual apresentaremos alguns dos conceitos básicos de Haskell e criaremos nossas primeiras funções em Haskell.

{{Auto category}}

{{AutoCat}}
[[Categoria:Livro/Haskell/Arquivo]]</text>
      <sha1>2lt55ckel7zr96eokdhkn17rqvcrb6o</sha1>
    </revision>
    <revision>
      <id>589294</id>
      <parentid>589293</parentid>
      <timestamp>2026-10-12T00:19:26Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>67836</id>
      </contributor>
      <origin>589294</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4901" sha1="155kl42uult3tur1lr5hqlqdq2ecag7" xml:space="preserve">== Instalando o Haskell ==
Haskell é uma ''linguagem de programação'', isto é, uma linguagem na qual os seres humanos podem expressar como os computadores devem se comportar. É como escrever uma receita de cozinha: você escreve a receita e o computador a executa.

Para executar programas em Haskell, você precisa de um programa especial chamado ''compilador'' de Haskell. Um compilador recebe o código escrito em Haskell e o traduz para ''código de máquina'', uma linguagem mais elementar que o computador entende. Usando a analogia da cozinha, você escreve uma receita (seu programa em Haskell) e um cozinheiro (um programa compilador) faz o trabalho de combinar os ingredientes reais para preparar um prato comestível (um arquivo executável). Naturalmente, não é fácil obter a receita a partir do prato pronto (assim como não é possível obter o código Haskell a partir do executável depois que ele é compilado).

Para começar, visite [https://www.haskell.org/downloads haskell.org/downloads] para consultar as instruções mais recentes. Atualmente, o método recomendado é usar [https://haskell.org/ghcup GHCup]. Use-o para instalar a versão mais recente recomendada do GHC, &lt;code&gt;cabal&lt;/code&gt; (não &lt;code&gt;stack&lt;/code&gt;) e o servidor de linguagem Haskell. Você deve usar &lt;code&gt;cabal&lt;/code&gt; para instalar qualquer biblioteca Haskell de que precisar. Abordaremos o uso de &lt;code&gt;cabal&lt;/code&gt; em detalhes em [[Haskell/Packaging]]

{{Nota no corpo|1=
Usuários de Linux:

'''É fortemente desaconselhado instalar qualquer componente relacionado ao Haskell usando os repositórios de pacotes e o gerenciador de pacotes do sistema (a menos que você esteja usando Fedora ou NixOS). Especificamente, distribuições como Arch Linux e Debian gerenciam os pacotes Haskell muito mal, o que prejudica a experiência com as ferramentas de desenvolvimento. Use GHCup e Cabal, conforme indicado acima.'''
}}

Para testar apenas alguns conceitos básicos de Haskell sem baixar e instalar nada, existe um [https://play.haskell.org/ ambiente de testes] que inclui alguns pacotes por padrão. A maioria das instruções deste Wikilivro também funcionará nesse ambiente, embora ele não aceite entradas do usuário.

== Primeiro código ==

Após a instalação, escreveremos nosso primeiro código em Haskell usando o programa chamado '''GHCi''' (o 'i' significa ''interativo''). Dependendo do seu sistema operacional, siga estas etapas:

No Windows: clique em Iniciar, depois em Executar, digite 'cmd' e pressione Enter. Em seguida, digite &lt;code&gt;ghci&lt;/code&gt; e pressione Enter novamente.

No MacOS: abra o aplicativo &quot;Terminal&quot;, localizado na pasta &quot;Aplicativos/Utilitários&quot;, digite &lt;code&gt;ghci&lt;/code&gt; na janela que aparecerá e pressione Enter.

No Linux: abra um terminal e execute &lt;code&gt;ghci&lt;/code&gt;.

Você deverá obter uma saída semelhante à seguinte:

&lt;pre&gt;
GHCi, version 8.10.7: http://www.haskell.org/ghc/  :? for help
Prelude&gt; 
&lt;/pre&gt;

A primeira parte indica a versão do GHCi e informa como obter ajuda no próprio GHCi. A parte &lt;code&gt;Prelude&gt;&lt;/code&gt; é conhecida como ''prompt''. É nesse local que você digita os comandos, e o GHCi responde com os resultados. O prompt também informa que o módulo atualmente carregado é &lt;code&gt;Prelude&lt;/code&gt;, que dá acesso à maioria das funções predefinidas.

Agora vamos experimentar algumas operações aritméticas básicas:

{{HaskellGHCi|1=
Prelude&gt; 2 + 2
4
Prelude&gt; 5 + 4 * 3
17
Prelude&gt; 2 ^ 5
32
}}

Esses operadores correspondem aos encontrados na maioria das outras linguagens de programação: &lt;code&gt;+&lt;/code&gt; é a adição, &lt;code&gt;*&lt;/code&gt; é a multiplicação e &lt;code&gt;^&lt;/code&gt; é a exponenciação (elevar um número a uma potência, ou seja, &lt;math&gt;a ^ b&lt;/math&gt;). Como mostra o segundo exemplo, Haskell segue a ordem convencional das operações matemáticas (por exemplo, a multiplicação é efetuada antes da adição).

Agora você já sabe usar Haskell como uma calculadora. Na verdade, Haskell é ''sempre'' uma calculadora — só que muito poderosa, capaz de trabalhar não apenas com números, mas também com outros objetos, como caracteres, listas, funções, árvores e até mesmo outros programas (se você ainda não conhece esses termos, não se preocupe).

Para sair do GHCi quando terminar, use &lt;code&gt;&lt;/code&gt; (ou simplesmente &lt;code&gt;&lt;/code&gt;):

{{HaskellGHCi|
Prelude&gt; 
Leaving GHCi.
}}

O GHCi é um ambiente de desenvolvimento poderoso. À medida que avançarmos, aprenderemos a carregar arquivos com código-fonte no GHCi e a avaliar diferentes partes deles.

Se tudo estiver claro até aqui (caso contrário, use a página de discussão e ajude a melhorar este Wikilivro!), você estará pronto para o próximo capítulo, no qual apresentaremos alguns dos conceitos básicos de Haskell e criaremos nossas primeiras funções em Haskell.

{{Auto category}}

{{AutoCat}}
[[Categoria:Livro/Haskell/Arquivo]]</text>
      <sha1>155kl42uult3tur1lr5hqlqdq2ecag7</sha1>
    </revision>
    <revision>
      <id>589299</id>
      <parentid>589294</parentid>
      <timestamp>2026-10-12T00:28:17Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>67836</id>
      </contributor>
      <origin>589299</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4882" sha1="gejf9p44uxh9wqjvfvhjx75mbt0ufxb" xml:space="preserve">== Instalando o Haskell ==
Haskell é uma ''linguagem de programação'', isto é, uma linguagem na qual os seres humanos podem expressar como os computadores devem se comportar. É como escrever uma receita de cozinha: você escreve a receita e o computador a executa.

Para executar programas em Haskell, você precisa de um programa especial chamado ''compilador'' de Haskell. Um compilador recebe o código escrito em Haskell e o traduz para ''código de máquina'', uma linguagem mais elementar que o computador entende. Usando a analogia da cozinha, você escreve uma receita (seu programa em Haskell) e um cozinheiro (um programa compilador) faz o trabalho de combinar os ingredientes reais para preparar um prato comestível (um arquivo executável). Naturalmente, não é fácil obter a receita a partir do prato pronto (assim como não é possível obter o código Haskell a partir do executável depois que ele é compilado).

Para começar, visite [https://www.haskell.org/downloads haskell.org/downloads] para consultar as instruções mais recentes. Atualmente, o método recomendado é usar [https://haskell.org/ghcup GHCup]. Use-o para instalar a versão mais recente recomendada do GHC, &lt;code&gt;cabal&lt;/code&gt; (não &lt;code&gt;stack&lt;/code&gt;) e o servidor de linguagem Haskell. Você deve usar &lt;code&gt;cabal&lt;/code&gt; para instalar qualquer biblioteca Haskell de que precisar. Abordaremos o uso de &lt;code&gt;cabal&lt;/code&gt; em detalhes em [[Haskell/Packaging]]

{{Nota no corpo|1=
Usuários de Linux:

'''É fortemente desaconselhado instalar qualquer componente relacionado ao Haskell usando os repositórios de pacotes e o gerenciador de pacotes do sistema (a menos que você esteja usando Fedora ou NixOS). Especificamente, distribuições como Arch Linux e Debian gerenciam os pacotes Haskell muito mal, o que prejudica a experiência com as ferramentas de desenvolvimento. Use GHCup e Cabal, conforme indicado acima.'''
}}

Para testar apenas alguns conceitos básicos de Haskell sem baixar e instalar nada, existe um [https://play.haskell.org/ ambiente de testes] que inclui alguns pacotes por padrão. A maioria das instruções deste Wikilivro também funcionará nesse ambiente, embora ele não aceite entradas do usuário.

== Primeiro código ==

Após a instalação, escreveremos nosso primeiro código em Haskell usando o programa chamado '''GHCi''' (o 'i' significa ''interativo''). Dependendo do seu sistema operacional, siga estas etapas:

No Windows: clique em Iniciar, depois em Executar, digite 'cmd' e pressione Enter. Em seguida, digite &lt;code&gt;ghci&lt;/code&gt; e pressione Enter novamente.

No MacOS: abra o aplicativo &quot;Terminal&quot;, localizado na pasta &quot;Aplicativos/Utilitários&quot;, digite &lt;code&gt;ghci&lt;/code&gt; na janela que aparecerá e pressione Enter.

No Linux: abra um terminal e execute &lt;code&gt;ghci&lt;/code&gt;.

Você deverá obter uma saída semelhante à seguinte:

&lt;pre&gt;
GHCi, version 8.10.7: http://www.haskell.org/ghc/  :? for help
Prelude&gt; 
&lt;/pre&gt;

A primeira parte indica a versão do GHCi e informa como obter ajuda no próprio GHCi. A parte &lt;code&gt;Prelude&gt;&lt;/code&gt; é conhecida como ''prompt''. É nesse local que você digita os comandos, e o GHCi responde com os resultados. O prompt também informa que o módulo atualmente carregado é &lt;code&gt;Prelude&lt;/code&gt;, que dá acesso à maioria das funções predefinidas.

Agora vamos experimentar algumas operações aritméticas básicas:

{{HaskellGHCi|1=
Prelude&gt; 2 + 2
4
Prelude&gt; 5 + 4 * 3
17
Prelude&gt; 2 ^ 5
32
}}

Esses operadores correspondem aos encontrados na maioria das outras linguagens de programação: &lt;code&gt;+&lt;/code&gt; é a adição, &lt;code&gt;*&lt;/code&gt; é a multiplicação e &lt;code&gt;^&lt;/code&gt; é a exponenciação (elevar um número a uma potência, ou seja, &lt;math&gt;a ^ b&lt;/math&gt;). Como mostra o segundo exemplo, Haskell segue a ordem convencional das operações matemáticas (por exemplo, a multiplicação é efetuada antes da adição).

Agora você já sabe usar Haskell como uma calculadora. Na verdade, Haskell é ''sempre'' uma calculadora — só que muito poderosa, capaz de trabalhar não apenas com números, mas também com outros objetos, como caracteres, listas, funções, árvores e até mesmo outros programas (se você ainda não conhece esses termos, não se preocupe).

Para sair do GHCi quando terminar, use &lt;code&gt;&lt;/code&gt; (ou simplesmente &lt;code&gt;&lt;/code&gt;):

{{HaskellGHCi|
Prelude&gt; 
Leaving GHCi.
}}

O GHCi é um ambiente de desenvolvimento poderoso. À medida que avançarmos, aprenderemos a carregar arquivos com código-fonte no GHCi e a avaliar diferentes partes deles.

Se tudo estiver claro até aqui (caso contrário, use a página de discussão e ajude a melhorar este Wikilivro!), você estará pronto para o próximo capítulo, no qual apresentaremos alguns dos conceitos básicos de Haskell e criaremos nossas primeiras funções em Haskell.

{{AutoCat}}
[[Categoria:Livro/Haskell/Arquivo]]</text>
      <sha1>gejf9p44uxh9wqjvfvhjx75mbt0ufxb</sha1>
    </revision>
  </page>
  <page>
    <title>Haskell/Variáveis e funções</title>
    <ns>0</ns>
    <id>29858</id>
    <revision>
      <id>589300</id>
      <parentid>497016</parentid>
      <timestamp>2026-10-12T00:29:22Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>67836</id>
      </contributor>
      <origin>589300</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="21182" sha1="ivwpc5slq457d62sddywfhypvpihr0m" xml:space="preserve">{{Em tradução}}

{{clear}}
{{HaskellÍndice|Introdução}}

''Todos os exemplos deste capítulo pode ser salvos num arquivo e executados usando o GHC. Não inclua &quot;Prelude&gt;&quot; em nenhum dos exemplos. Quando este comando aparecer, quer dizer que o código seguinte foi rodado no GHCi. Quando não houver o comando, basta copiar o código inteiro.''

== Variáveis ==

No capítulo passado, usamos o GHCi como uma calculadora, o que é tão prático apenas para contas curtas. Para grandes cálculos e para escrever um programa em Haskell, geralmente temos que acompanhar e verificar resultados intermediários.

Podemos fazer isso atribuindo nomes. Chamas as chamadas ''variáveis''. Quando um programa é executado, cada variável é substituída por um ''valor'' ao qual ela se refere. Por exemplo, considere o seguinte

{{HaskellGHCi|1=
Prelude&gt; 3.141592653 * 5^2
78.539816325
}}

Este foi o cálculo aproximado da área de um círculo de raio &lt;code&gt;5&lt;/code&gt;, de acordo com a fórmula &lt;math&gt;A = \pi r^2&lt;/math&gt;. Claro que se torna um processo bastante trabalhoso escrever todos os dígitos de &lt;math&gt;\pi \approx 3,141592653&lt;/math&gt;, ou mesmo lembrar os primeiros 5. Por isso, para evitar repetições podemos fazer com a máquina se lembre destes valores uma única vez para que possamos usá-los sempre que necessário. Essa abstração nos deixa livre para focar em outras partes mais importantes. No caso deste exemplo, Haskell já possui uma variável chamada &lt;code&gt;pi&lt;/code&gt; que armazena mais de 15 dígitos de &lt;math&gt;\pi&lt;/math&gt;, o que deixa o código mais claro e ainda ganhamos em precisão nos resultados.

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

Perceba que a variável &lt;code&gt;pi&lt;/code&gt; e seu valor, &lt;code&gt;3.141592653589793&lt;/code&gt;, trocados entre si nos cálculos.

== Arquivos de código em Haskell ==

Além de fazer cálculos esporadicamente no GHCi, você pode salvar seus códigos num arquivo Haskell, que são arquivos de texto com a extensão &lt;tt&gt;.hs&lt;/tt&gt;. É recomendável usar um editor de texto próprio para programação (cf. [[w:Editor de texto|artigo da Wikipédia sobre editores de texto]]). A grande maioria deles possuem a capacidade ''realçar a sintaxe'', isto é, colorir o código fonte de modo a facilitar a leitura. Vim e Emacs são duas opções bastante populares entre programadores.

Para ajudar na organização, crie também um novo diretório (uma pasta de arquivos) em seu computador para salvar os arquivos Haskell que você cria quando estiver resolvendo os exercícios deste livro. Vamos lá, crie um diretório chamado &lt;tt&gt;HaskellWikibook&lt;/tt&gt;, por exemplo, e dentro dele, um arquivo chamado &lt;tt&gt;Varfun.hs&lt;/tt&gt; contendo o seguinte código:

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

Este programa define a variável &lt;code&gt;r&lt;/code&gt; como sendo o valor &lt;code&gt;5.0&lt;/code&gt;.

Nota: certifique-se de que não há espaços em branco no começo das linhas, porque Haskell é sensível a espaços.

Depois abra um terminal no diretório &lt;tt&gt;HaskellWikibook&lt;/tt&gt; que você criou, execute o GHCi e carregue o arquivo &lt;tt&gt;Varfun.hs&lt;/tt&gt; usando o comando &lt;code&gt;:load&lt;/code&gt;:

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

É bom saber que &lt;code&gt;:load&lt;/code&gt; pode ser abreviado para &lt;code&gt;:l&lt;/code&gt;: &lt;code&gt;:l Varfun.hs&lt;/code&gt;.

Se o GHCi retornar um erro como &lt;code&gt;Could not find module 'Varfun.hs'&lt;/code&gt;, isso quer dizer que você provavelmente está no diretório errado. Tente o comando &lt;code&gt;:cd&lt;/code&gt; para mudar o diretório corrente de dentro do GHCi (por exemplo, &lt;code&gt;:cd HaskellWikibook&lt;/code&gt;).

Depois que o arquivo estiver carregado na sessão do GHCi, você vai ver a linha de comando mudar de &quot;Prelude&quot; para &quot;*Main&quot;. Agora você pode usar a varíavel &lt;code&gt;r&lt;/code&gt; que você definiu no arquivo.

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

Acabamos de calcular a área de um círculo de raio 5,0 usando a fórmula &lt;math&gt;\pi r^2&lt;/math&gt;. O que aconteceu aqui é que usamos &lt;code&gt;r&lt;/code&gt; que definimos no arquivo &lt;tt&gt;Varfun.hs&lt;/tt&gt;, e &lt;code&gt;pi&lt;/code&gt;, que já está definido em outro lugar.

Agora, vamos fazer esse valor ser mais fácil de ser acessado ao definirmos um nome para ele também. Abra o arquivo novamente e mude seu conteúdo para:

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

Salve-e e recarregue-o no GHCi usando &lt;code&gt;:reload&lt;/code&gt;, ou simplesmente &lt;code&gt;:r&lt;/code&gt;:

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

Agora temos duas variávels: &lt;code&gt;r&lt;/code&gt; e &lt;code&gt;area&lt;/code&gt;.

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

{{nota|A palavra &lt;code&gt;let&lt;/code&gt; é o que deveríamos usar para definir novas variáveis diretamente no GHCi, sem precisar editar um arquivo de código. Mesmo que possa ser prático fazer isso, nem sempre é o caso para tarefas mais complexas. É preferível usar arquivos nesses casos.}}

== Comentários ==
Além do código em si, arquivos de código fonte podem conter texto conhecidos como ''cometários'', que são ignorados pelo compilador. Em Haskell existem dois tipos de comentários. Primeiro, aqueles que começam com &lt;code&gt;--&lt;/code&gt; e que vão até o final da linha:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
x = 5     -- x is 5.
y = 6     -- y is 6.
-- z = 7  -- z is not defined.
&lt;/syntaxhighlight&gt;

Nestes casos, &lt;code&gt;x&lt;/code&gt; e &lt;code&gt;y&lt;/code&gt; são realmente definidos no código, mas &lt;code&gt;z&lt;/code&gt; não é.

O segundo tipo do comentário é deliminado por &lt;code&gt;{- ... -}&lt;/code&gt; e podem se abranger mais de uma linha:
&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
answer = 2 * {-
  bloco de cometário de mais de uma linha e...
  -} 3 {- comentário no meio da linha -} * 7
&lt;/syntaxhighlight&gt;

Comentários são usados para explicar partes de um programa ou para fazer qualquer tipo de anotação acerca de algum contexto. É importante frisar que exagerar na quantidade de comentários pode, na verdade, dificultar a leitura do código em si, e comentários desatualizados podem também gerar confusões.

== Variáveis em linguagens imperativas ==
Os leitores familiares com linguagens de programação imperativa perceberão que as variáveis em Haskell se comportam de maneira bem diferente que as variáveis em C, por exemplo.
Se você não possui experiência prévia com programação, pode pular esta seção, apesar de que ela pode te ajudar a entender as situações em que pessoas comparam o comportamento de Haskell em relação a outras linguagens. Muitos livros sobre Haskell fazem isso, por exemplo.

''Programação imperativa'' trata as variáveis como posições na memória da máquina. Essa abordagem está relacionada com o funcionamento básico de um computador. Programas imperativos dizem explicitamente ao computador o que devem fazer. Linguagens de alto nível, que podem estar bastante distantes destes conceitos, ainda retém parte deles no sentido de que ainda usam esse padrão de programação &quot;passo-a-passo&quot;. Em contraste a isso, ''programação funcional'' proporciona uma maneira diferente de pensar, usando termos matemáticos e deixando de lado as instruções diretas ao computador, que são traduzidas apenas compilador para algo que o computador possa interpretar e processar.

Vejamos um exemplo. O código a seguir não funcionaria em Haskell:

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

Um programador de linguagens imperativas leria isto como sendo: primeiro, definir &lt;code&gt;r = 5&lt;/code&gt; e depois redefinir para &lt;code&gt;r = 2&lt;/code&gt;. Em Haskell, entretanto,  o compilador responderia este código com um erro: &quot;múltiplas declarações de &lt;code&gt;r&lt;/code&gt;&quot;. Dentro de um escopo definido, uma variável de Haskell é definida uma única vez, e sua definição não pode mudar.

As variáveis de Haskell parecem ''invariáveis'', mas a verdade é que elas se comportam como variáveis matemáticas. Na Matemática, você nunca vê uma variável mudar de valor num mesmo problema, e a mesma coisa acontece em Haskell.

De forma mais precisa, as variáveis de Haskell são ''imutáveis'': elas variam apenas de acordo com os datos que entramos no programa. Não podemos definir &lt;code&gt;r&lt;/code&gt; de dois jeitos diferentes num mesmo código, mas podemos mudar este valor se mudarmos de arquivo. Vamos mudar o código acima para:

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

Claro que vai funcionar. Mudamos &lt;code&gt;r&lt;/code&gt; no único lugar em que ele está definido, e isso muda seu valor em todo o resto do programa.

Em problemas reais, os programas em Haskell deixam ''alguns'' valores indefinidos no código. Esses valores são definidos mais tarde, quando o programa adquire dados de um arquivo ou ação externa. Mas por enquanto, vamos nos ater a definir variáveis internamente. Vamos aprender sobre interações com o mundo exterior no capítulos futuros.

Aqui temos mais um exemplo da grande diferença entre Haskell com as linguagens imperativas:

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

Em vez de &quot;incrementar o valor de &lt;code&gt;r&lt;/code&gt;&quot;, isto é, atualizar o valor já armazenado na memória, este código em Haskell é a definição recursiva e &lt;code&gt;r&lt;/code&gt;, ou seja, ele foi definido em termos de si mesmo. Não se preocupe, pois explicaremos [[Haskell/Recurssão|recurssão]] mais tarde. Neste caso específico, se &lt;code&gt;r&lt;/code&gt; tiver sido definido com algum valor anterior, o compilador retornaria uma mensagem de erro, como explicamos anteriormente. Se &lt;code&gt;r&lt;/code&gt; tiver sido definido com um valor de 5, fazer &lt;code&gt;r = r + 1&lt;/code&gt; é o mesmo que tentar dizer que &lt;math&gt;5 = 5 + 1&lt;/math&gt; na Matemática, o que está obviamente errado.

Já que os valores não mudam dentro de um mesmo programa, variáveis podem ser definidas na ordem em que quisermos. Por exemplo, os dois códigos a seguir são exatamente a mesma coisa:

{|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;
|}

Em Haskell não temos essa noção de que &quot;&lt;code&gt;x&lt;/code&gt; foi declarado antes de &lt;code&gt;y&lt;/code&gt;&quot;, ou o contrário. Claro, para usarmos &lt;code&gt;y&lt;/code&gt; ainda precisamos do valor de &lt;code&gt;x&lt;/code&gt;, mas a ordem não nos interessam, e nem ao compilador.

== Funções ==
Mudar o programa todas as vezes em que quisermos calcular a área de um círculo diferente é tedioso e nos limita a um círculo por vez. Poderíamos calcular duas áreas duplicando todas as contas em nosso código, definindo &lt;code&gt;r2&lt;/code&gt; e &lt;code&gt;area2&lt;/code&gt;&lt;ref group=nota&gt;Podemos ver aqui que os nomes de variáveis podem contar números e letras. Entretanto, toda variável ''deve'' começar com um letra minúscula, que pode ser seguida por outras letras (também maiúsculas), números, traço (_) ou apóstrofe (').&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 evitarmos essa repetição incessante, é preferível simplesmente adicionar uma ''função'' para calcular a área e aplicá-la a diferentes raios. 

Uma ''função'' recebe um ''argumento'' (ou ''parâmetro'') e retorna um resultado, exatamente como na Matemática. Em Haskell, as funções são definidas da mesma forma que as variáveis, exceto que temos que dizer quais são seus argumentos do lado esquerdo da expressão. Por exemplo, o código a seguir define &lt;code&gt;area&lt;/code&gt;, cujo argumento é &lt;code&gt;r&lt;/code&gt;:

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

Observe a sintáxe: o nome da função vem primeiro (&lt;code&gt;area&lt;/code&gt;), seguido de um espaço em branco e de seu argumento (&lt;code&gt;r&lt;/code&gt;). Depois vem o sinal &lt;code&gt;=&lt;/code&gt;, e a definição da função, que usa o argumento de entrada em seu cálculo.

Agora podemos testar diferentes valores de raio e ''chamar'' a função com eles. Salve o código acima num arquivo, abra-o no GHCi, e experimente:

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

Acabamos de ''chamar'' a função com diferentes valores e calculamos a área de três círculos diferentes.

Matematicamente, o calculo da área pode ser representado por &lt;math&gt;A(r) = \pi \cdot r ^ 2&lt;/math&gt;. Para calcular as áreas, faríamos &lt;math&gt;A(5) = 78.54&lt;/math&gt; ou &lt;math&gt;A(3) = 28.27&lt;/math&gt;. Haskell também funciona com parênteses, mas eles são geralmente omitidos por convenção para deixar o código menos carregado de símbolos e mais legível.

Mesmo assim, parênteses ainda são usados para agrupar ''expressões'' (qualquer código que retorne algum valor) que devem ser calculadas todas juntas. Veja como as seguintes expressões são interpretadas de formas diferentes:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
5 * 3 + 2       -- 15 + 2 = 17 (multiplicação feita antes da adição)
5 * (3 + 2)     -- 5 * 5 = 25 (parenteses forçam a adição a ser computada primeiro)
area 5 * 3      -- (area 5) * 3
area (5 * 3)    -- area 15
&lt;/syntaxhighlight&gt;

Da mesma forma que a multiplicação acontece antes que a adição, perceba que as funções de Haskell tem hierarquia de ''precedência'' maior que qualquer outro operador, seja &lt;code&gt;+&lt;/code&gt; ou &lt;code&gt;*&lt;/code&gt;, por exemplo.

== Avaliação de expressões ==
O que exatamente acontece quando entramos uma expressão no GHCi? Depois que pressionamos &quot;enter&quot;, ela é avaliada. Isso significa que cada função vai ser substituída por sua definição e as contas serão realizadas até que um único valor final reste. Por exemplo, ao executarmos &lt;code&gt;area 5&lt;/code&gt; o seguinte acontece:

&lt;syntaxhighlight lang=haskell&gt;
area 5                     -- todos 'r' do lado direito serão substituidos por '5'
pi * 5 ^ 2                 -- 'pi' será substituido por um valor aproximado
3.141592653589793 * 5 ^ 2  -- a operação de potenciação '5 ^ 2' será realizada
3.141592653589793 * 25     -- a operação de multiplicação será realizada
78.53981633974483          -- resultado final
&lt;/syntaxhighlight&gt;

Quando usamos o GHCi, o resultado de ''aplicar'' ou ''chamar'' a função,  que segue o procedimento acima, vai aparecer na tela.

Agora, mais algumas funções:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
dobrar   x     = 2 * x
quadruplicar x = double (double x)
quadrado x     = x * x
metade   x     = x / 2
&lt;/syntaxhighlight&gt;

{{HaskellExercícios|1=
* Explique como GHCi avaliaria &lt;code&gt;quadruplicar 5&lt;/code&gt;}.
* Defina uma função que subtraia 12 da metade de seu argumento.}}

== Parâmetros múltiplos ==
Funções também podem ter mais que um argumento. Por exemplo, para calcular a área de um retângulo precisamos de seu comprimento e de sua largura:

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

{{HaskellGHCi|1=
*Main&gt; areaRetang 5 10
50
}}

Outro exemplo é a área de um 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;

{{HaskellGHCi|1=
*Main&gt; areaTriang 3 9
13.5
}}

Como você pode ver, os argumentos são separados por espaços. É por isso que as vezes você precisa usar parênteses para agrupar expressões. Por exemplo, não se pode escrever o quádruplo de um valor como sendo

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

Isso aplicaria a função &lt;code&gt;double&lt;/code&gt; sobre dois argumentos: &lt;code&gt;double&lt;/code&gt; e &lt;code&gt;x&lt;/code&gt;. É possível, sim, que ''funções sejam argumentos de outras funções'', como veremos mais tarde, mas isso não é o que queremos aqui. Para fazer esta função funcionar precisamos de parênteses:

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

Os argumento são sempre passados na ordem em que aparecem. Por exemplo:

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

{{HaskellGHCi|1=
*Main&gt; menos 10 5
5
*Main&gt; menos 5 10
-5
}}

Aqui, &lt;code&gt;menos 10 5&lt;/code&gt; avalia a expressão &lt;code&gt;10 - 5&lt;/code&gt;, enquanto que &lt;code&gt;menos 5 10&lt;/code&gt; avalia &lt;code&gt;5 - 10&lt;/code&gt; devido a mudança na ordem do argumentos.

{{HaskellExercícios|1=
* Escreva uma função para calcular o volume de uma caixa.
* Aproximadamente, de quantas pedras as famosas pirâmides de Gizé feitas? Dica: você vai precisar estimar o volume da pirâmide e o volume de cada bloco de pedra.
}}

== Combinando funções ==

Claro que você pode usar outras funções para definir suas próprias, bem como você já o fez usando adição, &lt;code&gt;+&lt;/code&gt;, ou multiplicação, &lt;code&gt;*&lt;/code&gt;. Na verdade, operadores também são definidos como funções em Haskell. Por exemplo, para calcular a área de um quadrado, podemos reutlizar a função que calcula a área de um retângulo:

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

{{HaskellGHCi|1=
*Main&gt; areaQuad 5
25
}}

Afinal de contas, um quadrado é um retângulo de lados iguais.

{{HaskellExercícios|1=
* Escreva uma função que calcule o volume de um cilindro. O volume de um cilindro é a área da base, que é um círculo, multiplicada pela altura. Como você já programou a função da área de um círculo neste capítulo, você pode reutilizá-la aqui.}}

== Definindo funções locais ==
=== Usando &lt;code&gt;where&lt;/code&gt; ===
Quando definimos uma função, às vezes precisamos calcular valores intermediários, mas que são ''locais'' e usados apenas dentro daquela função. Considere a [[w:teorema de Herão|fórmula de Herão]]: &lt;math&gt;A = \sqrt{p(p-a)(p-b)(p-c)}&lt;/math&gt;, sendo &lt;math&gt;p&lt;/math&gt; o metade do perímetro do triângulo. Este é o cálculo da área de um triângulo de lados &lt;code&gt;a&lt;/code&gt;, &lt;code&gt;b&lt;/code&gt; e &lt;code&gt;c&lt;/code&gt;:

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

A variável &lt;code&gt;s&lt;/code&gt; representa a metade do perímetro. Seria tedioso e propenso a erros se tivéssemos que escrever &lt;code&gt;(a + b + c)/2&lt;/code&gt; toda vez que precisássemos deste valor dentro de &lt;code&gt;herao&lt;/code&gt;. &lt;code&gt;sqrt&lt;/code&gt; calcula a raiz quadrada do seu argumento (lembre-se de ''square root'', no inglês).

Simplesmente escrever as definições separadamente não funcionaria. Veja:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
herao a b c = sqrt (p * (p - a) * (p - b) * (p - c))
p = (a + b + c) / 2                                   -- a, b, and c are not defined here
&lt;/syntaxhighlight&gt;

O compilador reclamaria que &lt;code&gt;a&lt;/code&gt;, &lt;code&gt;b&lt;/code&gt; e &lt;code&gt;c&lt;/code&gt; só estão disponíveis no lado direito de &lt;code&gt;herao&lt;/code&gt;, enquanto que a definição de &lt;code&gt;s&lt;/code&gt; não faz parte do lado direito de &lt;code&gt;herao&lt;/code&gt;. Para que ela seja embutida lá, usamos a palavra-chave &lt;code&gt;where&lt;/code&gt;.

Perceba que tanto &lt;code&gt;where&lt;/code&gt; quanto a definição de &lt;code&gt;s&lt;/code&gt; estão ''indentadas'' por 4 espaços em branco. Isso é importante para delimitar o que está dentro do que. Vejamos outros exemplos do uso de &lt;code&gt;where&lt;/code&gt;:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
areaTriangTrig  a b c = c * altura / 2   -- usando trigonometria
    where
    cosa    = (b ^ 2 + c ^ 2 - a ^ 2) / (2 * b * c)
    sina    = sqrt (1 - cosa ^ 2)
    altura  = b * sina
areaTriangHerao a b c = resultado        -- usa a fórmula de Herão
    where
    resulto = sqrt (p * (p - a) * (p - b) * (p - c))
    p       = (a + b + c) / 2
&lt;/syntaxhighlight&gt;

== Escopo ==
Observe atentamente o exemplo anterior: perceba que usamos as variáveis &lt;code&gt;a&lt;/code&gt;, &lt;code&gt;b&lt;/code&gt;, &lt;code&gt;c&lt;/code&gt; duas vezes, em cada função definida. Como pode isso?

Considere o seguinte procedimento no GHCi:

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

Seria estranho se retornasse &lt;code&gt;0&lt;/code&gt; para as áreas por causa da definição anterior de &lt;code&gt;let r = 0&lt;/code&gt;. Isso não acontece porque na segunta vez que digitamos &lt;code&gt;r&lt;/code&gt; estamos nos referindo a um &lt;code&gt;r&lt;/code&gt; ''diferente''. Parece confuso, mas pense no seguinte: muitas pessoas se chamam João, mesmo assim, numa situação em que há apenas um João presente, podemos falar &quot;João&quot; sem nenhuma confusão. Em programação, essa noção de contexto é chamada de ''[[w:Escopo (computação)|escopo]]''.

Não vamos nos aprofundar nos detalhes técnicos que envolvem o escope por agora, mas tenha em mente que o valor de um parâmetro é exatamente aquilo que você passa à função, independente de como você o chamou na definição da função. Assim sendo, nomear as variáveis de modo apropriado ajuda bastante a leitura do código por humanos.

== Resumo ==

# Variáveis armazenam valores (que podem ser qualquer expressão em Haskell).
# Variáveis não mudam seus valores dentro de um mesmo escopo.
# Funções são úteis para escrever programas reutilizáveis.
# Funções podem aceitar mais de um parâmetro.

== Notas ==
&lt;references group=&quot;nota&quot;/&gt;</text>
      <sha1>ivwpc5slq457d62sddywfhypvpihr0m</sha1>
    </revision>
  </page>
  <page>
    <title>Haskell/Verdadeiro ou falso</title>
    <ns>0</ns>
    <id>92993</id>
    <revision>
      <id>589291</id>
      <parentid>472897</parentid>
      <timestamp>2026-10-12T00:14:45Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>67836</id>
      </contributor>
      <origin>589291</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="13668" sha1="63892laoatkrc42ab16msrmum95ngso" xml:space="preserve">{{Em tradução}}

{{clear}}
{{HaskellÍndice|Introdução}}

== Igualdade e outras comparaçãoes ==

No capítulo usamos sinais de igualdade para definir variáveis e funções em Haskell desta forma:

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

Isso significa que durante a avaliação do programa, todas as ocorrências de &lt;code&gt;r&lt;/code&gt; são substituídas por &lt;code&gt;5&lt;/code&gt; dentro do mesmo escopo. De modo similar, ao avaliar

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

todas os ocorrências de &lt;code&gt;f&lt;/code&gt; seguidas de um número (o argumento de &lt;code&gt;f&lt;/code&gt;), são substituídas por tal valor mais três.

Na Matemática, o sinal de igualdade é usado de forma diferente. Considere o seguinte problema:

{{Exercícios|1=
Resolva o seguinte problema: &lt;math&gt;x+3=5&lt;/math&gt;.
}}

Neste caso, o problema não representar &lt;math&gt;5&lt;/math&gt; como sendo &lt;math&gt;x+3&lt;/math&gt; ou vice-versa. Na verdade, temos uma ''proposição'' de que um número &lt;math&gt;x&lt;/math&gt;, quando somado a 3, resulta em 5. Resolver a equação significa achar qual valor de &lt;math&gt;x&lt;/math&gt;, se é que existe um, torna a proposição verdadeira. Neste exemplo simples, uma simples manipulação algébrica nos mostra que &lt;math&gt;x=2&lt;/math&gt;, isto é, &lt;math&gt;2&lt;/math&gt; é o número que satisfaz a proposição, pois &lt;math&gt;2+3=5&lt;/math&gt;.

Comparar valores para verificar se são iguais é algo bastante útil para a programação. Na verdade, é algum bastante elementar e necessário. Em Haskell, tais testes se parecem bastante com um equação. Entretanto, já que o sinal de igual já está sendo usado para definir alguma coisa, Haskell usa um sinal ''duplo'' de igualdade, &lt;code&gt;==&lt;/code&gt;, para fazer comparações. Veja:

{{HaskellGHCi|1=
Prelude&gt; 2 + 3 == 5
True
}}

Aqui, GHCi retorna &lt;code&gt;True&lt;/code&gt; (''verdadeiro'', em inglês) porque &lt;math&gt;2 + 3&lt;/math&gt; é igual a &lt;math&gt;5&lt;/math&gt;. E se a equação não for verdadeira?

{{HaskellGHCi|1=
Prelude&gt; 7 + 3 == 5
False
}}

O resultado é &lt;code&gt;False&lt;/code&gt; (''falso'', em inglês). Agora vamos usar a função &lt;code&gt;f&lt;/code&gt; definimos no começo deste capítulo:

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

Como esperado. Já que &lt;code&gt;f 2&lt;/code&gt; é avaliado como sendo &lt;code&gt;2 + 3&lt;/code&gt;, que resulta em &lt;code&gt;5&lt;/code&gt;, só poderíamos esperar que &lt;code&gt;5 == 5&lt;/code&gt; retornasse &lt;code&gt;True&lt;/code&gt;.

Nós também podemos comparar dois valores numéricos para saber qual é maior. Haskell possui vários operadores para esses testes: &lt;code&gt;&lt;&lt;/code&gt; para ''menor que''; &lt;code&gt;&gt;&lt;/code&gt;, ''maior que''; &lt;code&gt;&lt;=&lt;/code&gt;, ''menor que ou igual a''; e &lt;code&gt;&gt;=&lt;/code&gt;, ''maior que ou igual a''. Esses testes funcionam exatamente como &lt;code&gt;==&lt;/code&gt;, ''igual a''. Por exemplo, poderíamos usar &lt;code&gt;&lt;&lt;/code&gt; juntamente com a função &lt;code&gt;area&lt;/code&gt; do capítulo anterior para saber se um círculo com um certo raio tem área menor que um outro valor.

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

== Valores booleanos ==
O que acontece quando GHCi tem que determinar se essas comparações são verdadeiras ou falsas? Considere um caso diferente. Se entrarmos com uma expressão aritmética no GHCi, ela é ''avaliada'', e o resultado numérico aparece na tela:

{{HaskellGHCi|1=
Prelude&gt; 2 + 2
4
}}

Se substituirmos, na comparação, o valor final da expressão aritmética, algo parecido acontece:

{{HaskellGHCi|1=
Prelude&gt; 2 == 2
True
}}

Enquanto o &quot;4&quot; retornado primeiro representa a contagem de alguma coisa, o &quot;Verdadeiro&quot; é um ''valor'' que representa a verdade de uma certa proposição. Tais valores são conhecidos como '''booleanos'''.&lt;ref group=nota&gt;Este termo foi escolhido em homenagem ao matemático britânico [[w:George Boole|George Boole]].&lt;/ref&gt; Naturalmente, apenas dois valores são possíveis, os quais já nos foram apresentados: &lt;code&gt;True&lt;/code&gt; e &lt;code&gt;False&lt;/code&gt;.

== Introdução a tipos de dados ==

&lt;code&gt;True&lt;/code&gt; e &lt;code&gt;False&lt;/code&gt; são valores reais, não apenas uma analogia. Em Haskell, valores booleanos tem o mesmo ''status'' que valores numéricos, e podemos manipulá-los de formas semelhantes. Um exemplo trivial:

{{HaskellGHCi|1=
Prelude&gt; True == True
True
Prelude&gt; True == False
False
}}

&lt;code&gt;True&lt;/code&gt; é, de fato, igual a &lt;code&gt;True&lt;/code&gt;, and &lt;code&gt;True&lt;/code&gt; não é igual a &lt;code&gt;False&lt;/code&gt;. Agora responda: é possível dizer se &lt;code&gt;2&lt;/code&gt; é igual a &lt;code&gt;True&lt;/code&gt;?

{{HaskellGHCi|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
}}

Temos um erro no compilador. Na verdade, a pergunta original sequer faze sentido. Não se pode comparar um número com algo que não é um número, ou um booleano com algo não-booleano. Haskell possui essa noção incorporada em si, e a mensagem de erro acima, apesar de longa e um pouco intimidadora, diz exatamente isso: há um número (&lt;code&gt;Num&lt;/code&gt;) do lado esquerdo de &lt;code&gt;==&lt;/code&gt;, então esperava-se um número do lado direito também; contudo, um booleano (&lt;code&gt;Bool&lt;/code&gt;) não é um número, então o teste de igualdade falha.

Fica claro, então, que valores são separados em '''tipo''', e que esses tipos definem os limites do que podemos ou não fazer com tais valores. &lt;code&gt;True&lt;/code&gt; e &lt;code&gt;False&lt;/code&gt; são valores do tipo &lt;code&gt;Bool&lt;/code&gt;. Já o &lt;code&gt;2&lt;/code&gt; é um caso um pouco mais complicado, porque existem vários tipos de números na computação, bem como na matemática (apesar de não serem equivalentes). Mas no fim, ainda é um dado &lt;code&gt;Num&lt;/code&gt;. De forma geral, essa característica de limitação é de grande valor, porque podemos usar isso a nosso favor para controlar o comportamento dos nossos programas, criando regras que impedem o uso do programa com tipos que ''não fazem sentido'', o que garante a funcionamento do correto do que desenvolver. Voltaremos a este tópico sobre tipos mais tarde, pois eles são uma parte importante da linguagem Haskell.

== Operadores infixos ==

Um teste de igualdade, como &lt;code&gt;2 == 2 &lt;/code&gt;, também é uma expressão, bem como uma operação aritmética também o é, como &lt;code&gt;2 + 2&lt;/code&gt;. Ambos os casos são avaliados basicamente da mesma maneira. Quando digitamos &lt;code&gt;2 == 2&lt;/code&gt; numa sessão do GHCi, ele &quot;responde&quot; com &lt;code&gt;True&lt;/code&gt;, pois simplesmente avaliou a expressão. Na verdade, o operador &lt;code&gt;==&lt;/code&gt; é uma função de dois argumentos (o lado direito e o lado esquerdo da igualdade). Só que seu uso é diferente: Haskell permite que funções de dois argumentos sejam escritas como ''operadores infixos'', ou seja, que sejam escritas ''entre'' seus dois argumentos. Quando o nome da função é, na verdade, caracteres não-alfanuméricos (&lt;code&gt;==&lt;/code&gt;, por exemplo), usá-las como operadores infixos é a forma mais comum. Se você deseja usá-las da forma padrão, ou seja, como ''operadores prefixos'' (com o nome da função antes dos argumentos), elas devem ser cercadas por parênteses. Veja:

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

É possível converter um booleano em outro também, usando ''negação''. &lt;code&gt;not&lt;/code&gt; é a função de negação: converte &lt;code&gt;True&lt;/code&gt; para &lt;code&gt;False&lt;/code&gt;, e &lt;code&gt;False&lt;/code&gt; para &lt;code&gt;True&lt;/code&gt;.

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

Haskell já possui o operador de diferença: &lt;code&gt;/=&lt;/code&gt;, ''não é igual a''. Entretanto, poderíamos definí-lo facilmente usando &lt;code&gt;not&lt;/code&gt; e &lt;code&gt;==&lt;/code&gt;:

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

Note que podemos usar a notação de operadores infixos até mesmo na hora de definí-los. Além disso, um operador pode ser definido a partir de qualquer símbolo [[w:ASCII|ASCII]].

=== Outras operações booleanas ===

Existem outras operações com booleanos bastante úteis que necessárias: ''ou'' e ''e''.

A operação ''A ou B'' resulta em verdadeiro se ''A'', ou ''B'', ou ambos forem verdadeiros. Ela é definida como sendo o operador &lt;code&gt;(||)&lt;/code&gt; em Haskell:

{{HaskellGHCi|1=
Prelude&gt; True {{!!}} True
True
Prelude&gt; True {{!!}} False
True
Prelude&gt; False {{!!}} True
True
Prelude&gt; False {{!!}} False
False
}}

A operação ''A e B'' resulta em verdadeiro se ''A'' e ''B'' forem verdadeiros. Ela é definida com osendo o operador &lt;code&gt;(&amp;&amp;)&lt;/code&gt;:

{{HaskellGHCi|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 ==

Os programas escritos em Haskell geralmente usam operadores booleanos numa sintaxe bastante conveniente e abreviada. Quando uma mesma lógica é escrita com uma sintaxe diferente, chamamos isso de [[w:Açúcar sintático|''açúcar sintático'']]. Quer dizer que o código se torna mais &quot;aprazível ao paladar humano&quot;. É bom lembra-se deste termo, pois ele aparece bastante nos materiais sobre Haskell.

Um desses &quot;açúcares&quot;, é o que chamamos de ''guardas'', e que usa booleanos para facilitar a implementação de função de maneira bem simples. Primeiro, vamos implementar a função de valor absoluto para números reais, também chamada de [[w:Função modular|função modular ou módulo]]. Sua definição matemática é que: se um número for positivo, seu módulo é ele mesmo; se um número for negativo, seu módulo é seu oposto, ou 0 menos ele mesmo.

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

Nesta função, a expressão usada para calcular &lt;math&gt;|x|&lt;/math&gt; depende do próprio valor de &lt;math&gt;x&lt;/math&gt;. Se &lt;math&gt;x \ge 0&lt;/math&gt; for verdadeiro, então usamos a primeira expressão; se for falso, a segunda. Para expressar esse processo de decisão em Haskell, usamos guardas, sendo que a função ficaria assim:&lt;ref group=nota&gt;Esta função já está disponível nas bibliotecas padrões de Haskell, chamada de &lt;code&gt;abs&lt;/code&gt;. Não há necessidade de reimplementá-la.&lt;/ref&gt;

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

É interessante ver que o código acima se parece bastante com a definição matemática. Vamos por partes:

* Começamos com uma definição normal de uma função. Primeiro o nome, &lt;code&gt;absoluto&lt;/code&gt;, depois definindo a quantidade de argumentos que ela aceita, &lt;code&gt;x&lt;/code&gt;.

* Em vez de usar o sinal &lt;code&gt;=&lt;/code&gt; e começar a escrever a definição, nós escrevemos duas alternativas de comportamento logo a baixo.&lt;ref group=nota&gt;Na verdade, poderíamos escrever tudo numa linha só, como &lt;code&gt;f x | caso 1 | caso 2&lt;/code&gt;, mas é sempre preferível quebrar linhas para facilitar a leitura.&lt;/ref&gt; São essas alternativas que chamamos de ''guardas''. Deve-se lembrar que a indentação (os espaços em branco antes de &lt;code&gt;|&lt;/code&gt;) não são opcionais, e são usados para mostrar que as guardas estão dentro do escopo da definição de &lt;code&gt;absoluto&lt;/code&gt;.

* Cada guarda começa com uma barra vertical, &lt;code&gt;|&lt;/code&gt;. Depois dela, deve-se escrever uma expressão que resulte num booleano, também chamada de condição booleana ou ''predicado''. Ela é seguida pelo resto da definição, que começa a partir de &lt;code&gt;=&lt;/code&gt;. A definição descrita numa guarda só será avaliada se, e somente se o predicato for avaliado como &lt;code&gt;True&lt;/code&gt;.

* O case de &lt;code&gt;otherwise&lt;/code&gt; é avaliado quando nenhum dos outros casos acima for verdadeiro. Nestes caso, se &lt;code&gt;x&lt;/code&gt; não for menor que zero, então ele só pode ser maior que, ou igual a zero. O predicado da última guarda, portanto, poderia ser &lt;code&gt;x &gt;= 0&lt;/code&gt;, mas você geralmente vai ver &lt;code&gt;otherwise&lt;/code&gt; como um caso para aceitar todas as outras condições não descritas nas guardas anteriores.

{{nota|Não há nada de mágico por trás de &lt;code&gt;otherwise&lt;/code&gt;. Na verdade, ele é definido simplesmente como sendo &lt;code&gt;otherwise {{=}} True&lt;/code&gt;. Isso quer dizer que sempre que &lt;code&gt;otherwise&lt;/code&gt; for avaliado, sempre retornará &lt;code&gt;True&lt;/code&gt; e, portanto, a definição descrita em sua guarda será executada.}}

Perceba que escrevemos &lt;code&gt;0 - x&lt;/code&gt; em vez de &lt;code&gt;-x&lt;/code&gt;. O que acontece é que &lt;code&gt;-&lt;/code&gt; ''não é'' uma função de um argumento que retorna &lt;code&gt;0 - x&lt;/code&gt;. Na verdade, trata-se de uma abreviação sintática. Mesmo sendo bastante útil, ela geralmente causa conflito quando usada em conjunto com a função &lt;code&gt;(-)&lt;/code&gt;, que o operador da subtração. Faça um teste você mesmo no GHCi: calcule 3 menos -4, sem usar parênteses. É para evitar este tipo de problema que decidimos escrever de forma explícita &lt;code&gt;0 - x&lt;/code&gt;.

==Guardas e &lt;code&gt;where&lt;/code&gt;==
Usar &lt;code&gt;where&lt;/code&gt; dentro de uma função com guardas é bastante comum. Por exemplo: para saber quantas soluções reais uma [[w:Equação quadrática|equação de segundo grau]] possui, do tipo &lt;math&gt;ax^2+bx+c=0&lt;/math&gt;, temos que calcular seu discriminante, &lt;math&gt;\Delta = b^2 - 4ac&lt;/math&gt;. Se ele for maior que zero, há duas raízes reais; se for nulo, há uma; se for menor que zero, nenhuma. Uma função &lt;code&gt;numSolsReais&lt;/code&gt; em Haskell para calcular esta quantidade, poderia ser escrita assim:

&lt;syntaxhighlight lang = &quot;haskell&quot;&gt;
numSolsReais 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;</text>
      <sha1>63892laoatkrc42ab16msrmum95ngso</sha1>
    </revision>
  </page>
  <page>
    <title>Guia Prático de Implantação: Alpine Linux, Docker e Immich</title>
    <ns>0</ns>
    <id>131593</id>
    <revision>
      <id>589290</id>
      <timestamp>2026-10-11T23:42:13Z</timestamp>
      <contributor>
        <username>~2026-54705-73</username>
        <id>73073</id>
      </contributor>
      <comment>Criou a página com &quot;== Índice ==  * [[/Capa/]] * [[/Prefácio/]] * [[/Introdução/]] * [[/Capítulo 1: Instalação e Configuração Base do Alpine Linux/]] * [[/Capítulo 2: Segurança, Acesso Remoto e Gerenciamento/]] * [[/Capítulo 3: Conteinerização com Docker e Docker Compose/]] * [[/Capítulo 4: Deploy e Execução da Aplicação Immich/]] * [[/Capítulo 5: Verificação, Pós-Instalação e Considerações Finais/]]  {{livro novo}} {{Ficha do livro |Etapa                  = 1...&quot;</comment>
      <origin>589290</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1004" sha1="bptb2fuuxy34tlule7ps18kk8yfwzo7" xml:space="preserve">== Índice ==

* [[/Capa/]]
* [[/Prefácio/]]
* [[/Introdução/]]
* [[/Capítulo 1: Instalação e Configuração Base do Alpine Linux/]]
* [[/Capítulo 2: Segurança, Acesso Remoto e Gerenciamento/]]
* [[/Capítulo 3: Conteinerização com Docker e Docker Compose/]]
* [[/Capítulo 4: Deploy e Execução da Aplicação Immich/]]
* [[/Capítulo 5: Verificação, Pós-Instalação e Considerações Finais/]]

{{livro novo}}
{{Ficha do livro
|Etapa                  = 1     &lt;!-- Coloque um número de 0 até 8 --&gt;
|Nível educacional 1    = 
|Tema 1                 = &lt;!-- Antes de preencher este campo, opine na página [[Wikilivros Discussão:Biblioteca#Proposta]] --&gt;
|CDD 1                  = 004   &lt;!-- Código da Classificação Decimal de Dewey para Computação/Software --&gt;
|CDU 1                  = 004   &lt;!-- Código da Classificação Decimal Universal --&gt;
|CBC 1                  =       &lt;!-- Coloque o código da Classificação da Biblioteca do Congresso se aplicável --&gt;
}}
{{AutoCat}}</text>
      <sha1>bptb2fuuxy34tlule7ps18kk8yfwzo7</sha1>
    </revision>
  </page>
  <page>
    <title>Predefinição:Nota no corpo</title>
    <ns>10</ns>
    <id>131594</id>
    <revision>
      <id>589295</id>
      <timestamp>2026-10-12T00:20:07Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>67836</id>
      </contributor>
      <comment>Criou a página com &quot;&lt;div style=&quot;border:solid #999 1px;background:#F8F8F8;color: #202122;max-width:70%;padding:0.25em 1em;margin:0.5em auto;align:center;overflow:auto&quot;&gt; ''Nota''  {{{1}}} &lt;/div&gt; &lt;noinclude&gt;[[Category:Note templates|{{PAGENAME}}]]&lt;/noinclude&gt;&quot;</comment>
      <origin>589295</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="236" sha1="626i3saksw31s553bw9zjuusunpwslw" xml:space="preserve">&lt;div style=&quot;border:solid #999 1px;background:#F8F8F8;color: #202122;max-width:70%;padding:0.25em 1em;margin:0.5em auto;align:center;overflow:auto&quot;&gt;
''Nota''

{{{1}}}
&lt;/div&gt;
&lt;noinclude&gt;[[Category:Note templates|{{PAGENAME}}]]&lt;/noinclude&gt;</text>
      <sha1>626i3saksw31s553bw9zjuusunpwslw</sha1>
    </revision>
    <revision>
      <id>589296</id>
      <parentid>589295</parentid>
      <timestamp>2026-10-12T00:21:48Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>67836</id>
      </contributor>
      <origin>589296</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="247" sha1="rggq2kyp3j2cbevvf74zlo5c6o3t15v" xml:space="preserve">&lt;div style=&quot;border:solid #999 1px;background:#F8F8F8;color: #202122;max-width:70%;padding:0.25em 1em;margin:0.5em auto;align:center;overflow:auto&quot;&gt;
''Nota''

{{{1}}}
&lt;/div&gt;
&lt;noinclude&gt;[[Categoria:Predefinições de notas|{{PAGENAME}}]]&lt;/noinclude&gt;</text>
      <sha1>rggq2kyp3j2cbevvf74zlo5c6o3t15v</sha1>
    </revision>
  </page>
  <page>
    <title>Categoria:Predefinições de notas</title>
    <ns>14</ns>
    <id>131595</id>
    <revision>
      <id>589297</id>
      <timestamp>2026-10-12T00:23:00Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>67836</id>
      </contributor>
      <comment>Criou a página com &quot;[[Categoria:Predefinições de informação]]&quot;</comment>
      <origin>589297</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45" sha1="f1b3z2i8f0hrpmjkc3iu0b2mwhzgk8l" xml:space="preserve">[[Categoria:Predefinições de informação]]</text>
      <sha1>f1b3z2i8f0hrpmjkc3iu0b2mwhzgk8l</sha1>
    </revision>
  </page>
  <page>
    <title>Categoria:Predefinições de informação</title>
    <ns>14</ns>
    <id>131596</id>
    <revision>
      <id>589298</id>
      <timestamp>2026-10-12T00:23:23Z</timestamp>
      <contributor>
        <username>Luciérnaga de conocimiento</username>
        <id>67836</id>
      </contributor>
      <comment>Criou a página com &quot;[[Categoria:Predefinições]]&quot;</comment>
      <origin>589298</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="29" sha1="9rqapm7gg9sklqqnsj5josev0auttsg" xml:space="preserve">[[Categoria:Predefinições]]</text>
      <sha1>9rqapm7gg9sklqqnsj5josev0auttsg</sha1>
    </revision>
  </page>
</mediawiki>