Can we quantify the "degree of quantumness" in a quantum algorithm ? Entanglement is often held up as the key ingredient that makes quantum algorithms well... quantum, and this can be traced back to the Bell states that destroy the idea of quantum physics as a hidden-state probabilistic model. In quantum information theory (from my rather weak understanding), entanglement can also be used as a concrete resource that bounds the ability to do certain kinds of coding. 

But from other conversations (I recently sat on the Ph.D committee of a physicist working in quantum methods) I gather that entanglement is difficult to quantify, especially for mixed-state quantum states. Specifically, it appears hard to say that a particular quantum state has X units of entanglement in it (the student's Ph.D thesis was about trying to quantify amounts of entanglement "added" by well known gate operations). In fact, a recent Ph.D thesis suggests that a notion termed "quantum discord" might also be relevant (and needed) to quantify the "quantumness" of an algorithm or a state. 

If we want to treat entanglement as a resource like randomness, it's fair to ask how to measure how much of it is "needed" for an algorithm. I'm not talking about complete dequantization, merely a way of measuring the quantity. 

So is there currently any accepted way of measuring the "quantumness" of a state or an operator, or an algorithm in general ?
It depends on the context.

 For quantum algorithms, the situation is tricky, since for all we know, P=BPP=BQP.  So we can never say that a quantum algorithm does something that no classical algorithm can do; only something that a naive simulation would have trouble with.  For example, if a quantum circuit is drawn as a graph, then there is a classical simulation that runs in time exponential in the treewidth of the graph).  So treewidth can be thought of as an upper bound to 'quantumness', although not a precise measure.

Sometimes measuring quantumness in algorithms gets conflated with trying to measure the amount of entanglement produced by an algorithm, but we now think that a noisy quantum computer could have computational advantages over classical computer even with so much noise that its qubits are never in an entangled state (e.g. the one clean qubit model).  So the consensus is now more on the side of thinking of the quantumness in quantum algorithms as related to the dynamics rather than the states generated along the way.  This can help explain why 'dequantizing' is not likely to be generally possible.

 For bipartite quantum states, where the context is two-party correlations, we have many many good measures of quantumness.  Many have flaws, like being NP-hard, or not additive, but nevertheless we have a pretty sophisticated understanding of this situation.  Here is a recent review.

 There are other contexts, such as when we have a quantum state and would like to choose between different incompatible measurements.  In this setting, there are uncertainty principles that tell us things about how incompatible the measurements are.  The more incompatible the measurements are, the more 'quantum' a situation we have.  This is related to cryptography and zero-error capacities of noisy channels, among many other things.