Haskell and ML certainly have advantages over Java and C#. But it's important to
realise firstly that they have disadvantages too, and secondly that the imperative/OO
languages are evolving fast. When the mainstream was only C/C++, the most important
advantage of functional languages was garbage collection. Once Java and C# became
popular, polymorphism became the "unique selling proposition". But now both Java and
C# have generics and anonymous functions. For example, in C# 2.0 the most obvious
translation of map is just
static IEnumerable<T2> map<T1,T2>(IEnumerable<T1> arg, Converter<T1,T2> f) {
foreach (T1 x in arg)
yield return f (x);
}
this is type-safe, takes any type of collection as input and returns a
lazily-evaluated collection of results.
Or we could have
static S2 map<T1, T2, S1, S2>(S1 arg, Converter<T1, T2> f)
where S1:IEnumerable<T1>
where S2:ICollection<T2>,new()
{
S2 result = new S2();
foreach (T1 x in arg)
result.Add(f(x));
return result;
}
Which is parameterized over both the element types *and* both the collection types.
You can use it like this:
int[] myints = { 1, 2, 3 };
List<string> mystrings =
map<int,string,int[],List<string>>(
myints,
delegate (int i) {return (i+1).ToString();});
where I've mapped over an array, producing a list and passing in an anonymous
function.
You can download the free beta of Visual C# Express and compile that code today,
within a powerful IDE. Plus C# lets you do all sorts of real-world things (graphics,
networking, database access, web page generation,...) considerably more conveniently
that most existing implementations of functional languages.
Agreed, the syntax of these examples is a bit heavy (though Java has more inference
for type parameters than C#), but if we want to argue the genuine advantages of
functional programming, especially in an industrial context, "map" just isn't enough
any more.
One possible position is simply to declare victory - generics and anonymous functions
wouldn't be in Java and C# if it weren't for functional programmers. Another is to
move the discussion to a higher level and start to talk about reasoning principles,
rather than comparing lines of code. This is where the real advantages come, but it's
a pretty subtle argument to put to a PHB, I fear.
Nick
-----Original Message-----
From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED] On Behalf Of Vincenzo aka Nick Name
Sent: 15 September 2004 00:25
To: [EMAIL PROTECTED]
Subject: Re: [Haskell] Haskell in industry?
On Tuesday 14 September 2004 18:18, [EMAIL PROTECTED]
wrote:
> *�������Can't much of the simplicity of the Haskell code also be
> reached by just switching from C++ to something like Java or C#?
> (Probably an example from the application domain will be most
> convincing. So I probably have to bite the bullet and reimplement
> some code in Java or C#. But if you have some examples, they might be
> helpful.
I don't have examples but I've been working with C# 8 hours per day for
6 months and I ensure you that no, they are not simple. C++ is simpler
for enterprise uses than C#, IMHO, because you fundamentally reuse
other people libraries and so worry _less_ about memory management than
you'd expect, but YMMV. On the other hand, C# has NO parametric
polymorphism and after a while I've begun to miss C++ templates. C# has
functional programming, they say, but no you can't use a method name as
a function. You first have to create an "event". Composing this with
the absence of parametric polymorphism and type inference, here's what
a _monomorphic_ "map" function looks like, with a possibly naive syntax
because I don't have the compiler handy (and worked 8 hours today,too).
/////
public delegate int myDelegate(int i); //This is a type declaration
public ArrayList map(myDelegate fn,ArrayList list);
// Note that the list is untyped, but the function is strongly typed.
{
ArrayList result = new ArrayList();
foreach (Object obj in list)
{
result.Add(fn(obj));
}
return result;
}
/////
6 rows of effective code, untyped, contrived and poorly reusable.
And this is the way you call it (you already know, ok, but now I am
having fun :))
public int increment(int i)
{
return i+1;
}
map(new myDelegate(increment),myList); // note the call to "new"
The map function from the haskell prelude:
map f xs = [f x | x <- xs]
and how you call it:
map (\ x -> x+1) myList
It's strongly typed, polymorphic and reusable. And it's far more
readable and clear in intent, too.
Do I need to say more? If you have the possibility to use haskell, ocaml
or SML at work, do so :)
OK, I realize that you already knew haskell, but you asked first :)
Vincenzo
_______________________________________________
Haskell mailing list
[EMAIL PROTECTED]
http://www.haskell.org/mailman/listinfo/haskell
_______________________________________________
Haskell mailing list
[EMAIL PROTECTED]
http://www.haskell.org/mailman/listinfo/haskell
