Thanks for clearing that up! I do understand why you removed it, although it does seem odd that it wasn’t used a lot, – probably not because it wasn’t useful but because people simply didn’t know it was there. As you know, the same functionality can be achieved in numerous other ways so I guess people didn’t even bother enquiring.

BTW, awesome work on Sizzle, it rules! 🙂

I, personally, added in the .find(“foo”, function(){}) syntax because I liked – for the same reasons that you did – but after a while it became apparent that 1) I was the only one using it and 2) That it made a large number of methods very sloppy and ambiguous.

We can certainly look at adding it back in some day – but I’m just not seeing it, right now.

If you wanted to get that functionality for all methods you could do something like this:

$().using("children", "li", function() { });

The first arg is the name of the jQuery method you want to use, followed by its arguments (if any) and finally the function to be applied to the filtered elements. A simple implementation:

$.fn.using = function(/*method, args, fn*/){
	var ap = Array.prototype, args = arguments,
		method = ap.shift.call(args), fn = ap.pop.call(args);
	return this[method].apply(this, args).each(fn).end();
};

Hilarity ensues if the method isn’t one that requires an .end() or if there aren’t enough arguments.

It’s easy enough to bring back though:

$.fn.oFind = $.fn.find;
$.fn.find = function(){
    var a = arguments;
    return $.isFunction(a[1]) ?
        // If a function is passed don't return
        // elems, just perform the action on them:
        this.each(function(){
            $(a[0],this).each(a[1]);
        })
        : this.oFind.apply(this,a);
}

The problem now is that it doesn’t quite make sense… should it return the original element or the new-found elements? The point in the “with” method was that it didn’t change the subject of the chain…

Early versions of jQuery allowed find and filter to take a second optional argument that was a function. When that was provided it would do an each with that function using the find/filter elements and not change the chain. So your example above would just use find instead of with and it would work just the way you want.

I don’t recall why that feature was removed; I know it was the subject of some extended discussion on a jQuery list at the time.