6 Months with C#

Re:6 Months with C# by MatthewPhillips on Sunday March 10, 2013 @02:29PM (#5352875)

Your example won't even compile. You're confusing functions with lambda expressions. Lambda expressions look a little like a function but they are something different. Lambda can be compiled into functions at run time and that's often what they're used for, but they can't be implicitly assigned to a var. Doing it you're way would look like this:

    Expression<Func<string>> func = () => "foo";
    func.Compile()();

That's hardly better, and it's still not anonymous! You probably like Lambda Expressions because they make things like LINQ elegant, and indeed they do. But a lambda expression is confusingly similar looking to a func (indeed a mistake you made) but when you try to do something more complicated like this:

    Expression<Func<string>> func = () =>
    {
      string foo = "bar";
      return foo;
    };

That won't compile because a lambda expression can't have a statement body, it can only contain (a single!) expression.

Now the cool thing about lambda expressions is that to the end user they are simple and elegant assuming you know that they are not the same thing as functions, but on the other end of it; consuming a lambda expression you get to see the guts of it and realize what a hack it is on the language. Sure, in the context of a compiled statically typed language it's rather powerful. It's how they are able to compile a lambda expression into a SQL statement, because you can inspect lambda expressions which you can't do to functions.

Now you asked about Java and I'm not going to defend Java or predict what their intentions are, but I'll just say that Java is being much more conservation about sticking to what it is; a statically typed compiled language. C# is attemping to be everything to every body.

[ Parent | on HN ]

Re:6 Months with C# by nkohari on Sunday March 10, 2013 @03:30PM (#5353118)

You're right, I'm a bit rusty, not having written anything large in C# for a couple of years. The compiler can't infer the type, so it would be:

    Func<string> foo = () => "foo";
    func()

I'm well aware of the difference between an anonymous function and an expression in C#. What in your example suggests that you should be using an expression? In practice, you never need to work with expression trees unless you're doing metaprogramming of some kind. They were added to the framework primarily to support metaprogramming and support the DLR.

LINQ (or at least "LINQ to Objects") does not use expression trees. For example, this is the signature of the Select() extension method:

    public static IEnumerable<TResult> Select<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector) { ... }

Note the lack of Expression<Func<>>.

Things like LINQ to SQL and the Entity Framework translate these statements into expression trees, but they do it transparently inside the framework.

My point in bringing up Java is that in order to do something like what we're talking about, you'd have to jump through a whole bunch of hoops. It certainly would be more difficult than in C# -- which is really what matters more than the "purity" of the language.

[ Parent | on HN ]

Re:6 Months with C# by nrkn on Sunday March 10, 2013 @06:40PM (#5353858)

You're wrong. A lambda can have a body. Compiles and executes:

  new Func<string>(() => {
    var foo = "bar";
    return foo;
  })();

[ Parent | on HN ]

Re:6 Months with C# by dennisgorelik on Sunday March 10, 2013 @03:23PM (#5353096)

This compiles:

  Func<string> func = () => "foo";
  string result = func();

[ Parent | on HN ]