Controlando o escopo de instâncias em Haskell

Detalhes bibliográficos
Ano de defesa: 2012
Autor(a) principal: Marco Túlio Gontijo e Silva
Orientador(a): Carlos Camarao de Figueiredo
Banca de defesa: Fernando Magno Quintao Pereira, Mariza Andrade da Silva Bigonha, Andre Luís de Medeiros Santos, Lucilia Camarão de Figueiredo
Tipo de documento: Dissertação
Tipo de acesso: Acesso aberto
Idioma: por
Instituição de defesa: Universidade Federal de Minas Gerais
Programa de Pós-Graduação: Não Informado pela instituição
Departamento: Não Informado pela instituição
País: Não Informado pela instituição
Palavras-chave em Português:
Link de acesso: http://hdl.handle.net/1843/ESBF-935NQ7
Resumo: O sistema de módulos de Haskell objetiva a simplicidade e possui a notável vantagem de ser fácil de aprender e usar. Entretanto, instâncias de classes de tipo em Haskell são sempre exportadas e importadas entre módulos. Isso quebra a uniformidade e simplicidade do sistema de módulos e introduz problemas práticos. Instâncias criadas em módulos diferentes podem conflitar umas com as outras e podem fazer com que seja impossível importar dois módulos que contenham definições de uma mesma instância se essa instância for utilizada. Isso faz com que seja muito incoveniente a definição de duas instâncias diferentes da mesma classe de tipos para o mesmo tipo em diferentes módulos de um mesmo programa. A definição de instâncias em módulos onde nem o tipo nem a classe de tipos são definidos se tornou uma má prática, e essas instâncias foram chamadas de instâncias órfãs. Somente esse tipo de instância pode causar conflitos já que, se instâncias forem definidas apenas no mesmo módulo do tipo ou da classe de tipos, só poderá existir uma instância para cada par de classe e tipo. Nessa dissertação nós apresentamos e discutimos uma solução para esses problemas que simplesmente permite que haja controle sobre a importação e exportação de instâncias entre módulos, por meio de uma pequena alteração na linguagem. A solução é apresentada em duas versões. A versão final, mais consistente, não é compatível comHaskell, isto é, programas que funcionam em Haskell podem deixar de funcionar com essa alteração. A versão intermediária traz os benefícios da proposta, é compatível com Haskell, mas é um pouco menos consistente. Para evitar que o programador precise escrever nomes de instâncias muito longos nas listas de controle de importação eexportação de módulos, propomos outra pequena alteração na linguagem, que torna possível dar nomes mais curtos a instâncias.Também mostramos como a especificação formal do sistema de módulos precisa ser adaptada para lidar com nossa proposta. Como a especificação formal não tratava instâncias, primeiro adaptamos essa especificação para tratar instâncias e, em seguida, mostramos como nossa proposta é especificada formalmente.
id UFMG_05bc9311952476ae5409e32021677035
oai_identifier_str oai:repositorio.ufmg.br:1843/ESBF-935NQ7
network_acronym_str UFMG
network_name_str Repositório Institucional da UFMG
repository_id_str
spelling Carlos Camarao de FigueiredoFernando Magno Quintao PereiraMariza Andrade da Silva BigonhaAndre Luís de Medeiros SantosLucilia Camarão de FigueiredoMarco Túlio Gontijo e Silva2019-08-14T05:28:24Z2019-08-14T05:28:24Z2012-12-20http://hdl.handle.net/1843/ESBF-935NQ7O sistema de módulos de Haskell objetiva a simplicidade e possui a notável vantagem de ser fácil de aprender e usar. Entretanto, instâncias de classes de tipo em Haskell são sempre exportadas e importadas entre módulos. Isso quebra a uniformidade e simplicidade do sistema de módulos e introduz problemas práticos. Instâncias criadas em módulos diferentes podem conflitar umas com as outras e podem fazer com que seja impossível importar dois módulos que contenham definições de uma mesma instância se essa instância for utilizada. Isso faz com que seja muito incoveniente a definição de duas instâncias diferentes da mesma classe de tipos para o mesmo tipo em diferentes módulos de um mesmo programa. A definição de instâncias em módulos onde nem o tipo nem a classe de tipos são definidos se tornou uma má prática, e essas instâncias foram chamadas de instâncias órfãs. Somente esse tipo de instância pode causar conflitos já que, se instâncias forem definidas apenas no mesmo módulo do tipo ou da classe de tipos, só poderá existir uma instância para cada par de classe e tipo. Nessa dissertação nós apresentamos e discutimos uma solução para esses problemas que simplesmente permite que haja controle sobre a importação e exportação de instâncias entre módulos, por meio de uma pequena alteração na linguagem. A solução é apresentada em duas versões. A versão final, mais consistente, não é compatível comHaskell, isto é, programas que funcionam em Haskell podem deixar de funcionar com essa alteração. A versão intermediária traz os benefícios da proposta, é compatível com Haskell, mas é um pouco menos consistente. Para evitar que o programador precise escrever nomes de instâncias muito longos nas listas de controle de importação eexportação de módulos, propomos outra pequena alteração na linguagem, que torna possível dar nomes mais curtos a instâncias.Também mostramos como a especificação formal do sistema de módulos precisa ser adaptada para lidar com nossa proposta. Como a especificação formal não tratava instâncias, primeiro adaptamos essa especificação para tratar instâncias e, em seguida, mostramos como nossa proposta é especificada formalmente.The Haskell module system aims for simplicity and has a notableadvantage of being easy to learn and use. However, type classinstances in Haskell are always exported and imported betweenmodules. This breaches uniformity and simplicity of the module systemand introduces practical problems. instances created in different modules can conflict with each other, and can make it impossible to import two modules that contain instance definitions if this instance is used. Because of this, it is not very incovenient to define two distinct instances of the same type class for the same type in a program. As a workaround for this problem, the definition of instances in modules where the data type or the type class are not defined became a bad practice, and these instances were called orphans. Only these instances can cause the conflict since, as non-orphan instances are defined in the same module of the type or of the type class, there will be only one instance for each class and each type. In this dissertation we present and discuss a solution to these problems that simply allows control over importation and exportation of instances between modules, through a small change in the language. The solution is presented in two versions. The final version, more consistent, is not compatible with Haskell, that is, programs that work on Haskell may not work with this change. The intermediate version, on the other hand, brings the benefits of the proposal while being compatible with Haskell, although it is less consistent. In order to avoid that the programmer needs to write very long names for the instances in the importation and exportation control lists on modules, we propose another small change in the language in which it is possible to give shorter names to instances. We also show how a formal specification of the module system must be adapted to include our proposal. As the formal specification didn't handle instances in general, we adapt this specification to handle instances at first, and then show how our proposal can be formally specified.Universidade Federal de Minas GeraisUFMGHaskell (Linguagem de programação de computador)ComputaçãoMódulosHaskellInstâncias de classes de tipoControlando o escopo de instâncias em Haskellinfo:eu-repo/semantics/publishedVersioninfo:eu-repo/semantics/masterThesisinfo:eu-repo/semantics/openAccessporreponame:Repositório Institucional da UFMGinstname:Universidade Federal de Minas Gerais (UFMG)instacron:UFMGORIGINALmarcotuliogontijo.pdfapplication/pdf3079559https://repositorio.ufmg.br/bitstream/1843/ESBF-935NQ7/1/marcotuliogontijo.pdf514a68276c8406202033f2881739e301MD51TEXTmarcotuliogontijo.pdf.txtmarcotuliogontijo.pdf.txtExtracted texttext/plain88375https://repositorio.ufmg.br/bitstream/1843/ESBF-935NQ7/2/marcotuliogontijo.pdf.txtf76ee8a29091c8b5d8b9fcd7ddb4e0beMD521843/ESBF-935NQ72019-11-14 19:52:38.845oai:repositorio.ufmg.br:1843/ESBF-935NQ7Repositório de PublicaçõesPUBhttps://repositorio.ufmg.br/oaiopendoar:2019-11-14T22:52:38Repositório Institucional da UFMG - Universidade Federal de Minas Gerais (UFMG)false
dc.title.pt_BR.fl_str_mv Controlando o escopo de instâncias em Haskell
title Controlando o escopo de instâncias em Haskell
spellingShingle Controlando o escopo de instâncias em Haskell
Marco Túlio Gontijo e Silva
Módulos
Haskell
Instâncias de classes de tipo
Haskell (Linguagem de programação de computador)
Computação
title_short Controlando o escopo de instâncias em Haskell
title_full Controlando o escopo de instâncias em Haskell
title_fullStr Controlando o escopo de instâncias em Haskell
title_full_unstemmed Controlando o escopo de instâncias em Haskell
title_sort Controlando o escopo de instâncias em Haskell
author Marco Túlio Gontijo e Silva
author_facet Marco Túlio Gontijo e Silva
author_role author
dc.contributor.advisor1.fl_str_mv Carlos Camarao de Figueiredo
dc.contributor.referee1.fl_str_mv Fernando Magno Quintao Pereira
dc.contributor.referee2.fl_str_mv Mariza Andrade da Silva Bigonha
dc.contributor.referee3.fl_str_mv Andre Luís de Medeiros Santos
dc.contributor.referee4.fl_str_mv Lucilia Camarão de Figueiredo
dc.contributor.author.fl_str_mv Marco Túlio Gontijo e Silva
contributor_str_mv Carlos Camarao de Figueiredo
Fernando Magno Quintao Pereira
Mariza Andrade da Silva Bigonha
Andre Luís de Medeiros Santos
Lucilia Camarão de Figueiredo
dc.subject.por.fl_str_mv Módulos
Haskell
Instâncias de classes de tipo
topic Módulos
Haskell
Instâncias de classes de tipo
Haskell (Linguagem de programação de computador)
Computação
dc.subject.other.pt_BR.fl_str_mv Haskell (Linguagem de programação de computador)
Computação
description O sistema de módulos de Haskell objetiva a simplicidade e possui a notável vantagem de ser fácil de aprender e usar. Entretanto, instâncias de classes de tipo em Haskell são sempre exportadas e importadas entre módulos. Isso quebra a uniformidade e simplicidade do sistema de módulos e introduz problemas práticos. Instâncias criadas em módulos diferentes podem conflitar umas com as outras e podem fazer com que seja impossível importar dois módulos que contenham definições de uma mesma instância se essa instância for utilizada. Isso faz com que seja muito incoveniente a definição de duas instâncias diferentes da mesma classe de tipos para o mesmo tipo em diferentes módulos de um mesmo programa. A definição de instâncias em módulos onde nem o tipo nem a classe de tipos são definidos se tornou uma má prática, e essas instâncias foram chamadas de instâncias órfãs. Somente esse tipo de instância pode causar conflitos já que, se instâncias forem definidas apenas no mesmo módulo do tipo ou da classe de tipos, só poderá existir uma instância para cada par de classe e tipo. Nessa dissertação nós apresentamos e discutimos uma solução para esses problemas que simplesmente permite que haja controle sobre a importação e exportação de instâncias entre módulos, por meio de uma pequena alteração na linguagem. A solução é apresentada em duas versões. A versão final, mais consistente, não é compatível comHaskell, isto é, programas que funcionam em Haskell podem deixar de funcionar com essa alteração. A versão intermediária traz os benefícios da proposta, é compatível com Haskell, mas é um pouco menos consistente. Para evitar que o programador precise escrever nomes de instâncias muito longos nas listas de controle de importação eexportação de módulos, propomos outra pequena alteração na linguagem, que torna possível dar nomes mais curtos a instâncias.Também mostramos como a especificação formal do sistema de módulos precisa ser adaptada para lidar com nossa proposta. Como a especificação formal não tratava instâncias, primeiro adaptamos essa especificação para tratar instâncias e, em seguida, mostramos como nossa proposta é especificada formalmente.
publishDate 2012
dc.date.issued.fl_str_mv 2012-12-20
dc.date.accessioned.fl_str_mv 2019-08-14T05:28:24Z
dc.date.available.fl_str_mv 2019-08-14T05:28:24Z
dc.type.status.fl_str_mv info:eu-repo/semantics/publishedVersion
dc.type.driver.fl_str_mv info:eu-repo/semantics/masterThesis
format masterThesis
status_str publishedVersion
dc.identifier.uri.fl_str_mv http://hdl.handle.net/1843/ESBF-935NQ7
url http://hdl.handle.net/1843/ESBF-935NQ7
dc.language.iso.fl_str_mv por
language por
dc.rights.driver.fl_str_mv info:eu-repo/semantics/openAccess
eu_rights_str_mv openAccess
dc.publisher.none.fl_str_mv Universidade Federal de Minas Gerais
dc.publisher.initials.fl_str_mv UFMG
publisher.none.fl_str_mv Universidade Federal de Minas Gerais
dc.source.none.fl_str_mv reponame:Repositório Institucional da UFMG
instname:Universidade Federal de Minas Gerais (UFMG)
instacron:UFMG
instname_str Universidade Federal de Minas Gerais (UFMG)
instacron_str UFMG
institution UFMG
reponame_str Repositório Institucional da UFMG
collection Repositório Institucional da UFMG
bitstream.url.fl_str_mv https://repositorio.ufmg.br/bitstream/1843/ESBF-935NQ7/1/marcotuliogontijo.pdf
https://repositorio.ufmg.br/bitstream/1843/ESBF-935NQ7/2/marcotuliogontijo.pdf.txt
bitstream.checksum.fl_str_mv 514a68276c8406202033f2881739e301
f76ee8a29091c8b5d8b9fcd7ddb4e0be
bitstream.checksumAlgorithm.fl_str_mv MD5
MD5
repository.name.fl_str_mv Repositório Institucional da UFMG - Universidade Federal de Minas Gerais (UFMG)
repository.mail.fl_str_mv
_version_ 1803589606195593216