If the objective function $f$ is easy to compute, you can use a solution to $OPT$ to solve $L_{OPT}$: find some $x$ which maximises the objective function; compute $f(x)$ and output "yes" if it meets or exceeds the threshold $u$ (output "no" otherwise).
That is, $L_{OPT}$ reduces to $OPT$ (for some suitable definition of the reduction type), and is in this sense easier.
If we let $OPTVAL$ be the function problem of computing the optimal value, but not the solution which has this value, $OPTVAL$ reduces to $L_{OPT}$ via binary search. (Also $OPTVAL$ reduces to $OPT$: compute the optimal solution, then compute its value.)
Note that the reduction in one direction is a member of a smaller class of reductions than in the other: when solving $L_{OPT}$ via $OPT$ you have the reduction $r$ and some post-processing $p$ such that for every instance $i$, the answer to $L_{OPT}$ equals the output of $p(OPT(r(i))$. That is, it's a one-call reduction (but not tail call, which it can't be due to a type mismatch). The reduction from $L_{OPT}$ to $OPTVAL$ is a multi-call reduction (with binary search it will make a logarithmic number of queries).
It's not clear to me that you can reduce $OPT$ to $OPTVAL$, not even with multiple calls: given an oracle which tells you what the optimal value is, how to you compute a solution with that value, generically?
However, most "natural" problems will probably let you do this. For instance, if we represent a graph $G$ as the number of vertices followed by an enumeration of the complement of the edge set and want to compute the chromatic number (smallest $k$ such that the graph is $k$-colourable), we can let $G'$ be $G$ with an edge added and ask our $OPTVAL$-oracle what the optimal value is. Whenever such a change doesn't increase the number of colours required, we learn of an additional constraint we can impose. Do so until it's no longer possible (at most polynomially often); now each vertex is adjacent to every vertex of any different colour, i.e. $u$ and $v$ have the same colour for every $(u, v) \in (V \times V) \setminus E$. Assign a colour to an uncoloured vertex, apply this rule and repeat until the graph is $k$-coloured.
One could generalise this: let solution-extractable optimisation problems be those such that with oracle access to the optimal value on smaller instances and the given instance, you can compute the optimal solution. Then you can multi-call reduce $OPT$ to $OPTVAL$ on solution-extractable problems (by construction). Of course, you can also compute optimal solutions to the smaller instances, since they are instances of a solution-extractable problem by assumption; maybe that helps to extract the optimal solution to the bigger instance.
It would be nice to have some generic constructions that enable this. Here's one idea:
Given some optimisation problem $P$ with a bound $k$ on the solution length, let instances of $Q$ be triples $(x, 1^{2k-l}, p)$ where $x$ are $P$-instances and $p$ has length $l$ be the problem of finding optimal solutions to $P$ which have $p$ as a prefix. If you can solve $OPTVAL_Q$ then $P$ is solution-extractable: whenever $OPTVAL$ of $Q$ goes down both when you extend $p$ with a $0$ and when you extend it with a $1$, $p$ is a longest optimal solution; otherwise, extend $p$ with any value which doesn't decrease the objective function. Note that padding the problem with a number of ones equal to two times the bound on the solution length, we make the self-reductions downward when extending $p$.
Probably bit-by-bit solution extraction can be extended to chunk-by-chunk extraction if chunks have length at most $O(\log n)$ (since there's only polynomially many values to try out).
