typescript Wiki Rss Feed

New Comment on "Known breaking changes between 0.8 and 0.9"

dlshryock — Mon, 20 May 2013 14:52:34 GMT

@mihailik Thanks, I'm actually aware that you can use lambdas like that, my hope was to get the ability to use functions like that as well. Lambdas stored in a var cause a few problems in my opinion: they don't work for inheritance, they're mutable so they can be changed, they can have order of initialization problems, and they don't contain any sort of name property to identify them, which is bad for call stacks, and metaprogramming. I really like the use of short functions that return their results immediately. For me, limiting yourself to a single computational result for a function is a great way to increase the modularity, and composability of your functions. It gets even better when you can partially apply functions to set up context, and then invoke them later with the rest of the arguments. I've been using this technique along with the fact that you can extract the name of named functions as a type safe mapping layer between my client and server side code, as well as for handling routing page rendering in the client side. Without the named arrow functions, my code will unfortunately get much longer and more cumbersome. I'm sure that these things are probably much more of a concern to me than they are to other people, but I figured I'd mention them anyways :D

New Comment on "Known breaking changes between 0.8 and 0.9"

mihailik — Sat, 18 May 2013 08:50:40 GMT

Almost precisely that lambda is what's supported today: var addOne = (n: number) => n+1; var x: (a,b) => (c,d) => a+b+c+d class A{ private _name:string; greeting: () => "Hello, "+name; }

New Comment on "Known breaking changes between 0.8 and 0.9"

dlshryock — Fri, 17 May 2013 21:27:19 GMT

Is there any possibility of returning the ability to write functions like lambdas? for example, it was to be possible to write the following prior to the 0.9 alpha: function addOne(n:number) => n+1; It probably doesn't seem very important for simple cases like the above, but it is extremely useful if you are doing function currying / partial application: function x(a,b) => (c,d) => a+b+c+d; would have to become: function x(a,b){return function(c,d){ return a+b+c+d;} } a fully curried function: function x(a) => (b) => (c) => (d) => a+b+c+d; would have to be: function(a){return function(b){return function(c){return function(d){ return a+b+c+d; } } } } It gets worse and worse the more you want to break argument lists apart. And yes, I am using the arrow functions in real life production application, and would prefer them to be real named functions, not lambda variables :D I would even like to go so far as to ask for their support as methods: class A{ private _name:string; greeting() => "Hello, "+name; }

Updated Wiki: Known breaking changes between 0.8 and 0.9

jonturner — Tue, 14 May 2013 18:50:39 GMT

Known breaking changes between 0.8 and 0.9

The 0.9.x series introduces breaking changes to help the language mature, align with the ECMAScript 5 standard and ECMAScript 6 draft recommendations, and general alignment of the compiler with the spec itself. While we try to limit the number of breaking changes, it’s important to make necessary changes now, before the language and tools reach 1.0.

Below is the list of currently known breaking changes.

Tightening of compiler to spec

Description: There was functionality allowed by the 0.8.3 compiler that was not explicitly allowed by the spec (eg, exploiting patterns of access modifiers to simulate ‘protected’).
Reason: We tightened the compiler to follow the spec more closely to avoid code that relies on a “loose” compiler implementation.

The type ‘bool’ is now ‘boolean’

Description: The name of the Boolean type was initially ‘bool’. During 0.9.0, ‘bool’ will be marked as deprecated, preferring instead the name ‘boolean’. As of 0.9.1, ‘bool’ will no longer be accepted.
Reason: The official name for the Boolean type in ECMAScript is ‘boolean’. The ‘bool’ type name is being changed to align with the standard, based on user feedback.

The ‘module’ keyword no longer creates a type

Description: In 0.9.0, a clearer distinction is made between roles of namespaces, types, and values. Modules now contribute only to namespaces and values and will no longer contribute a type.
Reason: This simplification of the role of modules allow modules to now extend classes and functions more easily.

Introduction of generic types – Change to ‘Array’ type

