# Re: Segfault with huge list...?

```hi,

On Fri, Feb 10, 2017 at 3:07 PM, Christopher Howard <
christopher.how...@qlfiles.net> wrote:```
```
> Hi list. When I try to do
>
> (apply '+ (range 1 1000000)
>

​List of ​millions of items is not a problem.
Problem how you use it.
(apply) is not for free, ​It *creates*​ a function call with a million of
arguments.
Stack size make sense.

> I get segfault. I thought maybe this was some kind of internal
> limitation of the apply function, so I defined a foldl:
>
> (de foldl (Fn Acc Lst)
>     (if (== () Lst) Acc
>         (let Acc2 (Fn Acc (car Lst))
>              (foldl Fn Acc2 (cdr Lst)) ) ) )
>
> : (foldl '+ 0 (range 1 1000))
> (foldl '+ 0 (range 1 1000))
> -> 500500
> : (foldl '+ 0 (range 1 1000000))
> (foldl '+ 0 (range 1 1000000))
>
>
​
Stack size makes sense too.
I like recursions this way:

(de rec1 (F A L)
(if L
(rec1 F (inc 'A (++ L)) L)
A ) )

recursion with hidden accumulator from outer call and car-cdr:
(de rec2 (F L A)
(default A 0)
(if L
(rec2 F (cdr L) (inc 'A (car L)))
A ) )
The call will be:  (rec2 '+ (range 1 1000000)))

As recursion just loop you can implement it without big stack too:
(de sum1 (L)
(let N 0
(for I L
(inc 'N I) ) ) )

even without list creation:
(de sum2 (X)
(let N 0
(for I X
(inc 'N I) ) ) )

And finally, that's why (sum) was implemented:
(sum prog (range 1 1000000)))

Bonus: for practice write recursion function to sum numbers without (range)```