Common Lisp call function

You're close but both function definitions have minor issues. In the mrg function definition, you need to pass a form (i.e. parenthesize what you want to execute) after the function declaration:

(defun mrg (w v)
    (merge 'list (sort w #'<) (sort v #'<) #'<))

And your my_eval function is incomplete for the mrg condition:

(defun my_eval(A)
    (cond
        ((atom A) A)
        ((equal 'car    (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)))))
        ((equal 'cdr    (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)))))
        ((equal 'atom   (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)))))
        ((equal 'cons   (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)) (my_eval (caddr A)))))
        ((equal 'list   (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)) (my_eval (caddr A)))))
        ((equal 'equal  (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)) (my_eval (caddr A)))))
        ((equal '*      (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)) (my_eval (caddr A)))))
        ((equal '/      (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)) (my_eval (caddr A)))))
        ((equal '+      (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)) (my_eval (caddr A)))))
        ((equal '-      (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)) (my_eval (caddr A)))))
        ((equal '=      (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)) (my_eval (caddr A)))))
        ((equal 'mrg    (car A)) (let ((A A)) (funcall (car A) (my_eval (cadr A)) (merge 'list (sort A #'<) (sort A #'<) #'<))))
        (T A)
    )
) 

(it looks like you're still missing the action (i.e. another form) for the mrg test but I'm not sure what you wanted to do in this case)

Invalid number of arguments: (EQUAL MRG)

As other answers pointed out, there is an arity mistmatch: EQUAL takes 2 parameters but was called with 1 argument in (EQUAL MRG).

Notice also that you are duplicating code a lot.

In all cases, you compare the head of a list with a constant symbol, then you funcall it by giving it as arguments the result of calling my_eval to the first, and sometimes the second, elements of the same list. Basically, your code is doing this:

(apply (first list) (mapcar #'my-eval (rest list)))

The APPLY function takes a function designator and call it with an arbitrary number of arguments. Here, that list of arguments is the result of applying my_eval to each remaining elements in the list.

The differences with your code are:

• You check each function in head position, which is good for safety and can be replicated with a list of authorized symbols.
• You discard remaining arguments, if they exist (e.g. (+ 1 4 9) would evaluate to 5 under my_eval). IMHO, my_eval should rather fail loudly in that case, because that's probably not what anyone would expect.
• Note also that the let which rebinds A to a local variable name A is not useful here.

If you want to retain that approach but remove some code duplication, you may try this; the following function should be called you determined the form to evaluate is a cons-cell.

(defun my-eval/apply (cons)
  (check-type cons cons)
  (destructuring-bind (head . tail) cons
    (let ((size (length tail))
          (arity (case head
                   ((car cdr atom) 1)
                   ((cons list equal * / + - = mrg) 2))))
      (cond
        ((not arity) (error "Unknown function ~a" head))
        ((= size arity) (apply head (mapcar #'my_eval tail)))
        (t (error
            "Arity mismatch: ~a takes ~d parameter~:p but was ~
             called with ~d argument~:p in ~s" head arity size cons))))))