Description: In 0.9.0, with the introduction of generics, the type of Array is now generic.
Reason: The Array type was less specialized before. Now, with the advent of generics, we can allow for a more precise typing of Array contents.

Introduction of generic types – Change to syntax parsing

Description: In 0.9.0, with the introduction of generics, a difference in how syntax is parsed was introduced. This may affect some forms of syntax that previously parsed as acceptable ES5. Specifically, the following example will no longer be parsed as a comma-delimited expression of two comparisons, but instead as an invocation of a generic function with two arguments:

myfun<x,y>(z)

To make this unambiguously an expression, use parentheses. For example:

(myfun < x), y > (z)

Reason: We follow the precedence set by other languages with regards to syntax for generics. Unfortunately, this does lead to ambiguities in a few cases.

Overload declarations must immediately precede implementation

Description: The 0.8.x series was more lax about what was allowed between overload declaration and its implementation
Reason: Tightening compiler to align with grammar

Indexers must have full type annotation now

Description:

interface a1 {
    [n: number];  //<-- was allowed in 0.8.x, now an error
}
interface a1 {
    [n: number]: string;  //<-- correctly specifies return type, valid in 0.8.x and 0.9.x
}

Reason: Tightening compiler to align with grammar

Statics must be fully-qualified

Description: Previously you could optionally not qualify a static member access when inside a static member definition
Reason: Just as classes require “this.”, statics will require “<Class name>.” to denote where the symbol comes from

No longer accept semicolon at the end of methods

Description:

class Todo extends Backbone.Model {
 
    // Default attributes for the todo.
    defaults() {
        return {
            content: "empty todo...",
            done: false
        }
    };
}

Reason: This may be from following the syntax more strictly in the 0.9.0 fidelity parser. We may soften this restriction in the future.

No longer accept "new number[]"

Description: In the 0.8.x series, we allowed some exceptions to the rule that an expression should follow 'new'. Here we allowed the type "number[]" to follow new.
Reason: This was accidentally allowed in the 0.8.x compiler. As part of the 0.9.x work, we're tightening the compiler, and in doing so no longer allow this.

'declare' now required for top level non-interface declarations in .d.ts files

Description: The 0.8.x series had a lot of lenience in the .d.ts file syntax. We want to tighten the syntax.
Reason: Loose syntax rules are confusing to users and lead to inconsistent .d.ts files.

The node.d.ts distributed with 0.8 is not compatible with 0.9

Description: The 'node.d.ts' distributed as part of 0.8 samples is no longer compatible. Use the up-to-date node.d.ts distributed with the 0.9 samples.
Reason: This is an effect of the "modules no longer create a type" simplification

String indexers constrain the types of members on the interface

Description: A string indexer with element type Foo is a constraint that all members of the interface will have types compatible with Foo. The only exception is that members implicitly inherited from Object which can be called on any object type continue to have the type provided in Object unless explicitly overridden. So this:

    export interface IEventListenerMap {
        hasOwnProperty(eventName: string): bool;
        [eventName: string]: IEventCallback[];
    }

Can be changed to this without changes to consumers of the interface (that is, they can keep using .hasOwnProperty).

    export interface IEventListenerMap {
        [eventName: string]: IEventCallback[];
    }

Reason: String indexers are unified with property lookup in 0.9, so that foo.bar and foo["bar"] behave the same.

New Comment on "Roadmap"

TobiasHei — Thu, 09 May 2013 11:26:16 GMT

I would also love to see a timeline, by quater is fine to me. Thanks for this great language :)

New Comment on "Roadmap"

elhajjh — Wed, 08 May 2013 12:34:15 GMT

I can't see why there is no answer for a question that is asked many may times. as here about timeline for roadmap versions. Please provide some dates.

New Comment on "Roadmap"

elhajjh — Wed, 08 May 2013 12:33:22 GMT

I can't see why there is no answer for a question that is asked many may times. as here about timeline for roadmap versions.

New Comment on "Known breaking changes between 0.8 and 0.9"

NN — Fri, 03 May 2013 17:59:20 GMT

