L'uso di returnTrue () o returnFalse () funziona con un odore di codice?

Stavo cercando di capire come funzionano gli eventi cross-browser di jQuery, quando ho notato queste due funzioni nel codice sorgente :

function returnTrue() {
    return true;
}

function returnFalse() {
    return false;
}

Più in basso nel codice questi sono usati come:

if ( fn === false ) {
    fn = returnFalse;    <--- here
} else if ( !fn ) {
    return elem;
}

o

// Events bubbling up the document may have been marked as prevented
// by a handler lower down the tree; reflect the correct value.
this.isDefaultPrevented = src.defaultPrevented ||
    src.defaultPrevented === undefined &&

    // Support: Android <=2.3 only
    src.returnValue === false ?
returnTrue :    <--- here
returnFalse;    

o

jQuery.Event.prototype = {
    constructor: jQuery.Event,
    isDefaultPrevented: returnFalse,    <--- here
    isPropagationStopped: returnFalse,
    isImmediatePropagationStopped: returnFalse,
    isSimulated: false,

    preventDefault: function() {
        var e = this.originalEvent;

        this.isDefaultPrevented = returnTrue;    <--- here

La mia domanda è: perché uno avrebbe bisogno di tali funzioni in un linguaggio dinamico come JavaScript, in cui è possibile scrivere facilmente qualcosa di seguito:

if ( 'function' === typeof fn ) {
    return fn.apply( this, arguments );
}

else if ( 'boolean' === typeof fn ) {
    return fn;
}

È un odore di codice? O sono queste pratiche valide forse per un codice più pulito con meno istruzioni condizionali? O è solo un caso ristretto in cui, ad esempio, il browser si aspetta che una funzione invochi quale restituirebbe un valore booleano, quindi queste due funzioni servono solo a risparmiare tempo e combinazioni di tasti dello sviluppatore?