;;;; `len` as an ordinary name, which is the whole reason the count is spelled
;;;; `length`.
;;;;
;;;; Shadowing already made a `(defn len ...)` legal, and `builtin/len` already
;;;; made the builtin reachable past one. What is left, and what this file is,
;;;; is that `len` is not a builtin at all: nothing warns, nothing needs the
;;;; qualifier, and the name is free in every position a name can be in. A
;;;; global called `len` is the one case that cannot also be here — this is a
;;;; Lisp-1 and a defn and a defonce may not share a name — so it is pinned in
;;;; test_flan instead. `len-gone.flan` is the other half: the call to the name
;;;; nothing defines.
;;;;
;;;; Four lines. In order: the local (3), the parameter doubled (6), the defn
;;;; reached by its bare name (2), and the local again over a Vec (3).

(defn twice-len [len i32] i32
  (* len 2))

;;; A defn takes the name too, and a call to it is this program's. Nothing is
;;; shadowed here — if `len` were still a builtin this definition would carry
;;; a warning, and shadow-builtin.flan is where that sentence is pinned.
(defn len [s [i32]] i32
  (length s))

(defn main [] ()
  (let [xs [10 20 30]]
    ;; The shape the long word exists for: the count in a binding called len.
    (let [len (length xs)]
      (println len)
      (println (twice-len len)))
    ;; And the bare name as a call, where no local has taken it.
    (println (len (slice xs 0 2))))
  (let [v (vec-new i32)]
    (push v 1) (push v 2) (push v 3)
    (let [len (length v)]
      (println len))
    (free v)))