[Swift-devel] Polymorphic type notation in Swift/T

[Tim Armstrong]

This is only currently supported for external Tcl functions, btw, not
regular Swift composite functions.

It's possible to do what you suggest - assume that any unknown types in the
type signature are type variables.  It would be pretty straightforward to
implement too.  The downside is that can lead to surprising behaviour from
the user's perspective.

For example, suppose I declare a function with this type:

  f(Int x)

Int isn't the name of a type (the real integer type is int), so it would be
inferred to be a type variable, and then you have a function that looks
like it accepts ints, but actually accepts any input argument.

There are other scenarios too - e.g. if a type is defined in an imported
module but you forget to import the module, suddenly you have a type
variable where you thought you had a regular type.

I guess the way to think about it is that you're asking the programmer to
add a little redundant information about their intent that then allows the
compiler to check that their code is doing what they intended.

- Tim

On 14 March 2015 at 18:51, Pete Vilter <vilterp at uchicago.edu> wrote:

> Hi Tim,
> This would be very nice to have in Swift/K — is there a proposal to add
> it? The syntax is similar to Java static methods; should be familiar to
> people coming from that background. One question (which applies to Java as
> well): why is it necessary to declare the type variables at the beginning
> of the line? Can't the compiler just see what variables are being used in
> the return and argument types?
> Thanks,
> —Pete
>
> On Fri, Mar 13, 2015 at 2:44 PM Tim Armstrong <tim.g.armstrong at gmail.com>
> wrote:
>
>> Here's how I define contains in Swift/T:
>>
>> <K, V> (boolean o) contains(V A[K], K key)
>>
>> K and V declares that K and V are type variables in the scope of the
>> function definition.  I.e. when typechecking call to the function, K and V
>> can be any type, so long as they match in all places.
>>
>> The algorithm for typechecking is to match up input types to the argument
>> types and bind the type variables, e.g. matching a string[int] array to
>> V[K] would bind V=string and K=int, and matching int to K  would bind
>> K=int.  If there isn't a consistent way to bind K and V, e.g. if one of the
>> K's was a string, then typechecking fails.
>>
>>
>> For split, the function type would look like:
>>
>> <T, K> T[int][K] split(T[K], int n)
>>
>> - Tim
>> _______________________________________________
>> Swift-devel mailing list
>> Swift-devel at ci.uchicago.edu
>> https://lists.ci.uchicago.edu/cgi-bin/mailman/listinfo/swift-devel
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.mcs.anl.gov/pipermail/swift-devel/attachments/20150315/bce31225/attachment.html>