What do you LISPers think of Haskell?

On Aug 20, 1:43*pm, namekuseijin <namekusei...@gmail.com> wrote:
> On Aug 20, 2:55*am, Scott Burson <FSet....@gmail.com> wrote:
>
> > You could try Liskell:http://liskell.org/
>
> > I haven't tried it, but it looks interesting.
>
> Whoa! *Looks mighty fine to me!
>
> http://liskell.org/fifteen-minute-tour
>
> The syntax and semantics look like a nice mix of Scheme and Haskell.
> I the ease of defining ADTs:
>
> (defdata Point3DType
> * (Point3D Rational Rational Rational))
>
> and pattern matching on function definition without destructuring-bind
> or other verbose macro workaround:
> (define (distance3D (Point3D x y z))
> * (sqrt (+ (^ x 2)
> * * * * * *(+ (^ y 2) (^ z 2)))))
>
> or function definitions in let with the same syntax sugar as in define
> (no lambda):
> (define (scalar-multiply s point)
> * (let (((Point3D x y z) point)
> * * * * ((p x) (* s x)))
> * * (Point3D (p x) (p y) (p z))))
>
> Perhaps it also comes full with lazy semantics? *A project to watch
> closely.

You mean CLAZY? (Shameless plug: common-lisp.net/project/clazy). Not
that the hack is particularly clever, but it shows you how you can do
these things *in* portable Common Lisp.

Cheers
--
Marco

On 19 Ago, 19:31, ssecorp <circularf...@gmail.com> wrote:
(> LISP Haskell) ; much

(11) YOU SHALL NOT NAME TWO DIFFERENT PROGRAMMING LANGUAGES IN THE
SUBJECT OF C.L.L POSTINGS

On Tue, 19 Aug 2008 10:31:27 -0700, ssecorp wrote:

> What are you LISPers opinion of Haskell?
>
> Pros and cons compared to LISP?

I tried Haskell before CL. Most of the programming I do is the
application/implementation of numerical methods for solving economic
models.

Even though I recognize the `elegance' of certain Haskell constructs, the
language was a straitjacket for me because of two things: the type system
and the functional purity.

The type system required a lot of scaffolding (Either, Maybe, ...) when I
wanted to do something non-trivial. Indeed, Haskell makes the
construction of this scaffolding really easy, but in CL, I just find that
I don't have to do it and I can spend time writing more relevant code
instead.

Also, sometimes I had difficulty rewriting my algorithms in purely
functional ways. I agree that it can always be done, but I had to spend
a lot of time fighting Haskell.

What attracted me to Haskell initially was the elegance found in toy
examples (eg the Fibonacci series). It took me a lot of time to realize
that toy examples are, well, toy examples, and whether a language handles
them well is not relevant to problems of a larger scale. For example,
pattern matching looked fascinating, until I realized that I am not using
it that often.

Also, when I tried Haskell I didn't know about macros, which give Lisp a
lot of extra power. Now of course I would not ever use a language
without CL-like macros.

Note that I am not claiming that CL is `better', just that it suits me
better. Haskell is a fine language, and I don't intend to disparage it.
You will have to make up your own mind. I would suggest that you try
both: even if you end up using only one of them, working in the other one
for at least a month will broaden your horizons.

Best,

Tamas

On Aug 20, 3:47*pm, "xah...@gmail.com" <xah...@gmail.com> wrote:
> On Aug 20, 10:43 am, namekuseijin <namekusei...@gmail.com> wrote:
> > Who knows, perhaps it attracts even more interest than Haskell or Lisp
> > alone... now Arc has some tough competition! :P
>
> Arc is one of the despicable worthless shit there is.

Good that my little sarcasm prompted such inspired response from
you.

On Aug 20, 4:35*pm, Tamas K Papp <tkp...@gmail.com> wrote:
> I tried Haskell before CL. *Most of the programming I do is the
> application/implementation of numerical methods for solving economic
> models.

> Even though I recognize the `elegance' of certain Haskell constructs, the
> language was a straitjacket for me because of two things: the type system
> and the functional purity.

That's weird. Functional languages abstractions and syntax should go
hand-to-hand with numerical problems such as those you describe.

> The type system required a lot of scaffolding (Either, Maybe, ...) when I
> wanted to do something non-trivial.

You mean IO?

> Also, sometimes I had difficulty rewriting my algorithms in purely
> functional ways. *I agree that it can always be done, but I had to spend
> a lot of time fighting Haskell.

That doesn't make any sense: you don't fight Haskell when writing in
purely functional ways, only when allowing mutation and side-effects
in. And since you're mostly dealing with numerical computations and
algorithms, I believe IO would be very limited to just a few sections,
like reading lots of data from external sources and generating output.

>*For example,
> pattern matching looked fascinating, until I realized that I am not using
> it that often.

Perhaps because you're programming in Haskell as if it was Lisp?

On Wed, 20 Aug 2008 13:36:12 -0700, namekuseijin wrote:

> On Aug 20, 4:35Â*pm, Tamas K Papp <tkp...@gmail.com> wrote:
>> I tried Haskell before CL. Â*Most of the programming I do is the
>> application/implementation of numerical methods for solving economic
>> models.
>
>> Even though I recognize the `elegance' of certain Haskell constructs,
>> the language was a straitjacket for me because of two things: the type
>> system and the functional purity.
>
> That's weird. Functional languages abstractions and syntax should go
> hand-to-hand with numerical problems such as those you describe.

