---
_id: '10153'
abstract:
- lang: eng
  text: "Gradual typing is a principled means for mixing typed and untyped code. But
    typed and untyped code often exhibit different programming patterns. There is
    already substantial research investigating gradually giving types to code exhibiting
    typical untyped patterns, and some research investigating gradually removing types
    from code exhibiting typical typed patterns. This paper investigates how to extend
    these established gradual-typing concepts to give formal guarantees not only about
    how to change types as code evolves but also about how to change such programming
    patterns as well.\r\n\r\nIn particular, we explore mixing untyped \"structural\"
    code with typed \"nominal\" code in an object-oriented language. But whereas previous
    work only allowed \"nominal\" objects to be treated as \"structural\" objects,
    we also allow \"structural\" objects to dynamically acquire certain nominal types,
    namely interfaces. We present a calculus that supports such \"cross-paradigm\"
    code migration and interoperation in a manner satisfying both the static and dynamic
    gradual guarantees, and demonstrate that the calculus can be implemented efficiently."
acknowledgement: "We thank the reviewers for their valuable suggestions towards improving
  the paper. We also \r\nthank Mae Milano and Adrian Sampson, as well as the members
  of the Programming Languages Discussion Group at Cornell University and of the Programming
  Research Laboratory at Northeastern University, for their helpful feedback on preliminary
  findings of this work.\r\n\r\nThis material is based upon work supported in part
  by the National Science Foundation (NSF) through grant CCF-1350182 and the Austrian
  Science Fund (FWF) through grant Z211-N23 (Wittgenstein~Award).\r\nAny opinions,
  findings, and conclusions or recommendations expressed in this material are those
  of the authors and do not necessarily reflect the views of the NSF or the FWF."
article_number: '127'
article_processing_charge: No
article_type: original
author:
- first_name: Fabian
  full_name: Mühlböck, Fabian
  id: 6395C5F6-89DF-11E9-9C97-6BDFE5697425
  last_name: Mühlböck
  orcid: 0000-0003-1548-0177
- first_name: Ross
  full_name: Tate, Ross
  last_name: Tate
citation:
  ama: Mühlböck F, Tate R. Transitioning from structural to nominal code with efficient
    gradual typing. <i>Proceedings of the ACM on Programming Languages</i>. 2021;5.
    doi:<a href="https://doi.org/10.1145/3485504">10.1145/3485504</a>
  apa: 'Mühlböck, F., &#38; Tate, R. (2021). Transitioning from structural to nominal
    code with efficient gradual typing. <i>Proceedings of the ACM on Programming Languages</i>.
    Chicago, IL, United States: Association for Computing Machinery. <a href="https://doi.org/10.1145/3485504">https://doi.org/10.1145/3485504</a>'
  chicago: Mühlböck, Fabian, and Ross Tate. “Transitioning from Structural to Nominal
    Code with Efficient Gradual Typing.” <i>Proceedings of the ACM on Programming
    Languages</i>. Association for Computing Machinery, 2021. <a href="https://doi.org/10.1145/3485504">https://doi.org/10.1145/3485504</a>.
  ieee: F. Mühlböck and R. Tate, “Transitioning from structural to nominal code with
    efficient gradual typing,” <i>Proceedings of the ACM on Programming Languages</i>,
    vol. 5. Association for Computing Machinery, 2021.
  ista: Mühlböck F, Tate R. 2021. Transitioning from structural to nominal code with
    efficient gradual typing. Proceedings of the ACM on Programming Languages. 5,
    127.
  mla: Mühlböck, Fabian, and Ross Tate. “Transitioning from Structural to Nominal
    Code with Efficient Gradual Typing.” <i>Proceedings of the ACM on Programming
    Languages</i>, vol. 5, 127, Association for Computing Machinery, 2021, doi:<a
    href="https://doi.org/10.1145/3485504">10.1145/3485504</a>.
  short: F. Mühlböck, R. Tate, Proceedings of the ACM on Programming Languages 5 (2021).
conference:
  end_date: 2021-10-23
  location: Chicago, IL, United States
  name: 'OOPSLA: Object-Oriented Programming, Systems, Languages, and Applications'
  start_date: 2021-10-17
date_created: 2021-10-19T12:48:44Z
date_published: 2021-10-15T00:00:00Z
date_updated: 2021-11-12T11:30:07Z
day: '15'
ddc:
- '005'
department:
- _id: ToHe
doi: 10.1145/3485504
file:
- access_level: open_access
  checksum: 71011efd2da771cafdec7f0d9693f8c1
  content_type: application/pdf
  creator: fmuehlbo
  date_created: 2021-10-19T12:52:23Z
  date_updated: 2021-10-19T12:52:23Z
  file_id: '10154'
  file_name: monnom-oopsla21.pdf
  file_size: 770269
  relation: main_file
  success: 1
file_date_updated: 2021-10-19T12:52:23Z
has_accepted_license: '1'
intvolume: '         5'
keyword:
- gradual typing
- gradual guarantee
- nominal
- structural
- call tags
language:
- iso: eng
license: https://creativecommons.org/licenses/by-nd/4.0/
month: '10'
oa: 1
oa_version: Published Version
project:
- _id: 25F42A32-B435-11E9-9278-68D0E5697425
  call_identifier: FWF
  grant_number: Z211
  name: The Wittgenstein Prize
publication: Proceedings of the ACM on Programming Languages
publication_identifier:
  eissn:
  - 2475-1421
publication_status: published
publisher: Association for Computing Machinery
quality_controlled: '1'
status: public
title: Transitioning from structural to nominal code with efficient gradual typing
tmp:
  image: /image/cc_by_nd.png
  legal_code_url: https://creativecommons.org/licenses/by-nd/4.0/legalcode
  name: Creative Commons Attribution-NoDerivatives 4.0 International (CC BY-ND 4.0)
  short: CC BY-ND (4.0)
type: journal_article
user_id: 8b945eb4-e2f2-11eb-945a-df72226e66a9
volume: 5
year: '2021'
...