There are 4 possible conversion methods in TypeScript for arrays:

    let x = []; //any[]
    
    let y1 = x as number[];
    let z1 = x as Array&lt;number&gt;;
    let y2 = &lt;number[]&gt;x;
    let z2 = &lt;Array&lt;number&gt;&gt;x;

The `as` operator&#39;s mostly designed for `*.tsx` files to avoid the syntax ambiguity.

I think the right syntax is:

    var rows2 = &lt;Array&lt;any&gt;&gt;rows;

That&#39;s how you cast to `interface Array&lt;T&gt;`



I think this is just a bug - can you log an issue on the CodePlex site?

As a workaround, you can write `&lt;Array&gt;&lt;any&gt;rows`;

A simple solution for all types

    const myArray = &lt;MyType[]&gt;value;

In my JavaScript (.js) files, I use a Visual Studio 2012 plugin for regions [(here)][1] like this:

    //#region &quot;My Region&quot;
    
    //Code here
    
    //#endregion &quot;My Region&quot;


I would also like to have regions in TypeScript (.ts) files as well. Is this a possibility right now? 

  [1]: http://visualstudiogallery.msdn.microsoft.com/4be701d8-af03-40a4-8cdc-d2add5cde46c

Regions in TypeScript

How can I force `git merge` to use the default merge message instead of loading my editor with said message?

I have no editor listed in `git config -l`, so I&#39;m not sure why it opens an editor.

Git merge doesn&#39;t use default merge message, opens editor with default message

I&#39;m trying to use a wrapper for a library that wants an Array as an input parameter.

I tried casting the Array, but I get an error: Cannot convert &#39;any[]&#39; to &#39;Array&#39;

Is there a way to make this work?


    var rows = new Array(10);
    var rows2 = &lt;Array&gt;rows; //&lt;--- Cannot convert &#39;any[]&#39; to &#39;Array&#39;

TypeScript casting arrays

I'm trying to use a wrapper for a library that wants an Array as an input parameter.
I tried casting the Array, but I get an error: Cannot convert 'any[]' to 'Array'
Is there a way to make this work?
<pre><code class="hljs language-ini">var rows = new Array(10);
var rows2 = &#x3C;Array>rows; //&#x3C;--- Cannot convert 'any[]' to 'Array'
</code></pre>

How do I avoid implicit casting on non-constructing functions?  
I have a function that takes an integer as a parameter,  
but that function will also take characters, bools, and longs.  
I believe it does this by implicitly casting them.  
How can I avoid this so that the function only accepts parameters of a matching type, and will refuse to compile otherwise?  
There is a keyword &quot;explicit&quot; but it does not work on non-constructing functions. :\  
what do I do?

