Global ETD Search

Search theses and dissertations gathered from participating repositories worldwide. Every result links back to the library that holds it. No account is needed.

Results

Showing 1 to 17 of 17 for “"Gradual Typing"”.

  1. Gradual Typing for Python, Unguarded

    Gradual typing integrates static and dynamic typing with the guarantee that statically typed regions of a program will never have their types violated even if they interact with dynamically typed regions. Traditionally, this guarantee has been achieved by using proxies to mediate when values flow …

    iu Repository record for Gradual Typing for Python, Unguarded (opens in a new tab)

  2. Efficient Runtimes for Gradual Typing

    … of programming languages featuring gradual typing - which is the idea that some parts of a program may be type-checked dynamically while others are type-checked statically. This lets programmers trade off between the costs and benefits of using static type-checking for each …

    cornell Repository record for Efficient Runtimes for Gradual Typing (opens in a new tab)

  3. Gradual Typing for a More Pure JavaScript

    … However, for projects of a certain size dynamictyping can cause problems of maintainability as refactoring becomes increas-ingly difficult. One proposed solution is the use of gradual type systems, wherestatic type annotations are optional. This results in providing the best of bothworlds. The …

    chalmers Repository record for Gradual Typing for a More Pure JavaScript (opens in a new tab)

  4. TOWARDS EFFICIENT GRADUAL TYPING VIA MONOTONIC REFERENCES AND COERCIONS

    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 …

    iu Repository record for TOWARDS EFFICIENT GRADUAL TYPING VIA MONOTONIC REFERENCES AND COERCIONS (opens in a new tab)

  5. Formal Semantics and Mechanized Soundness Proof for Fast Gradually Typed JavaScript

    … typed languages. This led to the development of gradual typing, a typing paradigm which is a compromise between static and dynamic typing. In gradual typing, programmers can specify type annotations if and when they choose to; then, at compile time, the statically typed sections of code are type …

    waterloo Repository record for Formal Semantics and Mechanized Soundness Proof for Fast Gradually Typed JavaScript (opens in a new tab)

  6. A formal framework for understanding run-time checking errors in gradually typed languages

    Although Abstracting Gradual Typing provides a systematic approach to design gradual languages, the original framework has limitations: first, it accepts design choices that lead to type inconsistencies sneaking through evaluation. Second, when a type inconsistency is identified at run time, …

    ubc Repository record for A formal framework for understanding run-time checking errors in gradually typed languages (opens in a new tab) Download PDF for A formal framework for understanding run-time checking errors in gradually typed languages (opens in a new tab)

  7. Gradual Pluggable Typing in Java

    Gradual typing provides the ability to safely mix untyped or dynamically typed code with statically typed code while maintaining, within the statically typed portion, the guarantees claimed by the static typing. It is motivated by the idea that different amounts of typing are valuable at different …

    waterloo Repository record for Gradual Pluggable Typing in Java (opens in a new tab)

  8. An Argument against Gradual Type Systems in Programming Language Semantics

    … Siek and Walid Taha formalized the concept of gradual type systems, which integrates static and dynamic typing in a single programming language. This allows the programmer to statically or dynamically type portions of their code at will, which offers more flexibility than languages that require …

    lmu Repository record for An Argument against Gradual Type Systems in Programming Language Semantics (opens in a new tab)

  9. Gradual security typing

    … goal is achieved by applying ideas from gradual typing to security type systems.<br>Gradual typing is an area of programming language research that studies the principled integration of static and dynamic types.<br>Statically typed fragments of a program communicate with dynamically typed …

    freiburg-diss Repository record for Gradual security typing (opens in a new tab)

  10. Scala with Explicit Nulls

    … (like Java). Using the concept of blame from gradual typing, I show that if a well-typed program fails with certain kinds of nullability errors, an implicitly-nullable subterm can always be blamed for the failure.

    waterloo Repository record for Scala with Explicit Nulls (opens in a new tab)

  11. Generalised Type Preprocessing for Integrated Subtyping

    Subtyping is a common feature that organises types into hierarchies, which is used for encoding various forms of polymorphism. Subtype relations are typically defined syntactically using axioms and inference rules, but they do not always directly translate to a decision procedure. Therefore, in …

    anu Repository record for Generalised Type Preprocessing for Integrated Subtyping (opens in a new tab)

  12. A dependently typed programming language with dynamic equality

    … forced to use. When combined with a traditional typing workflow, these systems can be quite challenging and require a large amount of expertise to master. This thesis explores an alternative workflow and a more liberal handling of equality. Programmers are given warnings that contain the same …

    bu Repository record for A dependently typed programming language with dynamic equality (opens in a new tab)

  13. Reasoning About Foreign Function Interfaces: Blame and Nondeterministic Formal Semantics

    … echoes that of typed and untyped code in gradual type systems. In such systems, untyped values flowing into typed code must be cast at the boundary between typed and untyped code, and this introduces the possibility for runtime type errors in otherwise statically guaranteed code. …

    waterloo Repository record for Reasoning About Foreign Function Interfaces: Blame and Nondeterministic Formal Semantics (opens in a new tab)

  14. No Zombie Types: Liveness-Based Justification For Monotonic Gradual Types

    Gradual type systems with the monotonic dynamic semantics, such as HiggsCheck implementing SafeTypeScript, are able to achieve decent performance, making them a viable option for JavaScript programmers seeking run-time-checkable type annotations. However, the type restrictions for objects in the …

    waterloo Repository record for No Zombie Types: Liveness-Based Justification For Monotonic Gradual Types (opens in a new tab)

  15. An Integrated Theory of Type-Based Static and Dynamic Verification

    © 2015 Springer. http://dx.doi.org/10.1007/978-3-319-26529-2_11© 2015 ACM, Inc. http://doi.acm.org/10.1145/2676726.2676996

    kyoto Repository record for An Integrated Theory of Type-Based Static and Dynamic Verification (opens in a new tab)

  16. Static Types with Less Syntax: Locus Types

    Optionally and gradually-typed languages allow types to be introduced to dynamic code as needed. While this approach allows some gradual movement from dynamically to statically-typed code, it requires rewriting object-constructing code to use conventional static types. We introduce a flexible …

    waterloo Repository record for Static Types with Less Syntax: Locus Types (opens in a new tab)

  17. Gradual C Programming for Typed Lua

    … and automation. Optional type-systems and gradual type-systems realize some of the security benefits offered in statically-typed languages by adding a static type-system to a dynamically-typed language. However, these approaches generally do not provide the performance advantages of …

    waterloo Repository record for Gradual C Programming for Typed Lua (opens in a new tab)