felipeochoa / mole Goto Github PK

There's some monad-like behavior hiding in mole-parse-match: 'fail ~ Nothing and mole-node ~ Just mole-node. I suspect there's some optimization possible here (https://wiki.haskell.org/Performance/Monads), but I'm not sure...

A bunch of generic sequence code could be removed for single-item productions. E.g., (+ "x") expands to:

(mole-parse-match
    (children
     (mole-parse-match
         (res
          (let (item star-items)
            (while (mole-parse-success-p
                 (setq item
                       (mole-parse-match (res (mole-parse-anonymous-literal "x" nil)) ;; (1)
                         (list res)
                         'fail)))
              (setq star-items (nconc star-items item)))
            (if star-items
                (mole-node '+ star-items nil)
              'fail)))
       (list res)
       'fail))
  (mole-node 'mole~x children nil)
  'fail)

This optimization would get rid of the mole-parse-match in (1) and convert the (while ... (nconc...)) loop into a more idiomatic (and probably faster) (progn (while ... (push ...)) (nreverse ...)))

There's no need to create all the intermediate mole-nodes and to continually check against 'fail when everything will be fused together. Simply returning t for success and nil for fail should suffice. The challenge is in doing this while keeping the code understandable