https://typescript.codeplex.com/releases/view/105503 Here you have installer and specification

New Comment on "Known breaking changes between 0.8 and 0.9"

NN — Fri, 03 May 2013 17:56:49 GMT

marcocenz , the spec is in the repository: https://typescript.codeplex.com/SourceControl/BrowseLatest Just choose "develop" branch.

New Comment on "Known breaking changes between 0.8 and 0.9"

marcocenz — Wed, 01 May 2013 09:03:52 GMT

There is an updated version of the Language specifications? The only one I've found is of October 2012 for Language version 0.8.0 :-(

New Comment on "Known breaking changes between 0.8 and 0.9"

omidkrad — Mon, 29 Apr 2013 20:12:36 GMT

I love these improvements. Specially tightening the .d.ts definitions, it was becoming confusing.

New Comment on "Compile-on-Save"

middlewest — Wed, 24 Apr 2013 20:14:58 GMT

this feature doesn't work in 0.9 anymore

New Comment on "Known breaking changes between 0.8 and 0.9"

jonturner — Tue, 23 Apr 2013 18:14:43 GMT

Thanks, oisin. Fixed.

Updated Wiki: Known breaking changes between 0.8 and 0.9

jonturner — Tue, 23 Apr 2013 18:14:29 GMT

Known breaking changes between 0.8 and 0.9

Tightening of compiler to spec

The type ‘bool’ is now ‘boolean’

The ‘module’ keyword no longer creates a type

Introduction of generic types – Change to ‘Array’ type

Introduction of generic types – Change to syntax parsing

myfun<x,y>(z)

To make this unambiguously an expression, use parentheses. For example:

(myfun < x), y > (z)

Reason: We follow the precedence set by other languages with regards to syntax for generics. Unfortunately, this does lead to ambiguities in a few cases.

Overload declarations must immediately precede implementation

Description: The 0.8.x series was more lax about what was allowed between overload declaration and its implementation
Reason: Tightening compiler to align with grammar

Indexers must have full type annotation now

Description:

interface a1 {
    [n: number];  //<-- was allowed in 0.8.x, now an error
}
interface a1 {
    [n: number]: string;  //<-- correctly specifies return type, valid in 0.8.x and 0.9.x
}

Reason: Tightening compiler to align with grammar

Statics must be fully-qualified

No longer accept semicolon at the end of methods

Description:

class Todo extends Backbone.Model {
 
    // Default attributes for the todo.
    defaults() {
        return {
            content: "empty todo...",
            done: false
        }
    };
}

Reason: This may be from following the syntax more strictly in the 0.9.0 fidelity parser. We may soften this restriction in the future.

No longer accept "new number[]"

'declare' now required for top level non-interface declarations in .d.ts files

String indexers constrain the types of members on the interface

    export interface IEventListenerMap {
        hasOwnProperty(eventName: string): bool;
        [eventName: string]: IEventCallback[];
    }

Can be changed to this without changes to consumers of the interface (that is, they can keep using .hasOwnProperty).

    export interface IEventListenerMap {
        [eventName: string]: IEventCallback[];
    }

Reason: String indexers are unified with property lookup in 0.9, so that foo.bar and foo["bar"] behave the same.

New Comment on "Known breaking changes between 0.8 and 0.9"

oisin — Tue, 23 Apr 2013 14:11:13 GMT

You accidentally linked to a new page with your indexer example. It should be: foo.bar and foo[ "bar" ]

New Comment on "Roadmap"

davidhanson90 — Tue, 23 Apr 2013 13:02:23 GMT

Can you check "macros" into 1.x as that would drive alot of innovation from the community. :-)

Updated Wiki: Known breaking changes between 0.8 and 0.9

danquirk — Mon, 22 Apr 2013 21:35:34 GMT

Known breaking changes between 0.8 and 0.9

Tightening of compiler to spec

The type ‘bool’ is now ‘boolean’

The ‘module’ keyword no longer creates a type

Introduction of generic types – Change to ‘Array’ type

