Type parameters as constraints

[Anders Hejlsberg (ahejlsberg)]

With this PR it becomes possible for a type parameter constraint to reference type parameters from the same type parameter list (this was previously an error). For example:

functionassign<TextendsU,U>(target: T,source: U): T{for(letidinsource){target[id]=source[id];}returntarget;}letx={a: 1,b: 2,c: 3,d: 4};assign(x,{b: 10,d: 20});assign(x,{e: 0});// Error

A fancy term for this capability is F-Bounded Polymorphism.

Fixes#2304.

[Daniel Rosenwasser (DanielRosenwasser)]

Invert the condition to reduce nesting.

[Anders Hejlsberg (ahejlsberg)]

Not sure what you mean. There's a shared return statement at the bottom of the function and no else clause that would be reversed.

[Daniel Rosenwasser (DanielRosenwasser)]

I meant to just repeat the return statement, but it's not really a big deal.

[Anders Hejlsberg (ahejlsberg)]

Mohamed Hegazy (@mhegazy) Want to comment on this one before I merge it?

[Mohamed Hegazy (mhegazy)]

👍

[Daniel Rosenwasser (DanielRosenwasser)]

Anders Hejlsberg (@ahejlsberg) I tried this out and upon grabbing quick info on a, I'm seeing an uninstantiated type:

interfaceMapper<T>{map<UextendsT,VextendsU[]>(f: (item: T)=>U): V;}varm: Mapper<string>;vara=m.map((x: string)=>x);

I expected a to have the type string[], so something isn't working out here.

[Anders Hejlsberg (ahejlsberg)]

Daniel Rosenwasser (@DanielRosenwasser) Good catch. The problem is that the constraints aren't getting properly instantiated. Will put up a fix shortly.

[Daniel Rosenwasser (DanielRosenwasser)]

Hey Anders Hejlsberg (@ahejlsberg), Aleksey-Bykov wrote a useful example on #6037 which demonstrates the use of type parameters being able to extend each other. Can we add the following as a test case?

functionfold<a,r>(values: a[],result: r,fold: (result: r,value: a)=>r): r{for(letvalueofvalues){result=fold(result,value);}returnresult;}functionappend<a,bextendsa>(values: a[],value: b): a[]{values.push(value);returnvalues;}fold([1,2,3],[]as[string,string][],(result,value)=>append(result,["",""]));

[ZpdDG4gta (zpdDG4gta8XKpMCd)]

by the way

// test.tsexportfunctionappend<a,bextendsa>(result: a[],value: b): a[]{result.push(value);returnresult;}

compiles with

node ./built/local/tsc.js --module commonjs test.ts 

but fails with

node ./built/local/tsc.js --module commonjs --declaration test.ts 

saying

test.ts(1,37): error TS4016: Type parameter 'b' of exported function has or is using private name 'a'.

[ZpdDG4gta (zpdDG4gta8XKpMCd)]

created a separate bug: #6040

[Daniel Rosenwasser (DanielRosenwasser)]

I noticed the same thing on my bug where the type parameter was not being instantiated. Can you enable // @declaration: true for all these test cases?

[Anders Hejlsberg (ahejlsberg)]

Latest commits fix the uninstantiated type issue as well as issue in #6040.

[Basarat Ali Syed (basarat)]

Awesome 🌹. I've done aweful things in the past : https://github.com/TypeScriptBuilder/tsb/blob/24c5bbaa3e29587ab0830194c374cd7fa8bb2462/src/app/state/simpleRedux.ts#L90-L103 :)

[Daniel Rosenwasser (DanielRosenwasser)]

Anders Hejlsberg (@ahejlsberg) I think it wouldn't be unreasonable to just get declaration emit for all of these tests.

[ZpdDG4gta (zpdDG4gta8XKpMCd)]

Basarat Ali Syed (@basarat), a poorman's implementation of this feature could have been done by passing
a function that maps B to A thus enforcing the constraint, consider:

foo <a, b extends a>(foo: a, bar:b): void;

vs

foo <a, b>(foo: a, bar: b, bIsA: (val: b) => a): void;

[Claudia Meadows (dead-claudia)]

Question: does this patch support the following? I've come across this pattern way too frequently, and I've needed it for way too many things. In languages that support it, it's a very frequent idiom.

interfaceType<TextendsType<T>>{}

[Anders Hejlsberg (ahejlsberg)]

@isiahmeadows Yes, that pattern (the "curiously recurring template pattern") is now supported. But also note that the polymorphic 'this' type is a more succinct way to accomplish the same thing.

[Claudia Meadows (dead-claudia)]

I also came across an unusual use case where I needed two F-bounded type
parameters, which the this type doesn't cover. Given this supports that
as well, I'm happy.

On Thu, Dec 17, 2015, 09:31 Anders Hejlsberg notifications@github.com
wrote:

@isiahmeadows https://github.com/isiahmeadows Yes, that pattern (the
"curiously recurring template pattern") is now supported. But also note
that the polymorphic 'this' type
#4910 is a more succinct
way to accomplish the same thing.

—
Reply to this email directly or view it on GitHub
#5949 (comment)
.