Survey Results

Marshall Rosenstein wrote:

I always though it was better to return a single typed object with queryable properties. That way, if you need more return information, you modify the object, rather than the method signature. It, by definition, makes your code more object-oriented.

var foo(string arg1, int arg2, float[] arg3)
{
	return new {tmp=arg1+"test", md=arg2 % 42, len=arg3.Length, first=arg3[0]};
}

public object foo( string arg1, int arg2, float[] arg3 )
{
    return new { tmp=arg1+"test", md=arg2 % 42, len=arg3.Length, first=arg3[0] };
}

public var MyDynamicClass foo( string arg1, int arg2, float[] arg3 )
{
    return new var{ tmp=arg1+"test", md=arg2 % 42, len=arg3.Length, first=arg3[0] };
}

public var foo( string arg1, int arg2, float[] arg3 ) 
        { 
            return new var("MyDynamicClassName"){ tmp=arg1+"test", md=arg2 % 42, len=arg3.Length, first=arg3[0] }; 
        }

Balboos wrote:

variable arg list

Marshall Rosenstein wrote:

The problem is that if you were to externally link to a library containing such a function, there's no easy way to determine the properties available from "var" at compile time - Intellisense would certainly fail.

new { tmp=arg1+"test", md=arg2 % 42, len=arg3.Length, first=arg3[0] }; <big>
</big>

Marshall Rosenstein wrote:

Strangely, this compiles fine:

public object foo( string arg1, int arg2, float[] arg3 )
{
return new { tmp=arg1+"test", md=arg2 % 42, len=arg3.Length, first=arg3[0] };
}

1. The var or object can't be cast to its original type by the caller.
2. You can only access the data in the var using reflection.
3. Since the return Type of foo() isn't named in the meta-data (this can be verified using reflection), the Intellisense parser would have to both parse and interpret the IL of the third party library function to determine the actual return Type. In some cases, it is not possible to determine the return Type at compile time. For example, if the function logic contained a switch statement where what is returned is conditioned in some way by the runtime values of the input parameters:
   

   //Return Type cannot be determined at compile time
   public var foo()( int myRuntimeVal )
   {
      switch( myRuntimeVal ){
         case 1: return new{ Value=1 }; //Anonymous Type 1
         default: return new{ Name="Hello", Value="World" }; //Anonymous Type 2
      }
   }

4. Once the IL analysis successfully determined the Type, it would have to use reflection to determine the available properties of the Type.

Marshall Rosenstein wrote:

I haven't heard of the Connect website -- is it something I should explore?

Marshall Rosenstein wrote:

I don't think they'll ever add var as a return function value, and here's why.

The Type of var is known at compile time since it is the compiler that auto-generates the Type. However, the accessibility of the Type is always internal sealed. Also, if you look at the IL for foo(), there is no boxing that occurs, since anonymous types are not value types.

Since public var foo() is public, it would require that the return Type of foo() to be public as well. This is especially important when the method you are calling is in an external library. Otherwise you introduce the following problems:

Marshall Rosenstein wrote:

Since the return Type of foo() isn't named in the meta-data (this can be verified using reflection), the Intellisense parser would have to both parse and interpret the IL of the third party library function to determine the actual return Type. In some cases, it is not possible to determine the return Type at compile time. For example, if the function logic contained a switch statement where what is returned is conditioned in some way by the runtime values of the input parameters:


//Return Type cannot be determined at compile time
public var foo()( int myRuntimeVal )
{
switch( myRuntimeVal ){
case 1: return new{ Value=1 }; //Anonymous Type 1
default: return new{ Name="Hello", Value="World" }; //Anonymous Type 2
}
}

public CType1 foo(int myRuntimeVal)
{
    switch(myRuntimeVal){
        case 1: return new CType1(1);
        default: return new CType2("Hello", "World");
    }
}

(define (mv) (values 1 2))
(call-with-values mv +) => 3

Xiangyang Liu wrote:

it will return { True, False, NotSure, WhateverAnswerYouWant }

Xiangyang Liu wrote:

IsUserLoggedOn which returns True or False

Nibu babu thomas wrote:

good IDE too to support such a language

Vasudevan Deepak K wrote:

What do you say?

Nibu babu thomas wrote:

advanced development comes in we need to have an IDE.

Paul Watson wrote:

Could you explain more please? I know some pretty serious developer who use nothing but vi and the command-line.

Paul Watson wrote:

Fair enough but I think "need to have an IDE" is too strong a phrase. Nobody needs an IDE. It is a helpful tool at times but no project and no programmer should be dependent on one.

Nibu babu thomas wrote:

I personally also like that all required files be open in one parent window and I can move between these windows easily. Also some pretty nifty features like last opened files, projects, macros

Nibu babu thomas wrote:

I personally would also like to have a good IDE too to support such a language.

Paul Watson wrote:

It is a useful tool to have around but it is good to be able to code, compile, deploy, debug etc. without one.