Haskell (linguagem de programação)

Da Wikipédia, a enciclopédia livre
Ir para a navegação Saltar para pesquisar

Haskell
Logo da Haskell
ParadigmaPuramente funcional
Projetado porLennart Augustsson , Dave Barton, Brian Boutel, Warren Burton, Joseph Fasel, Kevin Hammond, Ralf Hinze, Paul Hudak , John Hughes , Thomas Johnsson, Mark Jones, Simon Peyton Jones , John Launchbury , Erik Meijer , John Peterson, Alastair Reid, Colin Runciman, Philip Wadler
Apareceu pela primeira vez1990 ; 32 anos atrás [1] ( 1990 )
Versão estável
Haskell 2010 [2] / julho 2010 ; 11 anos atrás ( 2010-07 )
Versão de visualização
Haskell 2020 anunciado [3]
Disciplina de digitaçãoInferido , estático , forte
SOMultiplataforma
Extensões de nome de arquivo.hs, .lhs
Local na rede Internetwww.haskell.org _ _
Principais implementações
GHC , Abraços , NHC, JHC, Yhc , UHC
Dialetos
Hélio , Gofer
Influenciado por
Clean , [4] FP , [4] Gofer , [4] Hope and Hope + , [4] Id , [4] ISWIM , [4] KRC , [4] Lisp , [4] Miranda , [4] ML e Padrão ML , [4] Orwell , SASL , [4] Esquema , [4] SISAL [4]
Influenciado
Agda , [5] Bluespec , [6] C++11 / Concepts , [7] C# / LINQ , [8] [9] [10] [11] CAL, [ citação necessária ] Cayenne , [8] Clean , [ 8] Clojure , [12] CoffeeScript , [13] Curry , [8] Elm , Epigram , [ citação necessária ] Escher , [14] F# , [15] Frege , [16] Hack , [17] Idris , [18] Isabelle , [8] Java / Genéricos , [8] LiveScript , [19] Mercury , [8] Ωmega , PureScript , [20] Python , [8] [ 21] Raku , [22] Rust , [23] Scala , [8] [24] Swift , [25] Timber , [26] Visual Basic 9.0 [8] [9]

Haskell ( / h æ s k əl / [27] ) é uma linguagem de programação puramente funcional de propósito geral , estaticamente tipada , com inferência de tipos e avaliação preguiçosa . [28] [29] Projetado para ensino, pesquisa e aplicação industrial, Haskell foi pioneiro em uma série de recursos avançados de linguagem de programação, como classes de tipo , que permitem a sobrecarga do operador com segurança de tipo . A principal implementação de Haskell é o Glasgow Haskell Compiler (GHC). É nomeado após o lógico Haskell Curry . [1]

A semântica de Haskell é historicamente baseada na linguagem de programação Miranda , que serviu para concentrar os esforços do grupo de trabalho inicial de Haskell. [30] A última especificação formal da linguagem foi feita em julho de 2010, enquanto o desenvolvimento do GHC expandiu o Haskell por meio de extensões de linguagem. A próxima especificação formal foi planejada para 2020 . [3] Em 29 de outubro de 2021, o GHC2021 foi lançado na versão GHC 9.2.1. [31]

Haskell é usado na academia e na indústria. [32] [33] [34] Em maio de 2021 , Haskell era a 28ª linguagem de programação mais popular nas pesquisas do Google por tutoriais, [35] e representava menos de 1% dos usuários ativos no repositório de código-fonte do GitHub . [36]

História

