Parametric polymorphism and async

paulyoung · January 12, 2022, 2:01pm

This was mentioned here:

dfinity/motoko/blob/a7cd4fba954b2fa7aeadc5680e2dc5d25e38cb69/design/WhitePaper.md#shared-generics-2096

# Motoko Evolution White Paper (Draft)

(Note: The status of this document still is very rough. It has more the character of a brain dump. Provided as is.)


## Background

### Introduction

*Motoko* is a general-purpose programming language designed to provide a seamless and modern programming experience on the Internet Computer (IC). To that end, it has built-in support for various features specific to the IC, such as:

* Representation of canisters as *actors* with asynchronous and atomic methods.
* Automatic integration with *Candid* for implicitly de/serialising message arguments and automatic derivation of Candid interfaces.
* *Async/await* support for straight-line coding of asynchronous messaging patterns.
* *Orthogonal peristence* keeping program state alive across messages automatically.
* *Stable variables* for persisting selected program state even across program version upgrades.
* Built-in support for other IC mechanisms, such as cycles, upgrades, heartbeat, etc (some of it still incomplete).

Motoko was initially designed and implemented as a relatively minimal language. This was both to keep it simple and to get off the ground more quickly. Consequently, there is a range of features it still lacks. Some are mere implementation gaps relative to the "complete" semantics provided by the interpreter, some are additional features that were anticipated from the beginning but consciously deferred, some have been discovered as new requirements over time.

This file has been truncated. show original

and previously here:

github.com/dfinity/motoko

Shared generics

opened 11:29AM - 05 Nov 20 UTC

rossberg

compiler language design typing P2

### Motivation Currently, polymorphism is fully parametric and erased in Moto…ko. Consequently, values of variable type cannot be used in any of the operations that requires intensional polymorphism: - message sends - async (may be unnecessary) - serialisation & deserialisation - structural comparison - structural hashing - polymorphic printing It is neither possible to provide such operations as generic library functions, nor can user code abstract over types that involve such operations. Instead, any relevant operation and abstraction can only be made accessible by adding new primitive syntax in the language. That clearly is an abstraction failure. ### Proposal This proposal extends the language with _shared type variables_. On the surface, the proposal is simple: * Allow the annotation `shared` on type bindings: ``` func foo<shared T>(x : T) : Bool { x == x }; ``` * Type variables thus declared are of _shared kind_ (a subkind of all types), and qualify as shared types. * They can only be instantiated by shared types. ### Implementation The gross of this proposal is under the surface. The compiler lowers shared generics by introducing implicit runtime type arguments to respective functions. For example, the above is lowered to ``` func foo<T>(_T : Rtt<T>, x : T) : Bool { prim_equal<T>(_T, x, x); } ``` where `Rtt<T>` is a runtime representation of the type `T`. This representation is passed to all intensional operators. The lowering also inserts the respective arguments at call sites. In some cases, that involves constructing witness RTT values dynamically, for example: ``` func bar<shared T>(x : T) : Bool { foo<[T]>([x]); } ``` This lowers to ``` func bar<T>(_T : Rtt<T>, x : T) : Bool { foo<[T]>(_rtt_array(_T), [x]); } ``` where `_rtt_array` is an internal intro form or function to construct the RTT for an array. These techniques are of course well-known from other evidence-passing translations.

Topic		Replies	Views
Motoko Sharable Generics Language Support	16	2314	January 10, 2024
Motoko async generics solution Motoko	1	54	September 11, 2024
Shared Generics Developers	2	560	October 31, 2022
Shared types, generics, and async* Language Support Motoko	3	464	May 22, 2023
Type of query function Language Support Motoko	2	449	August 3, 2021

Parametric polymorphism and async

Related topics