Introduction of generic types – Change to syntax parsing

myfun<x,y>(z)

To make this unambiguously an expression, use parentheses. For example:

(myfun < x), y > (z)

Reason: We follow the precedence set by other languages with regards to syntax for generics. Unfortunately, this does lead to ambiguities in a few cases.

Overload declarations must immediately precede implementation

Description: The 0.8.x series was more lax about what was allowed between overload declaration and its implementation
Reason: Tightening compiler to align with grammar

Indexers must have full type annotation now

Description:

interface a1 {
    [n: number];  //<-- was allowed in 0.8.x, now an error
}
interface a1 {
    [n: number]: string;  //<-- correctly specifies return type, valid in 0.8.x and 0.9.x
}

Reason: Tightening compiler to align with grammar

Statics must be fully-qualified

No longer accept semicolon at the end of methods

Description:

class Todo extends Backbone.Model {
 
    // Default attributes for the todo.
    defaults() {
        return {
            content: "empty todo...",
            done: false
        }
    };
}

Reason: This may be from following the syntax more strictly in the 0.9.0 fidelity parser. We may soften this restriction in the future.

No longer accept "new number[]"

'declare' now required for top level non-interface declarations in .d.ts files

String indexers constrain the types of members on the interface

    export interface IEventListenerMap {
        hasOwnProperty(eventName: string): bool;
        [eventName: string]: IEventCallback[];
    }

Can be changed to this without changes to consumers of the interface (that is, they can keep using .hasOwnProperty).

    export interface IEventListenerMap {
        [eventName: string]: IEventCallback[];
    }

Reason: String indexers are unified with property lookup in 0.9, so that foo.bar and foo"bar" behave the same.

Updated Wiki: Known breaking changes between 0.8 and 0.9

jonturner — Mon, 22 Apr 2013 16:14:55 GMT

Known breaking changes between 0.8 and 0.9

Tightening of compiler to spec

The type ‘bool’ is now ‘boolean’

The ‘module’ keyword no longer creates a type

Introduction of generic types – Change to ‘Array’ type

Introduction of generic types – Change to syntax parsing

myfun<x,y>(z)

To make this unambiguously an expression, use parentheses. For example:

(myfun < x), y > (z)

Reason: We follow the precedence set by other languages with regards to syntax for generics. Unfortunately, this does lead to ambiguities in a few cases.

Overload declarations must immediately precede implementation

Description: The 0.8.x series was more lax about what was allowed between overload declaration and its implementation
Reason: Tightening compiler to align with grammar

Indexers must have full type annotation now

Description:

interface a1 {
    [n: number];  //<-- was allowed in 0.8.x, now an error
}
interface a1 {
    [n: number]: string;  //<-- correctly specifies return type, valid in 0.8.x and 0.9.x
}

Reason: Tightening compiler to align with grammar

Statics must be fully-qualified

Description: Previous you could optionally not qualify a static member access when inside a static member definition
Reason: Just as classes require “this.”, statics will require “<Class name>.” to denote where the symbol comes from

No longer accept semicolon at the end of methods

Description:

class Todo extends Backbone.Model {
 
    // Default attributes for the todo.
    defaults() {
        return {
            content: "empty todo...",
            done: false
        }
    };
}

Reason: This may be from following the syntax more strictly in the 0.9.0 fidelity parser. We may soften this restriction in the future.

No longer accept "new number[]"

'declare' now required for top level non-interface declarations in .d.ts files

String indexers constrain the types of members on the interface

    export interface IEventListenerMap {
        hasOwnProperty(eventName: string): bool;
        [eventName: string]: IEventCallback[];
    }

Can be changed to this without changes to consumers of the interface (that is, they can keep using .hasOwnProperty).

    export interface IEventListenerMap {
        [eventName: string]: IEventCallback[];
    }

Reason: String indexers are unified with property lookup in 0.9, so that foo.bar and foo"bar" behave the same.

Updated Wiki: Known breaking changes between 0.8 and 0.9