Após o lançamento do Miranda pela Research Software Ltd. em 1985, o interesse em linguagens funcionais preguiçosas cresceu. Em 1987, existiam mais de uma dúzia de linguagens de programação não estritas e puramente funcionais. Miranda foi o mais utilizado, mas era um software proprietário . Na conferência sobre Linguagens de Programação Funcional e Arquitetura de Computadores (FPCA '87) em Portland, Oregon , houve um forte consenso de que um comitê fosse formado para definir um padrão aberto para tais linguagens. O objetivo do comitê era consolidar linguagens funcionais existentes em uma linguagem comum para servir de base para pesquisas futuras em design de linguagem funcional. [37]

Haskell 1.0 a 1.4

As classes de tipo , que permitem a sobrecarga de operador com segurança de tipo , foram propostas pela primeira vez por Philip Wadler e Stephen Blott para o Standard ML , mas foram implementadas pela primeira vez em Haskell entre 1987 e a versão 1.0. [38] [39]

A primeira versão do Haskell ("Haskell 1.0") foi definida em 1990. [1] Os esforços do comitê resultaram em uma série de definições de linguagem (1.0, 1.1, 1.2, 1.3, 1.4).

Hierarquia de classes de tipo no prelúdio Haskell a partir do GHC 7.10. A inclusão de Foldable e Traversable (com alterações correspondentes nas assinaturas de tipo de algumas funções), e de Applicative como intermediário entre Functor e Monad, são desvios do padrão Haskell 2010.

Haskell 98

No final de 1997, a série culminou no Haskell 98 , destinado a especificar uma versão estável, mínima e portátil da linguagem e uma biblioteca padrão de acompanhamento para o ensino e como base para futuras extensões. O comitê saudou expressamente a criação de extensões e variantes do Haskell 98 por meio da adição e incorporação de recursos experimentais. [37]

Em fevereiro de 1999, o padrão de linguagem Haskell 98 foi publicado originalmente como The Haskell 98 Report . [37] Em janeiro de 2003, uma versão revisada foi publicada como Haskell 98 Language and Libraries: The Revised Report . [29] A linguagem continua a evoluir rapidamente, com a implementação do Glasgow Haskell Compiler (GHC) representando o padrão de fato atual . [40]

Haskell 2010

No início de 2006, começou o processo de definição de um sucessor para o padrão Haskell 98, informalmente denominado Haskell Prime . [41] Este foi destinado a ser um processo incremental contínuo para revisar a definição da linguagem, produzindo uma nova revisão até uma vez por ano. A primeira revisão, denominada Haskell 2010 , foi anunciada em novembro de 2009 [2] e publicada em julho de 2010.

Haskell 2010 é uma atualização incremental para a linguagem, principalmente incorporando vários recursos bem usados ​​e incontroversos anteriormente habilitados por meio de sinalizadores específicos do compilador.

  • Nomes de módulos hierárquicos. Os nomes dos módulos podem consistir em sequências separadas por pontos de identificadores em maiúsculas, em vez de apenas um desses identificadores. Isso permite que os módulos sejam nomeados de maneira hierárquica (por exemplo, Data.Listem vez de List), embora tecnicamente os módulos ainda estejam em um único namespace monolítico. Essa extensão foi especificada em um adendo ao Haskell 98 e na prática foi universalmente usada.
  • A interface de função estrangeira (FFI) permite ligações a outras linguagens de programação. Apenas as ligações para C são especificadas no Relatório, mas o design permite outras ligações de linguagem. Para dar suporte a isso, as declarações de tipo de dados não podiam conter construtores, permitindo tipos nonce robustos para dados estrangeiros que não podiam ser construídos em Haskell. Essa extensão também foi especificada anteriormente em um Adendo ao Relatório Haskell 98 e amplamente utilizada.
  • Os chamados padrões n + k (definições da forma fact (n+1) = (n+1) * fact n) não eram mais permitidos. Esse açúcar sintático tinha uma semântica enganosa, na qual o código parecia usar o (+)operador, mas na verdade desaçucarado para codificar usando (-)e (>=).
  • As regras de inferência de tipos foram relaxadas para permitir que mais programas verificassem tipos.
  • Alguns problemas de sintaxe (mudanças na gramática formal) foram corrigidos: protetores de padrão foram adicionados, permitindo correspondência de padrões dentro de guardas; a resolução da fixidez do operador foi especificada de forma mais simples que refletia a prática real; um caso extremo na interação da sintaxe léxica de operadores e comentários da linguagem foi abordado, e a interação de do-notação e if-then-else foi ajustada para eliminar erros de sintaxe inesperados.
  • O LANGUAGE pragma foi especificado. Em 2010, dezenas de extensões para a linguagem estavam em amplo uso, e o GHC (entre outros compiladores) forneceu o LANGUAGEpragma para especificar extensões individuais com uma lista de identificadores. Os compiladores do Haskell 2010 são obrigados a oferecer suporte à Haskell2010extensão e são incentivados a oferecer suporte a várias outras, que correspondem às extensões adicionadas no Haskell 2010.

Características

Haskell apresenta avaliação preguiçosa , expressões lambda , correspondência de padrões , compreensão de lista , classes de tipo e polimorfismo de tipo . É uma linguagem puramente funcional , o que significa que as funções geralmente não têm efeitos colaterais . Existe uma construção distinta para representar os efeitos colaterais, ortogonais ao tipo de funções. Uma função pura pode retornar um efeito colateral que é executado posteriormente, modelando as funções impuras de outras linguagens.

Haskell tem um sistema de tipo estático forte baseado na inferência de tipo Hindley–Milner . Sua principal inovação nesta área são as classes de tipos, originalmente concebidas como uma maneira de adicionar sobrecarga à linguagem, [42] mas desde que encontraram muitos outros usos. [43]

A construção que representa os efeitos colaterais é um exemplo de mônada : uma estrutura geral que pode modelar vários cálculos, como tratamento de erros, não determinismo , análise sintática e memória transacional de software . Eles são definidos como tipos de dados comuns, mas Haskell fornece algum açúcar sintático para seu uso.

Haskell tem uma especificação aberta e publicada, [29] e existem várias implementações . Sua principal implementação, o Glasgow Haskell Compiler (GHC), é um interpretador e um compilador de código nativo que roda na maioria das plataformas. O GHC é conhecido por seu rico sistema de tipos, incorporando inovações recentes, como tipos de dados algébricos generalizados e famílias de tipos. O Computer Language Benchmarks Game também destaca sua implementação de alto desempenho de simultaneidade e paralelismo . [44]

Existe uma comunidade ativa e crescente em torno da linguagem, e mais de 5.400 bibliotecas e ferramentas de código aberto de terceiros estão disponíveis no repositório de pacotes online Hackage . [45]

Exemplos de código

Um "Olá, Mundo!" programa em Haskell (apenas a última linha é estritamente necessária):

module  Main  ( main )  onde           -- não é necessário no interpretador, é o padrão em um arquivo de módulo

main  ::  IO  ()                      -- o compilador pode inferir esta definição de tipo 
main  =  putStrLn  "Hello, World!"

A função fatorial em Haskell, definida de algumas maneiras diferentes:

-- [[Assinatura de tipo|Anotação de tipo]] (opcional, o mesmo para cada implementação) 
fatorial  ::  ( Integral  a )  =>  a  ->  a

-- Usando recursão (com a expressão "ifthenelse") 
fatorial  n  =  if  n  <  2 
              then  1 
              else  n  *  fatorial  ( n  -  1 )

-- Usando recursão (com correspondência de padrões) 
fatorial  0  =  1 
fatorial  n  =  n  *  fatorial  ( n  -  1 )

-- Usando recursão (com guardas) 
fatorial  n 
   |  n  <  2      =  1 
   |  caso contrário  =  n  *  fatorial  ( n  -  1 )

-- Usando uma lista e a função "produto" 
fatorial  n  =  produto  [ 1 .. n ]

-- Usando dobra (implementa "produto") 
fatorial  n  =  dobral  ( * )  1  [ 1 .. n ]


-- Fatorial  de estilo sem pontos =  foldr  ( * )  1  .  enumFromTo  1

Como o tipo Integer tem precisão arbitrária , esse código calculará valores como factorial 100000(um número de 456.574 dígitos), sem perda de precisão.

Uma implementação de um algoritmo semelhante ao quick sort over lists, onde o primeiro elemento é tomado como pivô:

-- Anotação de tipo (opcional, igual para cada implementação) 
quickSort  ::  Ord  a  =>  [ a ]  ​​->  [ a ]

-- Usando compreensões de lista 
quickSort  []      =  []                                -- A lista vazia já está ordenada 
quickSort  ( x : xs )  =  quickSort  [ a  |  a  <-  xs ,  a  <  x ]    -- Ordena a parte esquerda da lista 
                   ++  [ x ]  ++                         -- Insere pivô entre duas partes ordenadas 
                   quickSort  [ a  |  a  <-  xs ,  a  >=  x ]   -- Classifica a parte direita da lista

-- Usando filtro 
quickSort  []      =  [] 
quickSort  ( x : xs )  =  quickSort  ( filtro  ( < x )  xs ) 
                   ++  [ x ]  ++ 
                   quickSort  ( filtro  ( >= x )  xs )

Implementações

Todas as implementações listadas são distribuídas sob licenças de código aberto . [46]

As implementações que cumprem totalmente ou quase com o padrão Haskell 98 incluem:

  • O Glasgow Haskell Compiler (GHC) compila para código nativo em muitas arquiteturas de processador diferentes e para ANSI C , por meio de uma das duas linguagens intermediárias : C-- , ou em versões mais recentes, bitcode LLVM (anteriormente Low Level Virtual Machine). [47] [48] GHC tornou-se o dialeto Haskell padrão de fato . [49] Existem bibliotecas (por exemplo, ligações para OpenGL ) que funcionam apenas com GHC. O GHC também é distribuído com a plataforma Haskell .
  • Jhc, um compilador Haskell escrito por John Meacham, enfatiza a velocidade e eficiência dos programas gerados e explora novas transformações de programas.
    • Ajhc é um fork de Jhc.
  • O Utrecht Haskell Compiler (UHC) é uma implementação Haskell da Universidade de Utrecht . [50] Ele suporta quase todos os recursos do Haskell 98, além de muitas extensões experimentais. Ele é implementado usando gramáticas de atributos e atualmente é usado principalmente para pesquisas sobre sistemas de tipos gerados e extensões de linguagem.

As implementações que não são mais mantidas ativamente incluem:

  • O sistema Gofer do usuário Haskell ( Hugs ) é um interpretador de bytecode . Ele já foi uma das implementações mais usadas, juntamente com o compilador GHC, [51] mas agora foi substituído principalmente pelo GHCi. Ele também vem com uma biblioteca gráfica.
  • HBC é uma implementação inicial que suporta Haskell 1.4. Foi implementado por Lennart Augustsson e baseado em Lazy ML . Ele não foi desenvolvido ativamente por algum tempo.
  • nhc98 é um compilador de bytecode com foco em minimizar o uso de memória.
    • O York Haskell Compiler ( Yhc ) foi um fork do nhc98, com o objetivo de ser mais simples, mais portátil e eficiente, além de integrar suporte ao Hat, o Haskell tracer. Ele também tinha um backend JavaScript , permitindo que os usuários executassem programas Haskell em navegadores da web .

As implementações não totalmente compatíveis com Haskell 98 e usando uma linguagem Haskell variante, incluem:

  • Eta e Frege são dialetos de Haskell visando a Java Virtual Machine .
  • Gofer era um dialeto educacional de Haskell, com um recurso chamado constructor classes , desenvolvido por Mark Jones. Foi suplantado pelo Hugs (Haskell User's Gofer System).
  • Hélio, um dialeto mais recente de Haskell. O foco está em tornar o aprendizado mais fácil por meio de mensagens de erro mais claras. Atualmente, ele não possui suporte completo para classes de tipos, tornando-o incompatível com muitos programas Haskell.

Aplicativos notáveis

  • O assistente de prova Agda está escrito em Haskell. [52]
  • Cabal é uma ferramenta para construir e empacotar bibliotecas e programas Haskell. [53]
  • Darcs é um sistema de controle de revisões escrito em Haskell, com diversos recursos inovadores, como controle mais preciso dos patches a serem aplicados.
  • O GHC também é frequentemente um banco de testes para recursos avançados de programação funcional e otimizações em outras linguagens de programação.
  • Git-annex é uma ferramenta para gerenciar (grandes) arquivos de dados sob controle de versão do Git . Ele também fornece um sistema distribuído de sincronização de arquivos (assistente git-annex).
  • Linspire Linux escolheu Haskell para o desenvolvimento de ferramentas do sistema. [54]
  • Pandoc é uma ferramenta para converter um formato de marcação em outro.
  • Pugs é um compilador e interpretador para a linguagem de programação Raku (anteriormente Perl 6).
  • TidalCycles é uma linguagem especial de domínio para padrão musical de codificação ao vivo, embutido em Haskell. [55]
  • Xmonad é um gerenciador de janelas para o X Window System , escrito totalmente em Haskell. [56]

Indústria

Web

Frameworks web notáveis ​​escritos para Haskell incluem: [63]

Críticas

Jan-Willem Maessen, em 2002, e Simon Peyton Jones , em 2003, discutiram problemas associados à avaliação preguiçosa, ao mesmo tempo em que reconheciam os motivos teóricos para ela. [64] [65] Além de considerações puramente práticas, como desempenho aprimorado, [66] eles observam que, além de adicionar alguma sobrecarga de desempenho, a avaliação preguiçosa torna mais difícil para os programadores raciocinar sobre o desempenho de seu código (particularmente seu uso do espaço).

Bastiaan Heeren, Daan Leijen e Arjan van IJzendoorn em 2003 também observaram alguns obstáculos para os alunos de Haskell: , já que a generalidade do Haskell geralmente leva a mensagens de erro enigmáticas." [67] Para resolver isso, pesquisadores da Universidade de Utrecht desenvolveram um interpretador avançado chamado Helium , que melhorou a facilidade de uso das mensagens de erro, limitando a generalidade de alguns recursos do Haskell e, em particular, removendo o suporte para classes de tipo .

Ben Lippmeier projetou o Disciple [68] como um dialeto estrito por padrão (preguiçoso por anotação explícita) de Haskell com um sistema de tipo e efeito, para abordar as dificuldades de Haskell em raciocinar sobre avaliação preguiçosa e no uso de estruturas de dados tradicionais, como mutáveis matrizes. [69] Ele argumenta (p. 20) que "a atualização destrutiva fornece ao programador duas ferramentas importantes e poderosas... novo valor para todas as partes de um programa com carga mínima para o programador."

Robert Harper , um dos autores do Standard ML , deu suas razões para não usar Haskell para ensinar programação introdutória. Entre eles estão a dificuldade de raciocinar sobre o uso de recursos com avaliação não estrita, que a avaliação preguiçosa complica a definição de tipos de dados e raciocínio indutivo, [70] e a "inferioridade" do (antigo) sistema de classes de Haskell em relação ao sistema de módulos de ML. [71]

A ferramenta de construção de Haskell, Cabal , tem sido historicamente criticada por lidar mal com várias versões da mesma biblioteca, um problema conhecido como "Cabal hell". O servidor Stackage e a ferramenta Stack build foram criados em resposta a essas críticas. [72] O próprio Cabal agora tem um sistema de compilação muito mais sofisticado, fortemente inspirado no Nix , [73] que se tornou o padrão com a versão 3.0.

Idiomas relacionados

Clean é um parente próximo e um pouco mais velho de Haskell. Seu maior desvio do Haskell está no uso de tipos de exclusividade em vez de mônadas para E/S e efeitos colaterais.

Uma série de linguagens inspiradas em Haskell, mas com diferentes sistemas de tipos, foram desenvolvidas, incluindo:

Outros idiomas relacionados incluem:

  • Curry , uma linguagem de programação funcional/lógica baseada em Haskell.

As variantes notáveis ​​do Haskell incluem:

  • Generic Haskell , uma versão do Haskell com suporte ao sistema de tipos para programação genérica .
  • Hume , uma linguagem funcional estrita para sistemas embarcados baseada em processos como autômatos sem estado sobre uma espécie de tuplas de canais de caixa de correio de um elemento onde o estado é mantido por feedback nas caixas de correio e uma descrição de mapeamento de saídas para canais como cabeamento de caixa, com um Linguagem e sintaxe de expressão semelhante a Haskell.

Conferências e workshops

A comunidade Haskell se reúne regularmente para atividades de pesquisa e desenvolvimento. Os principais eventos são:

A partir de 2006, ocorreu uma série de hackathons organizados , a série Hac, com o objetivo de aprimorar as ferramentas e bibliotecas da linguagem de programação. [74]

Referências

  1. ^ a b c Hudak et al. 2007 .
  2. ^ a b Marlow, Simon (24 de novembro de 2009). "Anunciando Haskell 2010" . Haskell (lista de discussão) . Recuperado em 12 de março de 2011 .
  3. ^ a b Riedel, Herbert (28 de abril de 2016). "ANN: o comitê Haskell Prime 2020 foi formado" . Haskell-prime (lista de discussão) . Recuperado em 6 de maio de 2017 .
  4. ^ a b c d e f g h i j k l m Peyton Jones 2003 , p. XI
  5. ^ Norell, Ulf (2008). "Programação tipada de forma dependente em Agda" (PDF) . Gotemburgo: Universidade Chalmers . Recuperado em 9 de fevereiro de 2012 .
  6. ^ Hudak et al. 2007 , pp. 12–38, 43.
  7. ^ Stroustrup, Bjarne ; Sutton, Andrew (2011). "Design de Bibliotecas de Conceito para C++" (PDF) . Arquivado do original (PDF) em 10 de fevereiro de 2012. {{cite journal}}:Cite journal requer |journal=( ajuda )
  8. ^ a b c d e f g h i j Hudak et al. 2007 , pp. 12-45-46.
  9. ^ a b Meijer, Erik (2006). "Confissões de um vendedor de linguagem de programação usada: Obtendo as massas viciadas em Haskell". Opsla 2007 . CiteSeerX 10.1.1.72.868 . 
  10. Meijer, Erik (1 de outubro de 2009). "Aulas C9: Dr. Erik Meijer – Fundamentos de Programação Funcional, Capítulo 1 de 13" . Canal 9 . Microsoft . Recuperado em 9 de fevereiro de 2012 .
  11. ^ Drobi, Sadek (4 de março de 2009). "Erik Meijer em LINQ" . InfoQ . QCon SF 2008: C4Media Inc. Recuperado em 9 de fevereiro de 2012 .{{cite news}}: Manutenção CS1: localização ( link )
  12. ^ Hickey, Rich. "Clojure Estante" . Listamania! . Arquivado a partir do original em 3 de outubro de 2017 . Recuperado em 3 de outubro de 2017 .
  13. Heller, Martin (18 de outubro de 2011). "Torça o nariz para o Dart e cheire o CoffeeScript" . InfoMundo . Recuperado 2020-07-15 .
  14. ^ "Programação declarativa em Escher" (PDF) . Recuperado em 7 de outubro de 2015 .
  15. ^ Syme, Don ; Granicz, Adam; Cisternino, Antonio (2007). Especialista F# . Apress . pág. 2. O F# também se baseia em Haskell, particularmente no que diz respeito a dois recursos avançados de linguagem chamados expressões de sequência e fluxos de trabalho .
  16. ^ Wechsung, Ingo. "Linguagem de Programação Frege" (PDF) . Recuperado em 26 de fevereiro de 2014 .
  17. ^ "Facebook apresenta 'Hack', a linguagem de programação do futuro" . COM CABO . 20 de março de 2014.
  18. ^ "Idris, uma linguagem de tipagem dependente" . Recuperado em 26 de outubro de 2014 .
  19. ^ "Inspiração do LiveScript" . Recuperado em 4 de fevereiro de 2014 .
  20. ^ Freeman, Phil (2016). "PureScript por exemplo" . Leanpub . Recuperado em 23 de abril de 2017 .
  21. ^ Kuchling, AM "como programação funcional" . Documentação do Python v2.7.2 . Fundação de Software Python . Recuperado em 9 de fevereiro de 2012 .
  22. ^ "Glossário de termos e jargão" . Perl Foundation Perl 6 Wiki . A Fundação Perl . Arquivado a partir do original em 21 de janeiro de 2012 . Recuperado em 9 de fevereiro de 2012 .
  23. ^ "A referência da oxidação: Apêndice: Influências" . Recuperado em 3 de fevereiro de 2016 .
  24. Fogus, Michael (6 de agosto de 2010). "Martin Odersky take(5) toList" . Envie mais paramédicos . Recuperado em 9 de fevereiro de 2012 .
  25. Lattner, Chris (3 de junho de 2014). "Homepage de Chris Lattner" . Chris Latner . Recuperado em 3 de junho de 2014 . A linguagem Swift é o produto do esforço incansável de uma equipe de especialistas em linguagem, gurus de documentação, ninjas de otimização de compiladores e um grupo interno incrivelmente importante de dogfooding que forneceu feedback para ajudar a refinar e testar ideias. Claro, também se beneficiou muito das experiências duramente conquistadas por muitas outras linguagens no campo, extraindo ideias de Objective-C, Rust, Haskell, Ruby, Python, C#, CLU e muitos outros para listar.
  26. ^ "Madeira / História" . Recuperado em 7 de outubro de 2015 .
  27. Chevalier, Tim (28 de janeiro de 2008). "alguém pode me dizer a pronúncia de "haskell"?" . Haskell-café (Lista de discussão) . Recuperado em 12 de março de 2011 .
  28. ^ Inferência de tipo originalmente usando inferência de tipo Hindley-Milner
  29. ^ a b c Peyton Jones 2003 .
  30. ^ Edward Kmett, Edward Kmett - Classes de Tipo vs. o Mundo
  31. ^ Equipe GHC 2020 (29 de outubro de 2021) GHC 9.2.1 lançado
  32. Mossberg, Erik (8 de junho de 2020), erkmos/haskell-companies , recuperado em 22 de junho de 2020
  33. ^ O'Sullivan, Bryan; Goerzen, John; Stewart, Donald Bruce (15 de novembro de 2008). Haskell do mundo real: código em que você pode acreditar . "O'Reilly Media, Inc.". pp. xxviii–xxxi. ISBN 978-0-596-55430-9.
  34. ^ "Haskell em Produção: Riskbook" . Empresa de Desenvolvimento de Software Serokell . Recuperado em 7 de setembro de 2021 .
  35. ^ "PYPL Popularity of Programming Language index" . pypl.github.io . Maio de 2021. Arquivado a partir do original em 7 de maio de 2021 . Recuperado em 16 de maio de 2021 .
  36. ^ Frederickson, Ben. "Ranking Programming Languages ​​by GitHub Users" . www.benfrederickson.com . Recuperado em 6 de setembro de 2019 .
  37. ^ a b c Peyton Jones 2003 , Prefácio.
  38. "Classes de tipo, propostas pela primeira vez durante o projeto da linguagem de programação Haskell, ..." — John Garrett Morris (2013), "Classes de tipo e cadeias de instâncias: uma abordagem relacional"
  39. ^ Wadler, Philip (outubro de 1988). "Como tornar o polimorfismo ad-hoc menos ad hoc" .
  40. ^ "Haskell Wiki: Implementações" . Recuperado em 18 de dezembro de 2012 .
  41. ^ "Bem-vindo a Haskell"" . O Wiki Haskell .
  42. ^ Wadler, P.; Blott, S. (1989). "Como fazer polimorfismo ad-hoc menos ad hoc". Anais do 16º Simpósio ACM SIGPLAN-SIGACT sobre Princípios de Linguagens de Programação . ACM : 60-76. doi : 10.1145/75277.75283 . ISBN 978-0-89791-294-5. S2CID  15327197 .
  43. ^ Hallgren, T. (janeiro de 2001). "Diversão com Dependências Funcionais, ou Tipos como Valores em Computações Estáticas em Haskell" . Anais da Reunião Conjunta de Inverno CS/CE . Varberg, Suécia.
  44. ^ Jogo de benchmarks de linguagem de computador
  45. ^ "Estatísticas do HackageDB" . Hackage.haskell.org. Arquivado a partir do original em 3 de maio de 2013 . Recuperado em 26 de junho de 2013 .
  46. ^ "Implementações" no Haskell Wiki
  47. ^ "O back-end LLVM" . GHC Trac .
  48. ^ Terei, David A.; Chakravarty, Manuel MT (2010). "Um back-end LLVM para GHC" . Anais do Simpósio ACM SIGPLAN Haskell 2010 . Imprensa ACM.
  49. ^ C. Ryder e S. Thompson (2005). "Portando HaRe para a API GHC"
  50. ^ Compilador Utrecht Haskell
  51. ^ Hudak et al. 2007 , pp. 12–22.
  52. Agda 2 , Agda Github Community, 15 de outubro de 2021 , recuperado em 16 de outubro de 2021
  53. ^ "A cabala Haskell" . Recuperado em 8 de abril de 2015 .
  54. ^ "Linspire/Freespire Core OS Team e Haskell" . Lista de discussão Debian Haskell . Maio de 2006.
  55. ^ "Código ao vivo com Tidal Cycles | Tidal Cycles" . doc.tidalcycles.org . Recuperado em 19 de janeiro de 2022 .
  56. ^ xmonad.org
  57. ^ "Combater spam com Haskell" . Código do Facebook . 26 de junho de 2015 . Recuperado em 11 de agosto de 2019 .
  58. ^ "Haxl de código aberto, uma biblioteca para Haskell" . Código do Facebook . 10 de junho de 2014 . Recuperado em 11 de agosto de 2019 .
  59. ^ https://github.com/input-output-hk/cardano-node
  60. ^ Analisando, analisando e comparando o código-fonte em vários idiomas: github/semantic , GitHub, 7 de junho de 2019 , recuperado em 7 de junho de 2019
  61. ^ a b c d Uma prova formal de correção funcional foi concluída em 2009. Klein, Gerwin; Elphinstone, Kevin; Heiser, Gernot ; Andronic, junho; Galo, David; Derrin, Philip; Elkaduwe, Dhammika; Engelhardt, Kai; Kolanski, Rafael; Norris, Michael; Sewell, Thomas; Tuch, Harvey; Winwood, Simon (outubro de 2009). "seL4: Verificação formal de um kernel do sistema operacional" (PDF) . 22º Simpósio ACM sobre Princípios de Sistemas Operacionais . Big Sky, MT, EUA.
  62. ^ Yula Gavrilova e Gints Dreimanis. Os 6 principais projetos de software escritos em Haskell. Blog Serokell. 17 de outubro de 2019. ( https://serokell.io/blog/top-software-written-in-haskell ). Acessado em 4 de novembro de 2021
  63. ^ "Web/Frameworks – HaskellWiki" . wiki.haskell.org . Recuperado em 11 de agosto de 2019 .
  64. ^ Jan-Willem Maessen. Eager Haskell: A execução limitada a recursos gera uma iteração eficiente . Anais do workshop SIGPLAN 2002 Association for Computing Machinery (ACM) sobre Haskell.
  65. ^ Simon Peyton Jones. Vestindo a camisa de cabelo: uma retrospectiva sobre Haskell . Palestra convidada no POPL 2003.
  66. ^ "A avaliação preguiçosa pode levar a um excelente desempenho, como em The Computer Language Benchmarks Game" .
  67. ^ Heeren, Bastiaan; Leijen, Daan; van IJzendoorn, Arjan (2003). "Hélio, para aprender Haskell" (PDF) . Anais do Workshop 2003 ACM SIGPLAN sobre Haskell : 62–71. doi : 10.1145/871895.871902 . ISBN  1581137583. S2CID  11986908 .
  68. ^ "DDC - HaskellWiki" . Haskell.org. 3 de dezembro de 2010 . Recuperado em 26 de junho de 2013 .
  69. Ben Lippmeier, Type Inference and Optimization for an Impure World , Australian National University (2010) tese de doutorado, capítulo 1
  70. ^ Robert Harper. "O ponto da preguiça" . acesso fechado
  71. ^ Robert Harper. "Módulos são mais importantes" . acesso fechado
  72. ^ "Resolvendo o Inferno Cabal" . www.yesodweb.com . Recuperado em 11 de agosto de 2019 .
  73. ^ "Anunciando a nova construção da cabala: construções locais no estilo Nix" . Recuperado em 1 de outubro de 2019 .
  74. ^ "Hackathon - HaskellWiki" .

Leitura adicional

Relatórios
Livros didáticos
Tutoriais
História

Links externos