The following program compiles, although I&#39;d like it not to:

    #include &lt;cstdlib&gt;
    
    //the function signature requires an int
    void function(int i);
    
    int main(){
    
    	int i{5};
    	function(i); //&lt;- this is acceptable
    
    	char c{&#39;a&#39;};
    	function(c); //&lt;- I would NOT like this to compile
    
    	return EXIT_SUCCESS;
    }
    
    void function(int i){return;}

*please be sure to point out any misuse of terminology and assumptions 

How do I avoid implicit conversions on non-constructing functions?

I want to define a function that takes an `unsigned int` as argument and returns an `int` congruent modulo UINT_MAX+1 to the argument.

A first attempt might look like this:

    int unsigned_to_signed(unsigned n)
    {
        return static_cast&lt;int&gt;(n);
    }

But as any language lawyer knows, casting from unsigned to signed for values larger than INT_MAX is implementation-defined.

I want to implement this such that (a) it only relies on behavior mandated by the spec; and (b) it compiles into a no-op on any modern machine and optimizing compiler.

As for bizarre machines...  If there is no signed int congruent modulo UINT_MAX+1 to the unsigned int, let&#39;s say I want to throw an exception.  If there is more than one (I am not sure this is possible), let&#39;s say I want the largest one.

OK, second attempt:

    int unsigned_to_signed(unsigned n)
    {
        int int_n = static_cast&lt;int&gt;(n);

        if (n == static_cast&lt;unsigned&gt;(int_n))
            return int_n;

        // else do something long and complicated
    }

I do not much care about the efficiency when I am not on a typical twos-complement system, since in my humble opinion that is unlikely.  And if my code becomes a bottleneck on the omnipresent sign-magnitude systems of 2050, well, I bet someone can figure that out and optimize it then.

Now, this second attempt is pretty close to what I want.  Although the cast to `int` is implementation-defined for some inputs, the cast back to `unsigned` is guaranteed by the standard to preserve the value modulo UINT_MAX+1.  So the conditional does check exactly what I want, and it will compile into nothing on any system I am likely to encounter.

However...  I am still casting to `int` without first checking whether it will invoke implementation-defined behavior.  On some hypothetical system in 2050 it could do who-knows-what.  So let&#39;s say I want to avoid that.

Question:  What should my &quot;third attempt&quot; look like?

To recap, I want to:

 - Cast from unsigned int to signed int
 - Preserve the value mod UINT_MAX+1
 - Invoke only standard-mandated behavior
 - Compile into a no-op on a typical twos-complement machine with optimizing compiler

[Update]

Let me give an example to show why this is not a trivial question.

Consider a hypothetical C++ implementation with the following properties:

 - `sizeof(int)` equals 4
 - `sizeof(unsigned)` equals 4
 - `INT_MAX` equals 32767
 - `INT_MIN` equals -2&lt;sup&gt;32&lt;/sup&gt; + 32768
 - `UINT_MAX` equals 2&lt;sup&gt;32&lt;/sup&gt; - 1
 -  Arithmetic on `int` is modulo 2&lt;sup&gt;32&lt;/sup&gt; (into the range `INT_MIN` through `INT_MAX`)
 - `std::numeric_limits&lt;int&gt;::is_modulo` is true
 - Casting unsigned `n` to int preserves the value for 0 &lt;= n &lt;= 32767 and yields _zero_ otherwise

On this hypothetical implementation, there is exactly one `int` value congruent (mod UINT_MAX+1) to each `unsigned` value.  So my question would be well-defined.

I claim that this hypothetical C++ implementation fully conforms to the C++98, C++03, and C++11 specifications.  I admit I have not memorized every word of all of them...  But I believe I have read the relevant sections carefully.  So if you want me to accept your answer, you either must (a) cite a spec that rules out this hypothetical implementation or (b) handle it correctly.

Indeed, a correct answer must handle _every_ hypothetical implementation permitted by the standard. That is what &quot;invoke only standard-mandated behavior&quot; means, by definition.

Incidentally, note that `std::numeric_limits&lt;int&gt;::is_modulo` is utterly useless here for multiple reasons.  For one thing, it can be `true` even if unsigned-to-signed casts do not work for large unsigned values.  For another, it can be `true` even on one&#39;s-complement or sign-magnitude systems, if arithmetic is simply modulo the entire integer range.  And so on.  If your answer depends on `is_modulo`, it&#39;s wrong.

[Update 2]

[hvd&#39;s answer][1] taught me something:  My hypothetical C++ implementation for integers is _not_ permitted by modern C.  The C99 and C11 standards are very specific about the representation of signed integers; indeed, they only permit twos-complement, ones-complement, and sign-magnitude (section 6.2.6.2 paragraph (2); ).

But C++ is not C.  As it turns out, this fact lies at the very heart of my question.

The original C++98 standard was based on the much older C89, which says (section 3.1.2.5):

&gt; For each of the signed integer types, there is a corresponding (but
&gt; different) unsigned integer type (designated with the keyword
&gt; unsigned)  that uses the same amount of storage (including sign
&gt; information) and has the same alignment requirements.  The range of
&gt; nonnegative values of a signed integer type is a subrange of the
&gt; corresponding unsigned integer type, and the representation of the
&gt; same value in each type is the same.

C89 says nothing about only having one sign bit or only allowing twos-complement/ones-complement/sign-magnitude.

The C++98 standard adopted this language nearly verbatim (section 3.9.1 paragraph (3)):

&gt; For each of the signed integer types, there exists a corresponding
&gt; (but different) *unsigned integer type*: &quot;`unsigned char`&quot;, &quot;`unsigned
&gt; short int`&quot;, &quot;`unsigned int`&quot;, and &quot;`unsigned long int`&quot;, each of
&gt; which occupies the same amount of storage and has the same alignment
&gt; requirements (3.9) as the corresponding signed integer type ; that
&gt; is, each *signed integer* type has the same object representation as
&gt; its corresponding *unsigned integer* type. The range of nonnegative
&gt; values of a signed integer type is a subrange of the corresponding
&gt; unsigned integer type, and the value representation of each
&gt; corresponding signed/unsigned type shall be the same.

The C++03 standard uses essentially identical language, as does C++11.

No standard C++ spec constrains its signed integer representations to any C spec, as far as I can tell.  And there is nothing mandating a single sign bit or anything of the kind.  All it says is that _non-negative_ signed integers must be a subrange of the corresponding unsigned.

So, again I claim that INT_MAX=32767 with INT_MIN=-2&lt;sup&gt;32&lt;/sup&gt;+32768 is permitted.  If your answer assumes otherwise, it is incorrect unless you cite a **C++** standard proving me wrong.

  [1]: https://stackoverflow.com/a/13208789/768469

Efficient unsigned-to-signed cast avoiding implementation-defined behavior

I have a small table and a certain field contains the type &quot;**character varying**&quot;. I&#39;m trying to change it to &quot;**Integer**&quot; but it gives an error that casting is not possible.

Is there a way around this or should I just create another table and bring the records into it using a query.

The field contains only integer values.

Change type of varchar field to integer: &quot;cannot be cast automatically to type integer&quot;

How does one handle type casting in TypeScript or Javascript?  

Say I have the following TypeScript code:

    module Symbology { 
    
        export class SymbolFactory { 
    
            createStyle( symbolInfo : SymbolInfo) : any { 
                if (symbolInfo == null)
                {
                     return null;
                }
    
                if (symbolInfo.symbolShapeType === &quot;marker&quot;) {      
                    
                    // how to cast to MarkerSymbolInfo          
                    return this.createMarkerStyle((MarkerSymbolInfo) symbolInfo);
                }                                  
            }
    
            createMarkerStyle(markerSymbol : MarkerSymbolInfo ): any { 
                throw &quot;createMarkerStyle not implemented&quot;;
            }              
           
        }
    }

where `SymbolInfo` is a base class.  How do I handle typecasting from `SymbolInfo` to `MarkerSymbolInfo` in TypeScript or Javascript?

TypeScript or JavaScript type casting

I would like to import the following csv as strings not as int64. Pandas read_csv automatically converts it to int64, but I need this column as string.

    ID
    00013007854817840016671868
    00013007854817840016749251
    00013007854817840016754630
    00013007854817840016781876
    00013007854817840017028824
    00013007854817840017963235
    00013007854817840018860166


    df = read_csv(&#39;sample.csv&#39;)

    df.ID
    &gt;&gt;

    0   -9223372036854775808
    1   -9223372036854775808
    2   -9223372036854775808
    3   -9223372036854775808
    4   -9223372036854775808
    5   -9223372036854775808
    6   -9223372036854775808
    Name: ID


Unfortunately using converters gives the same result. 

    df = read_csv(&#39;sample.csv&#39;, converters={&#39;ID&#39;: str})
    df.ID
    &gt;&gt;

    0   -9223372036854775808
    1   -9223372036854775808
    2   -9223372036854775808
    3   -9223372036854775808
    4   -9223372036854775808
    5   -9223372036854775808
    6   -9223372036854775808
    Name: ID




Import pandas dataframe column as string not int

I&#39;m trying to convert a pet project to TypeScript and don&#39;t seem to be able to use the `tsc` utility to watch and compile my files. The help says I should use the `-w` switch, but it looks like it can&#39;t watch and compile all `*.ts` files in the some directory recursively. This seems like something `tsc` should be able to handle. What are my options?

How to watch and compile all TypeScript sources?

I&#39;m trying to pass a class as a parameter to some function, that will instantiate this class and return it. Here is my code:


    module A.Views {
      export class View { ... }
    }
    
    module A.App {
      export class MyApp {
        ...
        registerView(viewKlass:A.Views.View):void
        {
            var test = new viewKlass;
        } 
      }
    }

When i&#39;m trying to compile this, i&#39;m getting:

    (...): Value of type &#39;Views.View&#39; is not newable.

What am I doing wrong?

If a newable type value is an object constructor how do i pass the constructor function at runtime?

Passing class as parameter causes &quot;is not newable&quot; error

How to add a method to a base type, say Array? In the global module this will be recognized

    interface Array {
       remove(o): Array;
    }

but where to put the actual implementation?



Extending Array in TypeScript

I have such case:

    interface MoverShaker {
        getStatus(): { speed: number; frequency: number; };
    }

    function GetMoverShaker() : MoverShaker {
        return {
            getStatus: () =&gt; { speed: 2, frequency: 3 }
        }
    }

I am getting such error: The name &#39;frequency&#39; does not exist in the current scope. Is such construction possible in TypeScript? If I am using such construction then everything is ok:

    function GetMoverShaker(): MoverShaker {
        return {
            getStatus: () =&gt; {
                 return { speed: 2, frequency: 3 }
            }
    }



Content Type	Original Author	Original Content on Stackoverflow
Question	Adam Tegen	View Question on Stackoverflow
Solution 1 - Casting	shadeglare	View Answer on Stackoverflow
Solution 2 - Casting	Tsvetomir Nikolov	View Answer on Stackoverflow
Solution 3 - Casting	Ryan Cavanaugh	View Answer on Stackoverflow
Solution 4 - Casting	Jayant Varshney	View Answer on Stackoverflow

TypeScript casting arrays

Casting Problem Overview

Casting Solutions

Solution 1 - Casting

Solution 2 - Casting

Solution 3 - Casting

Solution 4 - Casting

Git merge doesn't use default merge message, opens editor with default message

Regions in TypeScript

Attributions