Sometimes they do, sometimes they don't. You can always write the
problem in purely functional ways, but sometimes that required quite a
bit of effort. For example, something like using a simple hash table
(which is still "provisional") requires IO. Things like that were a pain.

>> The type system required a lot of scaffolding (Either, Maybe, ...) when
>> I wanted to do something non-trivial.
>
> You mean IO?

Nope, I mean handling cases when a non-numerical result needs to be
returned or handled. Think of using nil to indicate a missing number in
Lisp: in Haskell you would need a Maybe. Or think of a function that
could take a real number or a list, for that I had to use Either. Things
like this got tiresome after a while. But this was not why I stopped
using the language.

>> Also, sometimes I had difficulty rewriting my algorithms in purely
>> functional ways. Â*I agree that it can always be done, but I had to
>> spend a lot of time fighting Haskell.
>
> That doesn't make any sense: you don't fight Haskell when writing in
> purely functional ways, only when allowing mutation and side-effects in.
> And since you're mostly dealing with numerical computations and
> algorithms, I believe IO would be very limited to just a few sections,
> like reading lots of data from external sources and generating output.

Your beliefs do not coincide with my experience. If you have already
specified the algorithm that you are trying to implement, perhaps you can
figure out the uber-functional way to do it in the first try. But in my
line of work, you experiment with different algorithms and because you
don't know which one of them will work a priori. I find Lisp ideal for
that kind of tinkering, whereas in Haskell, I found this hard.

>>Â*For example,
>> pattern matching looked fascinating, until I realized that I am not
>> using it that often.
>
> Perhaps because you're programming in Haskell as if it was Lisp?

If you reread my post, you will find that I started Haskell before CL.

Anyhow, please don't feel that you need to defend Haskell from me. I
emphasized that I consider Haskell a fine language, just not suitable for
my purposes. I gave Haskell an try, I used it for about 6 weeks. Of
course you can always claim that if I had used it for 6 years, I would be
more experienced and would see how to do things the Haskell way, but
honestly, I don't care. I was more productive in Lisp after a week than
in Haskell after 6 weeks.

Best,

Tamas

On Aug 20, 7:55*am, Scott Burson <FSet....@gmail.com> wrote:
> On Aug 19, 10:11 pm, Ralph Allan Rice <ralph.r...@gmail.com> wrote:
>
> > On Aug 19, 1:31 pm, ssecorp <circularf...@gmail.com> wrote:
>
> > > What are you LISPers opinion of Haskell?
>
> > I recently did some Haskell (and Erlang) hacking, too. Although I like
> > both languages and they both have their niches, the biggest feature
> > that takes me back to Common Lisp every time is macros. Whenever I use
> > another language (does not matter what it is), deep down I wish the
> > language had macros like Common Lisp.
>
> You could try Liskell:http://liskell.org/
>
> I haven't tried it, but it looks interesting.
>
> -- Scott

I just checked out the sight but it doesn't look like much has been
done there recently. Does anyone know any more about this.

Robert

Tamas K Papp wrote:
> On Wed, 20 Aug 2008 13:36:12 -0700, namekuseijin wrote:
>> Perhaps because you're programming in Haskell as if it was Lisp?
>
> If you reread my post, you will find that I started Haskell before CL.

Sounds like you were not familiar with modern static typing though.

--
Dr Jon D Harrop, Flying Frog Consultancy
http://www.ffconsultancy.com/products/?u

xahlee@gmail.com wrote:
> Arc is one of the despicable worthless shit there is.
>
> Arc is the type of shit that when some person becomes famous for his
> achivement in some area, who began to sell all sort of shit and
> visions just because he can, and people will buy it.
That might be true, but I'd love it if you expounded on why you believe
that? I don't have a lot of lisp experience, so I need someone to
highlight facts about why Arc is bad comparatively.

Thanks.

--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>

Daniel Pitts wrote:
> xahlee@gmail.com wrote:
>
>> Arc is one of the despicable worthless shit there is.
>>
>> Arc is the type of shit that when some person becomes famous for his
>> achivement in some area, who began to sell all sort of shit and
>> visions just because he can, and people will buy it.
>
> That might be true, but I'd love it if you expounded on why you believe
> that? I don't have a lot of lisp experience, so I need someone to
> highlight facts about why Arc is bad comparatively.

PG bet the ranch on terser code at all costs, including all sorts of
whacky syntax that is so whacky bits of it conflict and cannot be used
in combination. It was starting to look like Python when I left town.

And of course the single namespace is a disaster. Oh, and the absence of
an OO package.

kt