Controlando o escopo de instâncias em Haskell
Ano de defesa: | 2012 |
---|---|
Autor(a) principal: | |
Orientador(a): | |
Banca de defesa: | , , , |
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 |