[Haskell-cafe] Re: Theory about uncurried functions
lrpalmer at gmail.com
Wed Mar 4 17:55:02 EST 2009
On Wed, Mar 4, 2009 at 3:38 PM, Achim Schneider <barsoap at web.de> wrote:
> There's not much to understand about CT, anyway: It's actually nearly
> as trivial as set theory.
You mean that theory which predicts the existence of infinitely many
infinities; in fact for any cardinal, there are at least that many
cardinals? That theory in which aleph_1 and 2^aleph_0 are definitely
comparable, but we provably cannot compare them? The theory which has
omega_0 < omega_1 < omega_2 < ... omega_omega < ..., where obviously omega_a
is much larger than a... except for when it catches its tail and omega_alpha
= alpha for some crazy-ass alpha.
I don't think set theory is trivial in the least. I think it is
complicated, convoluted, often anti-intuitive and nonconstructive.
Category theory is much more trivial, and that's what makes it powerful.
(Although training yourself to think categorically is quite difficult, I'm
> One part of the benefit starts when you begin
> to categorise different kind of categories, in the same way that
> understanding monads is easiest if you just consider their difference
> to applicative functors. It's a system inviting you to tackle a problem
> with scrutiny, neither tempting you to generalise way beyond
> computability, nor burdening you with formal proof requirements or
> shackling you to some other ball and chain.
> Sadly, almost all texts about CT are absolutely useless: They
> tend to focus either on pure mathematical abstraction, lacking
> applicability, or tell you the story for a particular application of CT
> to a specific topic, loosing themselves in detail without providing the
> bigger picture. That's why I liked that Rosetta stone paper so much: I
> still don't understand anything more about physics, but I see how
> working inside a category with specific features and limitations is the
> exact right thing to do for those guys, and why you wouldn't want to do
> a PL that works in the same category.
> Throwing lambda calculus at a problem that doesn't happen to be a DSL
> or some other language of some sort is a bad idea. I seem to understand
> that for some time now, being especially fond of automata to model
> autonomous, interacting agents, but CT made me grok it. The future will
> show how far it will pull my thinking out of the Turing tarpit.
>  Which aren't, at all, objects. Finite automata don't go bottom in
> any case, at least not if you don't happen to shoot them and their
> health drops below zero.
> (c) this sig last receiving data processing entity. Inspect headers
> for copyright history. All rights reserved. Copying, hiring, renting,
> performance and/or quoting of this signature prohibited.
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Haskell-Cafe