Re: why I love scheme

[Zelphir Kaltstahl]

I did not know, that lambdas are allocated on the heap. I have a few questions 
now:

How does this affect using fibers? (And how do fibers work better in that case?)

The unrolling you mentioned. Would same not be possible for the
naive-but-not-tail-recursive version? Is the idea, that the continuation tail
recursive version does work better, because the compiler is somehow able to
optimize it better? If so, why?

I am asking, because I once had the same kind of problem and then read, that
instead of growing stack levels, I am growing the continuation, so not winning
anything. But perhaps that was wrong and I should have gone for the continuation
solution. I would like to be able to make an educated decision when next meeting
such a problem.

Best regards,
Zelphir


On 12/15/21 1:59 PM, Stefan Israelsson Tampe wrote:
> I believe that the lambda closures will be allocated from the heap and hence
> this procedure will
> be perfect if you are using fibers.. Also the compiler can do magic if it
> want's and unroll 
> and untangle a few iterations, so it can be very fast as well.My point is that
> the named let
> is such a nice  looping construct (try to do this with a for loop in java). I
> use it all the time
> and only sometimes I need to move to even more advanced constructs like 
> letrec. 
>
> On Wed, Dec 15, 2021 at 10:38 AM Zelphir Kaltstahl <zelphirkaltstahl@posteo.de
> <mailto:zelphirkaltstahl@posteo.de>> wrote:
>
>     Hello Stefan!
>
>     This translates a recursive tree function into a tail recursive function.
>     However, in this case, I am not sure it is really worth doing, in
>     comparison to
>     the naive (+ first-branch other-branch) solution. The reason is, that
>     instead of
>     a call stack for multiple branches, you are only moving that stuff into a
>     longer
>     and longer continuation, which will be on the stack in each recursive 
> call.
>
>     However, I think you or other people on the list probably know more about 
> this
>     than I do and about how the approaches compare in terms of memory and 
> time.
>     Maybe the stack frames are more in size than the memory consumed by the
>     overhead
>     of the continuation, or the other way around.
>
>     Regards,
>     Zelphir
>
>     On 12/15/21 12:44 AM, Stefan Israelsson Tampe wrote:
>     > Maybe you think the below program is trivial, but I adore named let's so
>     > much that I just cannot fathom that when people go functional they 
> totally
>     > miss this beauty
>     >
>     >
>     > (define (count tree)
>     >
>     > ;; s = total sum up to now
>     >
>     > ;; t = tree of the type (car = child . cdr = siblings)
>     >
>     > ;; cont is the continuation, (cont 10) will continue
>     >
>     > ;; the calculation with the sum=10 see how we initiate
>     >
>     > ;; with a continuation that evaluates returns it's argument
>     >
>     >
>     > (let loop ((s 0) (t tree) (cont (lambda (s) s)))
>     >
>     > (if (pair? t)
>     >
>     > (loop s (car t) (lambda (s) (loop s (cdr t) cont)))
>     >
>     > (cont (if (number? t) t 0))))
>
>     -- 
>     repositories: https://notabug.org/ZelphirKaltstahl
>     <https://notabug.org/ZelphirKaltstahl>
>
-- 
repositories: https://notabug.org/ZelphirKaltstahl