TOWARDS EFFICIENT GRADUAL TYPING VIA MONOTONIC REFERENCES AND COERCIONS
dc.contributor.advisor | Siek, Jeremy | |
dc.contributor.author | Almahallawi, Deyaaeldeen | |
dc.date.accessioned | 2020-06-22T16:42:17Z | |
dc.date.available | 2020-06-22T16:42:17Z | |
dc.date.issued | 2020-06 | |
dc.description | Thesis (Ph.D.) - Indiana University, Luddy School of Informatics, Computing, and Engineering/University Graduate School, 2020 | en |
dc.description.abstract | Integrating static and dynamic typing into a single programming language enables programmers to choose which discipline to use in each code region. Different approaches for this integration have been studied and put into use at large scale, e.g. TypeScript for JavaScript and adding the dynamic type to C#. Gradual typing is one approach to this integration that preserves type soundness by performing type-checking at run-time using casts. For higher order values such as functions and mutable references, a cast typically wraps the value in a proxy that performs type-checking when the value is used. This approach suffers from two problems: (1) chains of proxies can grow and consume unbounded space, and (2) statically typed code regions need to check whether values are proxied. Monotonic references solve both problems for mutable references by directly casting the heap cell instead of wrapping the reference in a proxy. In this dissertation, an integration is proposed of monotonic references with the coercion-based solution to the problem of chains of proxies for other values such as functions. Furthermore, the prior semantics for monotonic references involved storing and evaluating cast expressions (not yet values) in the heap and it is not obvious how to implement this behavior efficiently in a compiler and run-time system. This dissertation proposes novel dynamic semantics where only values are written to the heap, making the semantics straightforward to implement. The approach is implemented in Grift, a compiler for a gradually typed programming language, and a few key optimizations are proposed. Finally, the proposed performance evaluation methodology shows that the proposed approach eliminates all overheads associated with gradually typed references in statically typed code regions without introducing significant average-case overhead. | en |
dc.identifier.uri | https://hdl.handle.net/2022/25620 | |
dc.language.iso | en | en |
dc.publisher | [Bloomington, Ind.] : Indiana University | en |
dc.rights | This work is under a CC-BY license. You are free to copy and redistribute the material in any format, as well as remix, transform, and build upon the material as long as you give appropriate credit to the original creator, provide a link to the license, and indicate any changes made. | en |
dc.rights.uri | https://creativecommons.org/licenses/by/4.0/ | en |
dc.subject | compilers | en |
dc.subject | gradual typing | en |
dc.subject | performance | en |
dc.title | TOWARDS EFFICIENT GRADUAL TYPING VIA MONOTONIC REFERENCES AND COERCIONS | en |
dc.type | Doctoral Dissertation | en |
Files
Original bundle
1 - 1 of 1
Loading...
- Name:
- dissertation.pdf
- Size:
- 4.86 MB
- Format:
- Adobe Portable Document Format
- Description:
Collections
If you need an accessible version of this item, please email your request to iusw@iu.edu so that they may create one and provide it to you.