; Iter 15c — empirical stress test for std_list's folds.
; Builds a 1000-element list [1000, 999, ..., 1] and folds it with
; both fold_left (tail-marked, should run in constant stack via
; `musttail call` lowering) and fold_right (constructor-blocked,
; runs at ~1000-deep stack — well within an 8MB Linux stack budget).
; Expected stdout: two lines, each `500500` (sum 1..1000 = 500500).

(module std_list_stress

  (import std_list)

  (fn build
    (doc "Build [n, n-1, ..., 1] :: std_list.List Int via Cons recursion. Constructor-blocked; not tail.")
    (type
      (fn-type
        (params (con Int))
        (ret (con std_list.List (con Int)))))
    (params n)
    (body
      (if (app == n 0)
        (term-ctor std_list.List Nil)
        (term-ctor std_list.List Cons
          n
          (app build (app - n 1))))))

  (fn add
    (doc "Binary +. Used as the fold accumulator op for both fold_left and fold_right.")
    (type
      (fn-type
        (params (con Int) (con Int))
        (ret (con Int))))
    (params a b)
    (body (app + a b)))

  (fn main
    (doc "Build a 1000-element list, fold it both ways, print both sums (each 500500).")
    (type (fn-type (params) (ret (con Unit)) (effects IO)))
    (params)
    (body
      (seq (do io/print_int (app std_list.fold_left  add 0 (app build 1000)))
           (do io/print_int (app std_list.fold_right add 0 (app build 1000)))))))
