Hugh Perkins wrote:
> What makes a callback different from any other kind of function?
Well... what about inside monads? Does this break purity??? Does this
require adding IO to the monad if the callback function does IO?
As I'm writing this I kindof have this sense inside me that this is a
really newbie-ish question. That the answer is no it doesnt break
purity, yes it does require adding IO to the monad, but I'm asking
anyway just to check :-)
The question exists only because of a cultural difference.
Let f, g be functions (actions, procedures, methods, subroutines...)
such that "f(g)" is legal and means f may invoke g.
Mainstream programmers say g is a callback function, f is a function
that accepts a callback function.
Functional programmers say f is a higher-order function, g is a function.
Its use is pervasive in functional programming and especially Haskell.
Already in the second or third lesson, one meets
map h [1,2,3]
foldl (+) 0 [1,2,3]
where map calls h, and foldl calls (+). It does not matter that all of
them are pure functions, since, in mainstream programming, g is still a
callback function whether pure or side-effecting, cf. qsort and bsearch
in C.
Some callback functions are intended to be side-effecting. To do IO
actions and handle exceptions, we write like
catch my_action my_handler
catch calls my_action; if an exception is raised, catch furthermore
calls my_handler. Thus my_action and my_handler are callbacks, and catch
is a higher-order function. This is remarkably different culturally from
mainstream programming: In mainstream programming, exception handling is
a special syntax, not a library function taking handlers as callbacks
(let alone the major action); in Haskell programming, exception handling
is just another higher-order function, not a special syntax.
It doesn't stop there. Whenever you write
do a <- m
n a
which is desugared to
m >>= \a -> n a
the >>= is a function that calls m, then uses its return value to call
(\a -> n a). Thus m and (\a -> n a) are callbacks, and >>= is a
higher-order function. Sequential execution, the daily bread of every
imperative programmer, is yet another library function (this time even
possibly user-defined function) rather than special syntax in Haskell.
Therefore you have most likely used callbacks alot in Haskell without
thinking about it.
_______________________________________________
Haskell-Cafe mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/haskell-cafe
