Gradual typing
Type system
- 9 min read
- 4 chapters
Related on Lably
Through Type conversion, Variable (high-level programming language) and JS++
In many cases gradual typing is added to an existing dynamic language, creating a derived language allowing for, but not requiring, static typing to be used. In some cases, a language uses gradual typing from the start. However, there are performance and implementation complexity tradeoffs compared to dynamic or optional typing.
History
The term was coined by Jeremy Siek, who developed gradual typing in 2006 with Walid Taha.
Sign in to keep reading
3 more chapters are free with a Lably account.
Implementation
In gradual typing, a special type named dynamic is used to represent statically-unknown types. The notion of type equality is replaced by a new relation called consistency that relates the dynamic type to every other type. The consistency relation is reflexive and symmetric but not transitive.
Prior attempts at integrating static and dynamic typing tried to make the dynamic type be both the top and bottom of the subtype hierarchy. However, because subtyping is transitive, that results in every type becoming related to every other type, and so subtyping would no longer rule out any static type errors. The addition of a second phase of plausibility checking to the type system did not completely solve this problem.
Gradual typing can easily be integrated into the type system of an object-oriented language that already uses the subsumption rule to allow implicit upcasts with respect to subtyping. The main idea is that consistency and subtyping are orthogonal ideas that compose nicely. To add subtyping to a gradually-typed language, simply add the subsumption rule and add a subtyping rule that makes the dynamic type a subtype of itself, because subtyping is supposed to be reflexive. (But do not make the top of the subtyping order dynamic!)
Comparison With Optional Types
Gradual and optional typing are similar in that variables and expressions may be given types and the correctness of the typing is checked at compile time (which is static typing). However, in a gradual type system, runtime checks are inserted at the boundaries of typed and untyped code. In an optional type system, all types are erased at compile time and untyped values can propagate through code that had type annotations.
<span id="mwQg"></span><span class="linenos" data-line="1" id="mwQw"></span><span class="kd" id="mwRA">class</span><span class="w" id="mwRQ"> </span><span class="nc" id="mwRg">Account</span><span class="w" id="mwRw"> </span><span class="o" id="mwSA">{</span><span class="w" id="mwSQ"> </span> <span class="linenos" data-line="2" id="mwSg"></span><span class="w" id="mwSw"> </span><span class="nl" id="mwTA">credits:</span><span class="kt" id="mwTQ">int</span><span class="w" id="mwTg"> </span><span class="c1" id="mwTw">//number of credits in account, statically typed</span> <span class="linenos" data-line="3" id="mwUA"></span><span class="w" id="mwUQ"> </span><span class="k" id="mwUg">new</span><span class="o" id="mwUw">(</span><span class="nl" id="mwVA">credits:</span><span class="kt" id="mwVQ">int</span><span class="o" id="mwVg">)</span><span class="w" id="mwVw"> </span><span class="o" id="mwWA">{</span> <span class="linenos" data-line="4" id="mwWQ"></span><span class="w" id="mwWg"> </span><span class="k" id="mwWw">this</span><span class="o" id="mwXA">.</span><span class="na" id="mwXQ">credits</span><span class="w" id="mwXg"> </span><span class="o" id="mwXw">=</span><span class="w" id="mwYA"> </span><span class="n" id="mwYQ">credits</span><span class="o" id="mwYg">;</span><span class="w" id="mwYw"> </span> <span class="linenos" data-line="5" id="mwZA"></span><span class="w" id="mwZQ"> </span><span class="o" id="mwZg">}</span> <span class="linenos" data-line="6" id="mwZw"></span><span class="w" id="mwaA"> </span> <span class="linenos" data-line="7" id="mwaQ"></span><span class="w" id="mwag"> </span><span class="n" id="mwaw">compare</span><span class="o" id="mwbA">(</span><span class="nl" id="mwbQ">account:</span><span class="n" id="mwbg">Account</span><span class="o" id="mwbw">){</span> <span class="linenos" data-line="8" id="mwcA"></span><span class="w" id="mwcQ"> </span><span class="c1" id="mwcg">//won't throw error in optionally typed as "1" > 1 is a valid comparison</span> <span class="linenos" data-line="9" id="mwcw"></span><span class="w" id="mwdA"> </span><span class="k" id="mwdQ">return</span><span class="w" id="mwdg"> </span><span class="k" id="mwdw">this</span><span class="o" id="mweA">.</span><span class="na" id="mweQ">credits</span><span class="w" id="mweg"> </span><span class="o" id="mwew">></span><span class="w" id="mwfA"> </span><span class="n" id="mwfQ">account</span><span class="o" id="mwfg">.</span><span class="na" id="mwfw">credits</span><span class="o" id="mwgA">;</span> <span class="linenos" data-line="10" id="mwgQ"></span><span class="w" id="mwgg"> </span><span class="o" id="mwgw">}</span> <span class="linenos" data-line="11" id="mwhA"></span><span class="w" id="mwhQ"> </span> <span class="linenos" data-line="12" id="mwhg"></span><span class="w" id="mwhw"> </span><span class="n" id="mwiA">spendCredit</span><span class="o" id="mwiQ">(){</span> <span class="linenos" data-line="13" id="mwig"></span><span class="w" id="mwiw"> </span><span class="k" id="mwjA">this</span><span class="o" id="mwjQ">.</span><span class="na" id="mwjg">credits</span><span class="w" id="mwjw"> </span><span class="o" id="mwkA">=</span><span class="w" id="mwkQ"> </span><span class="k" id="mwkg">this</span><span class="o" id="mwkw">.</span><span class="na" id="mwlA">credits</span><span class="w" id="mwlQ"> </span><span class="o" id="mwlg">-</span><span class="w" id="mwlw"> </span><span class="mi" id="mwmA">1</span><span class="o" id="mwmQ">;</span><span class="w" id="mwmg"> </span><span class="c1" id="mwmw">//optionally typed throws here</span> <span class="linenos" data-line="14" id="mwnA"></span><span class="w" id="mwnQ"> </span><span class="o" id="mwng">}</span> <span class="linenos" data-line="15" id="mwnw"></span><span class="w" id="mwoA"> </span> <span class="linenos" data-line="16" id="mwoQ"></span><span class="o" id="mwog">}</span> <span class="linenos" data-line="17" id="mwow"></span> <span class="linenos" data-line="18" id="mwpA"></span><span class="c1" id="mwpQ">//assume everything below executes at runtime/after Account has been compiled</span> <span class="linenos" data-line="19" id="mwpg"></span><span class="n" id="mwpw">let</span><span class="w" id="mwqA"> </span><span class="n" id="mwqQ">a</span><span class="w" id="mwqg"> </span><span class="o" id="mwqw">=</span><span class="w" id="mwrA"> </span><span class="k" id="mwrQ">new</span><span class="w" id="mwrg"> </span><span class="n" id="mwrw">Account</span><span class="o" id="mwsA">(</span><span class="mi" id="mwsQ">1</span><span class="o" id="mwsg">);</span><span class="w" id="mwsw"> </span><span class="c1" id="mwtA">//valid in both systems</span> <span class="linenos" data-line="20" id="mwtQ"></span><span class="n" id="mwtg">let</span><span class="w" id="mwtw"> </span><span class="n" id="mwuA">b</span><span class="w" id="mwuQ"> </span><span class="o" id="mwug">=</span><span class="w" id="mwuw"> </span><span class="k" id="mwvA">new</span><span class="w" id="mwvQ"> </span><span class="n" id="mwvg">Account</span><span class="o" id="mwvw">(</span><span class="s2" id="mwwA">"2"</span><span class="o" id="mwwQ">);</span><span class="w" id="mwwg"> </span><span class="c1" id="mwww">//gradually typed throws here, preventing invalid Account instances</span> <span class="linenos" data-line="21" id="mwxA"></span><span class="n" id="mwxQ">b</span><span class="o" id="mwxg">.</span><span class="na" id="mwxw">compare</span><span class="o" id="mwyA">(</span><span class="n" id="mwyQ">a</span><span class="o" id="mwyg">);</span><span class="w" id="mwyw"> </span><span class="c1" id="mwzA">//optionally typed returns false</span> <span class="linenos" data-line="22" id="mwzQ"></span><span class="n" id="mwzg">b</span><span class="o" id="mwzw">.</span><span class="na" id="mw0A">spendCredit</span><span class="o" id="mw0Q">();</span><span class="w" id="mw0g"> </span><span class="c1" id="mw0w">//optionally typed throws here</span>In a gradually typed language, an exception would be raised anytime a non-integer value is supplied for credit and stack traces would stop at invalid calls (new Account("2")). In an optionally typed language, an exception would only be raised when the language is forced to perform operations that would be incompatible with its type: credit can be set to "1" (a string) but this would only throw an error when performing math on it (e.x. when spendCredit attempts to subtract the integer 1). compare functions as normal, illustrating how a program running in production could create and manipulate invalid Accounts without triggering an error. This could result in data corruption if the invalid instances are saved to a datastore.
Getting similar results in an optionally typed language requires a programmer to manually perform type checking by inserting guards:
<span id="mw4A"></span><span class="linenos" data-line="1" id="mw4Q"></span><span class="kd" id="mw4g">class</span><span class="w" id="mw4w"> </span><span class="nc" id="mw5A">Account</span><span class="w" id="mw5Q"> </span><span class="o" id="mw5g">{</span><span class="w" id="mw5w"> </span> <span class="linenos" data-line="2" id="mw6A"></span><span class="w" id="mw6Q"> </span><span class="kd" id="mw6g">private</span><span class="w" id="mw6w"> </span><span class="nl" id="mw7A">credit:</span><span class="kt" id="mw7Q">int</span><span class="w" id="mw7g"> </span><span class="c1" id="mw7w">//private prevents external code setting (invalid) value</span> <span class="linenos" data-line="3" id="mw8A"></span><span class="w" id="mw8Q"> </span><span class="k" id="mw8g">new</span><span class="o" id="mw8w">(</span><span class="nl" id="mw9A">credit:</span><span class="kt" id="mw9Q">int</span><span class="o" id="mw9g">)</span><span class="w" id="mw9w"> </span><span class="o" id="mw-A">{</span> <span class="linenos" data-line="4" id="mw-Q"></span><span class="w" id="mw-g"> </span><span class="k" id="mw-w">this</span><span class="o" id="mw_A">.</span><span class="na" id="mw_Q">setCredit</span><span class="o" id="mw_g">(</span><span class="n" id="mw_w">credit</span><span class="o" id="mwAQA">);</span><span class="w" id="mwAQE"> </span><span class="c1" id="mwAQI">//must flow through guarded setter</span> <span class="linenos" data-line="5" id="mwAQM"></span><span class="w" id="mwAQQ"> </span><span class="o" id="mwAQU">}</span> <span class="linenos" data-line="6" id="mwAQY"></span><span class="w" id="mwAQc"> </span> <span class="linenos" data-line="7" id="mwAQg"></span><span class="w" id="mwAQk"> </span><span class="c1" id="mwAQo">//setter to ensure only values of the correct type are assigned</span> <span class="linenos" data-line="8" id="mwAQs"></span><span class="w" id="mwAQw"> </span><span class="n" id="mwAQ0">setCredit</span><span class="o" id="mwAQ4">(</span><span class="nl" id="mwAQ8">credit:</span><span class="kt" id="mwARA">int</span><span class="o" id="mwARE">){</span><span class="w" id="mwARI"> </span> <span class="linenos" data-line="9" id="mwARM"></span><span class="w" id="mwARQ"> </span><span class="k" id="mwARU">if</span><span class="o" id="mwARY">(</span><span class="n" id="mwARc">isInt</span><span class="o" id="mwARg">(</span><span class="n" id="mwARk">credit</span><span class="o" id="mwARo">)){</span><span class="w" id="mwARs"> </span><span class="c1" id="mwARw">//manual type check to guard against data corruption</span> <span class="linenos" data-line="10" id="mwAR0"></span><span class="w" id="mwAR4"> </span><span class="k" id="mwAR8">this</span><span class="o" id="mwASA">.</span><span class="na" id="mwASE">credit</span><span class="w" id="mwASI"> </span><span class="o" id="mwASM">=</span><span class="w" id="mwASQ"> </span><span class="n" id="mwASU">credit</span><span class="o" id="mwASY">;</span><span class="w" id="mwASc"> </span> <span class="linenos" data-line="11" id="mwASg"></span><span class="w" id="mwASk"> </span><span class="o" id="mwASo">}</span><span class="w" id="mwASs"> </span><span class="k" id="mwASw">else</span><span class="w" id="mwAS0"> </span><span class="o" id="mwAS4">{</span> <span class="linenos" data-line="12" id="mwAS8"></span><span class="w" id="mwATA"> </span><span class="k" id="mwATE">throw</span><span class="w" id="mwATI"> </span><span class="n" id="mwATM">TypeError</span><span class="o" id="mwATQ">;</span> <span class="linenos" data-line="13" id="mwATU"></span><span class="w" id="mwATY"> </span><span class="o" id="mwATc">}</span> <span class="linenos" data-line="14" id="mwATg"></span><span class="w" id="mwATk"> </span><span class="o" id="mwATo">}</span> <span class="linenos" data-line="15" id="mwATs"></span><span class="w" id="mwATw"> </span> <span class="linenos" data-line="16" id="mwAT0"></span><span class="w" id="mwAT4"> </span><span class="n" id="mwAT8">compare</span><span class="o" id="mwAUA">(</span><span class="nl" id="mwAUE">account:</span><span class="n" id="mwAUI">Account</span><span class="o" id="mwAUM">){</span><span class="w" id="mwAUQ"> </span><span class="c1" id="mwAUU">//types are stripped at compile time</span> <span class="linenos" data-line="17" id="mwAUY"></span><span class="w" id="mwAUc"> </span><span class="k" id="mwAUg">if</span><span class="o" id="mwAUk">(</span><span class="n" id="mwAUo">instanceOf</span><span class="o" id="mwAUs">(</span><span class="n" id="mwAUw">account</span><span class="o" id="mwAU0">,</span><span class="w" id="mwAU4"> </span><span class="n" id="mwAU8">Account</span><span class="o" id="mwAVA">)){</span><span class="w" id="mwAVE"> </span><span class="c1" id="mwAVI">//manual type checks everywhere!</span> <span class="linenos" data-line="18" id="mwAVM"></span><span class="w" id="mwAVQ"> </span><span class="k" id="mwAVU">return</span><span class="w" id="mwAVY"> </span><span class="k" id="mwAVc">this</span><span class="o" id="mwAVg">.</span><span class="na" id="mwAVk">credit</span><span class="w" id="mwAVo"> </span><span class="o" id="mwAVs">></span><span class="w" id="mwAVw"> </span><span class="n" id="mwAV0">account</span><span class="o" id="mwAV4">.</span><span class="na" id="mwAV8">credit</span><span class="o" id="mwAWA">;</span> <span class="linenos" data-line="19" id="mwAWE"></span><span class="w" id="mwAWI"> </span><span class="o" id="mwAWM">}</span><span class="w" id="mwAWQ"> </span><span class="k" id="mwAWU">else</span><span class="w" id="mwAWY"> </span><span class="o" id="mwAWc">{</span> <span class="linenos" data-line="20" id="mwAWg"></span><span class="w" id="mwAWk"> </span><span class="k" id="mwAWo">throw</span><span class="w" id="mwAWs"> </span><span class="n" id="mwAWw">TypeError</span><span class="o" id="mwAW0">;</span> <span class="linenos" data-line="21" id="mwAW4"></span><span class="w" id="mwAW8"> </span><span class="o" id="mwAXA">}</span> <span class="linenos" data-line="22" id="mwAXE"></span><span class="w" id="mwAXI"> </span><span class="o" id="mwAXM">}</span> <span class="linenos" data-line="23" id="mwAXQ"></span><span class="w" id="mwAXU"> </span> <span class="linenos" data-line="24" id="mwAXY"></span><span class="w" id="mwAXc"> </span><span class="c1" id="mwAXg">//since the private `credits` field can only be accessed within the class,</span> <span class="linenos" data-line="25" id="mwAXk"></span><span class="w" id="mwAXo"> </span><span class="c1" id="mwAXs">//methods can rely on compile time type checking.</span> <span class="linenos" data-line="26" id="mwAXw"></span><span class="w" id="mwAX0"> </span><span class="n" id="mwAX4">spendCredit</span><span class="o" id="mwAX8">(){</span> <span class="linenos" data-line="27" id="mwAYA"></span><span class="w" id="mwAYE"> </span><span class="k" id="mwAYI">this</span><span class="o" id="mwAYM">.</span><span class="na" id="mwAYQ">credits</span><span class="w" id="mwAYU"> </span><span class="o" id="mwAYY">=</span><span class="w" id="mwAYc"> </span><span class="k" id="mwAYg">this</span><span class="o" id="mwAYk">.</span><span class="na" id="mwAYo">credits</span><span class="w" id="mwAYs"> </span><span class="o" id="mwAYw">-</span><span class="w" id="mwAY0"> </span><span class="mi" id="mwAY4">1</span><span class="o" id="mwAY8">;</span><span class="w" id="mwAZA"> </span><span class="c1" id="mwAZE">//no need for `isInt(this.credits)`</span> <span class="linenos" data-line="28" id="mwAZI"></span><span class="w" id="mwAZM"> </span><span class="o" id="mwAZQ">}</span> <span class="linenos" data-line="29" id="mwAZU"></span><span class="w" id="mwAZY"> </span> <span class="linenos" data-line="30" id="mwAZc"></span><span class="o" id="mwAZg">}</span> <span class="linenos" data-line="31" id="mwAZk"></span> <span class="linenos" data-line="32" id="mwAZo"></span><span class="c1" id="mwAZs">//assume everything below executes at runtime/after Account has been compiled</span> <span class="linenos" data-line="33" id="mwAZw"></span><span class="n" id="mwAZ0">let</span><span class="w" id="mwAZ4"> </span><span class="n" id="mwAZ8">a</span><span class="w" id="mwAaA"> </span><span class="o" id="mwAaE">=</span><span class="w" id="mwAaI"> </span><span class="k" id="mwAaM">new</span><span class="w" id="mwAaQ"> </span><span class="n" id="mwAaU">Account</span><span class="o" id="mwAaY">(</span><span class="mi" id="mwAac">1</span><span class="o" id="mwAag">);</span><span class="w" id="mwAak"> </span><span class="c1" id="mwAao">//valid</span> <span class="linenos" data-line="34" id="mwAas"></span><span class="n" id="mwAaw">let</span><span class="w" id="mwAa0"> </span><span class="n" id="mwAa4">b</span><span class="w" id="mwAa8"> </span><span class="o" id="mwAbA">=</span><span class="w" id="mwAbE"> </span><span class="k" id="mwAbI">new</span><span class="w" id="mwAbM"> </span><span class="n" id="mwAbQ">Account</span><span class="o" id="mwAbU">(</span><span class="s2" id="mwAbY">"2"</span><span class="o" id="mwAbc">);</span><span class="w" id="mwAbg"> </span><span class="c1" id="mwAbk">//stacktrace wouldn't stop here, but inside `setCredit`</span>Note however, that stack traces won't trace to the offending call but the setter. If the programmer forgets to pass externally provided values through the setter, it's still possible that an invalid instance could be created and saved to disk but discovered during a later execution. This makes data corruption harder to prevent and impedes tracking down offending code paths.
Implementations
Examples of gradually typed languages derived from existing dynamically typed languages include Closure Compiler, Hack (for PHP), PHP (since 7.0), Typed Racket (for Racket), Typed Clojure (for Clojure), or cperl (a typed Perl 5). ActionScript was a gradually typed language that interoperated with ECMAScript, though it originally arose separately as a sibling, both influenced by Apple's HyperTalk.
A system for the J programming language has been developed, adding coercion, error propagation and filtering to the normal validation properties of the type system as well as applying type functions outside of function definitions, thereby the increasing flexibility of type definitions.
Conversely, C# started as a statically typed language, but as of version 4.0 is gradually typed, allowing variables to be explicitly marked as dynamic by using the dynamic type.
Raku (formerly Perl6) has had gradual typing implemented from the start. Type checks occur at all locations where values are assigned or bound. An "untyped" variable or parameter is typed as Any, which will match (almost) all values. The compiler flags type-checking conflicts at compile time if it can determine at compile time that they will never succeed.
Objective-C has gradual typing for object pointers with respect to method calls. Static typing is used when a variable is typed as pointer to a certain class of object: when a method call is made to the variable, the compiler statically checks that the class is declared to support such a method, or it generates a warning or error. However, if a variable of the type id is used, the compiler will allow any method to be called on it.
The JS++ programming language, released in 2011, is a superset of JavaScript (dynamically typed) with a gradual type system that is sound for ECMAScript and DOM API corner cases.
GDScript, the Godot game engine's primary scripting language, started out dynamically typed and introduced gradual typing with version 3.1 of the engine, allowing users to type variables, function parameters, arrays and dictionaries through type hints. Additionally, when assigning a value to a variable using the := notation, Godot will attempt to infer the type of the variable at build time.