[Haskell-beginners] No accumulation of partially applied functions allowed?
jays at panix.com
Wed Jun 27 00:39:11 CEST 2012
On Tue, 26 Jun 2012, Alec Story <avs38 at cornell.edu> wrote:
> Because of Haskell's type system, there are some expressions that you
> simply cannot compile. Most of them you don't *want* to compile because
> they do bad things (like add two strings, for example). Some things are
> legal in Lisp but don't typecheck in Haskell for exactly the reasons that
> Brent pointed out. They might make sense in some contexts, but the
> compiler isn't able to reason about them.
What is a formalized version of
It is not possible in Haskell to define `applyTo`.*
* At least not without crazy type class hackery.
I think the difficulty must arise mainly from the *, meaning I
think, "any type" in the above `applyTo`.*. Would it be
easy/convenient to define `applyTo`.(a, b, c) where a is a "type
variable"? In general can we, for any finite number n, where n > 2,
easily/conveniently define `applyTo`.(a1, a2, ..., an) ?
Ah, I see that the problem is for lists of length 3, so for the
type, if it be such, that I might write as [a, a, a], ah, OK, I
will fire up GHCi and have a look.
> On Tue, Jun 26, 2012 at 5:19 PM, Jay Sulzberger <jays at panix.com> wrote:
>> On Tue, 26 Jun 2012, Brent Yorgey <byorgey at seas.upenn.edu> wrote:
>> On Tue, Jun 26, 2012 at 10:08:49PM +0200, Obscaenvs wrote:
>>>> Sorry if this is a less than stellar question.
>>>> The problem:
>>>> Given a function f :: a -> a -> a -> b, make it work on a list
>>>> instead: f `applyTo`[x,y,z] where [x,y,z] :: [a].
>>>> My stab at a general solution was
>>>> applyTo f  = error "no arg"
>>>> applyTo f (x:xs) = go (f x) xs
>>>> go acc  = acc
>>>> go acc (y:) = acc y
>>>> go acc (y:ys) = go (acc $ y) ys
>>>> I thought this would work, functions being "first class citizens" but
>>>> ghci complains:
>>>> "Occurs check: cannot construct the infinite type: t1 = t0 -> t1
>>>> In the return type of a call of `acc'
>>>> Probable cause: `acc' is applied to too many arguments
>>>> In the expression: acc y
>>>> In an equation for `go': go acc (y : ) = acc y"
>>>> The 'probable cause' isn't the real cause here, but something to do
>>>> with the fact that it's impossible to accumulate functions in this
>>>> Or am I just too tired too make it work? I can see that the type of
>>>> `go` could be a problem, but is it insurmountable?
>>> The type of `go` is exactly the problem. In particular, the type of
>>> acc's first parameter. In the third clause of go's definition, we can
>>> see that `acc` and (acc $ y) are both used as the first argument to
>>> go, hence they must have the same type. However, this is impossible
>>> -- if acc has type (t0 -> t1), then y must have type t0, and (acc $ y)
>>> has type t1, so it would have to be the case that t1 = t0 -> t1 --
>>> hence the error message.
>>> It is not possible in Haskell to define `applyTo`.* I know this
>>> function gets used a lot in lisp/scheme, but Haskell style is
>>> different. If you explain the context in which you wanted this
>>> function, perhaps we can help you figure out a better way to structure
>>> things so it is not needed.
>>> * At least not without crazy type class hackery.
>> What is the difficulty?
>> Is the difficulty at the level of "syntax"?
>> Or is it that the type "Haskell expression", perhaps "Haskell
>> form", to use an old and often confusing Lisp term, does not
>> exist in the Haskell System of Expression? Here "exist" should be
>> read as "exist at the right level", right level for attaining
>> some objective.
>> These alternatives, I think, need not be disjoint.
>> I am ignorant of Haskell, but sometimes I write Perl in Lisp, and
>> the blurb for my last public rant mentioned a specific lambda
>> Beginners mailing list
>> Beginners at haskell.org
> Alec Story
> Cornell University
> Biological Sciences, Computer Science 2012
More information about the Beginners