(import /src/repl)

(use argparse)

(def params
  [```
   A desk calculator with vectors and quotations.

   USAGE:
      ec <expression>: evaluate <expression> as a sequence of
                       ec commands and print the resulting stack.
      ec -f <file>   : load and evaluate <file> as an ec program.
      ec             : enter interactive (repl) mode.
   
      ec operates as a RPN desk calculator with quotation
      and vector math functions. Ordinarily, tokens are
      evaluated from left to right as they're pushed onto
      the stack. eg.,
   
          3 4 +
   
      will push 3, then 4, then apply the operation +, which
      will pop two elements from the stack, add them, and
      push their sum.
   
      To quote a sequence of tokens, wrap it in
      parentheses. eg.,
   
          (3 4 +)
   
      will push a single quotation containing just those
      three tokens, which can be applied by subsequent
      commands.
   
      To create a vector, enclose a sequence of numbers or
      other vectors in square brackets. eg.,
   
          [3 4]
   
      will create a 1-dimensional vector and push it on the
      stack.
   
      Vectors can be added to other vectors or individual
      numbers. eg.,
    
          [3 4] 2 +
   
      will add 2 to each element of [3 4], resulting in
      [5 6].
   
          [3 4] [2 1] +
   
      will add matching elements of vectors, resulting in
      [5 5].
   
      Vectors can be of arbitrary dimension, but must
      contain homogeneous data. eg.,
   
          [[2 1] [0 0]]
   
      is a valid vector (of shape [2 2]), but
   
          [[2] [0 0]]
   
      is not.
   
      For a full dictionary listing, enter the special
      command:
   
        ??
   
      To get a description of any word, quote it and use the
      special command. eg.,
   
          (!) ?
   
      Will print a description of the `apply` adverb.
   ```
   :default {:kind :accumulate}
   "file" {:kind :option
           :short "f"
           :help "The filename to evaluate"}])

(defn main
  [& _args]
  (when-let [res (argparse ;params)]
    (match res
      {"file" filename} (->>
                          filename
                          (slurp)
                          (string/split "\n")
                          (repl/handle-lines))
      {:default inputs} (->
                          inputs
                          (string/join " ")
                          (tuple)
                          (repl/handle-lines))
      _ (repl/repl))))