(module mut

  (fn mut_empty
    (doc "Iter mut.1 — empty mut block; body is a single Int literal.")
    (type (fn-type (params) (ret (con Int))))
    (params)
    (body (mut 0)))

  (fn mut_single_var
    (doc "Iter mut.1 — one var, one assign, final expression reads the var.")
    (type (fn-type (params) (ret (con Int))))
    (params)
    (body
      (mut
        (var x (con Int) 0)
        (assign x (app + x 1))
        x)))

  (fn mut_two_vars
    (doc "Iter mut.1 — two vars, two assigns, final expression combines them.")
    (type (fn-type (params) (ret (con Float))))
    (params)
    (body
      (mut
        (var sum (con Float) 0.0)
        (var count (con Int) 0)
        (assign sum (app + sum 1.0))
        (assign count (app + count 1))
        (app + sum (app int_to_float count)))))

  (fn mut_nested_shadow
    (doc "Iter mut.1 — outer var shadowed by inner mut block's var of the same name.")
    (type (fn-type (params) (ret (con Int))))
    (params)
    (body
      (mut
        (var x (con Int) 10)
        (assign x (app + x 1))
        (mut
          (var x (con Int) 100)
          (assign x (app + x 1))
          x))))

  (fn mut_returns_bool
    (doc "Iter mut.1 — exercise Bool as a supported scalar var type.")
    (type (fn-type (params) (ret (con Bool))))
    (params)
    (body
      (mut
        (var flag (con Bool) false)
        (assign flag true)
        flag)))

  (fn mut_returns_unit
    (doc "Iter mut.1 — exercise Unit as the supported scalar zero case.")
    (type (fn-type (params) (ret (con Unit))))
    (params)
    (body
      (mut
        (var u (con Unit) (lit-unit))
        (assign u (lit-unit))
        u))))