jonturner — Mon, 22 Apr 2013 16:14:24 GMT

Known breaking changes between 0.8 and 0.9

Tightening of compiler to spec

The type ‘bool’ is now ‘boolean’

The ‘module’ keyword no longer creates a type

Introduction of generic types – Change to ‘Array’ type

Introduction of generic types – Change to syntax parsing

myfun<x,y>(z)

To make this unambiguously an expression, use parentheses. For example:

(myfun < x), y > (z)

Reason: We follow the precedence set by other languages with regards to syntax for generics. Unfortunately, this does lead to ambiguities in a few cases.

Overload declarations must immediately precede implementation

Description: The 0.8.x series was more lax about what was allowed between overload declaration and its implementation
Reason: Tightening compiler to align with grammar

Indexers must have full type annotation now

Description:

interface a1 {
    [n: number];  //<-- was allowed in 0.8.x, now an error
}
interface a1 {
    [n: number]: string;  //<-- correctly specifies return type, valid in 0.8.x and 0.9.x
}

Reason: Tightening compiler to align with grammar

Statics must be fully-qualified

No longer accept semicolon at the end of methods

Description:

class Todo extends Backbone.Model {
 
    // Default attributes for the todo.
    defaults() {
        return {
            content: "empty todo...",
            done: false
        }
    };
}

Reason: This may be from following the syntax more strictly in the 0.9.0 fidelity parser. We may soften this restriction in the future.

No longer accept "new number[]"

'declare' now required for top level non-interface declarations in .d.ts files

String indexers constrain the types of members on the interface

    export interface IEventListenerMap {
        hasOwnProperty(eventName: string): bool;
        [eventName: string]: IEventCallback[];
    }

Can be changed to this without changes to consumers of the interface (that is, they can keep using .hasOwnProperty).

    export interface IEventListenerMap {
        [eventName: string]: IEventCallback[];
    }

Reason: String indexers are unified with property lookup in 0.9, so that foo.bar and foo"bar" behave the same.

Updated Wiki: Known breaking changes between 0.8 and 0.9

jonturner — Mon, 22 Apr 2013 15:05:52 GMT

Known breaking changes between 0.8 and 0.9

Tightening of compiler to spec

The type ‘bool’ is now ‘boolean’

The ‘module’ keyword no longer creates a type

Introduction of generic types – Change to ‘Array’ type

Introduction of generic types – Change to syntax parsing

myfun<x,y>(z)

To make this unambiguously an expression, use parentheses. For example:

(myfun < x), y > (z)

Reason: We follow the precedence set by other languages with regards to syntax for generics. Unfortunately, this does lead to ambiguities in a few cases.

Overload declarations must immediately precede implementation

Description: The 0.8.x series was more lax about what was allowed between overload declaration and its implementation
Reason: Tightening compiler to align with grammar

Indexers must have full type annotation now

Description:

interface a1 {
    [n: number];  //<-- was allowed in 0.8.x, now an error
}
interface a1 {
    [n: number]: string;  //<-- correctly specifies return type, valid in 0.8.x and 0.9.x
}

Reason: Tightening compiler to align with grammar

Statics must be fully-qualified

No longer accept semicolon at the end of methods

Description:

class Todo extends Backbone.Model {
 
    // Default attributes for the todo.
    defaults() {
        return {
            content: "empty todo...",
            done: false
        }
    };
}

Reason: This may be from following the syntax more strictly in the 0.9.0 fidelity parser. We may soften this restriction in the future.

No longer accept "new number[]"

'declare' now required for top level non-interface declarations in .d.ts files

String indexers constrain the types of members on the interface

    export interface IEventListenerMap {
        hasOwnProperty(eventName: string): bool;
        [eventName: string]: IEventCallback[];
    }

Can be changed to this without changes to consumers of the interface (that is, they can keep using .hasOwnProperty).

    export interface IEventListenerMap {
        [eventName: string]: IEventCallback[];
    }

Reason: String indexers are unified with property lookup in 0.9, so that foo.bar and foo"bar" behave the same.