(def convertTo
  (let
    [*all-chars (mapv char (range 0 128))
     *negate (+seqf (constantly "negate") (+char "n") (+char "e") (+char "g") (+char "a") (+char "t") (+char "e"))
     *letter (+char (apply str (filter #(Character/isLetter %) *all-chars)))
     *digit (+char (apply str (filter #(Character/isDigit %) *all-chars)))
     *space (+char (apply str (filter #(Character/isWhitespace %) *all-chars)))
     *ws (+ignore (+star *space))
     *number (+map read-string (+str (+plus (+or *digit (+char "-.")))))
     *identifier (+str (+seqf cons (+char "+-/*") (+star (+or *letter *digit))))]
    (letfn [(*seq [begin p end]
              (+seqn 1 (+char begin) (+opt (+seqf cons *ws p (+star (+seqn 1 (+char " ") *ws p)))) *ws (+char end)))
            (*array [] (*seq "(" (delay (*value)) ")"))
            (*value [] (+or *negate *number *letter  (*array) *identifier))]
      (+parser (+seqn 0 *ws (*value) *ws)))))


(defn parseSuffix [expression]
  (cond
    (number? expression) (Constant expression)
    (char? expression) (Variable (str expression))
    (symbol? (last expression)) (apply (operationsMap (last expression)) (map parseSuffix (butlast expression)))
    :else (apply (operationsMap (if (symbol? (last expression)) (last expression) (read-string (last expression)))) (map parseSuffix (butlast expression)))
    )
  )

(defn parseObjectSuffix [expression] (parseSuffix (convertTo expression)))