While Clojure does not have first-class continuations or coroutines built-in as a core feature, it is possible to implement your own.
For example, core.async is a Clojure library that implements the CSP (Concurrent Sequential Processes) model. It uses a
go macro to transform the code within to a state machine. While not exactly coroutines per se, it can be used to implement the same patterns.
There is also pulley.cps, a macro compiler I've authored that transforms (via
cps-fn macros) Clojure code written in direct style into continuation-passing style. To the best of my knowledge, it is the most complete continuation-themed Clojure program. It supports dynamic binding, exceptions, calling back and forth between native and transformed code (though the continuation is not maintained across contexts). At the moment, only abortive continuations (i.e., traditional
call-cc) are supported, but I do have plans to implement delimited continuations in the future.
While pulley.cps does not directly provide coroutines per se, with
call-cc it is relatively straight-forward to implement your own. In fact, one of the examples is a simple implementation of cooperative multitasking. This is further built upon in the CSP example. There is also a Ping-Pong example, but it's more an example of tail-call optimization than coroutines.
Of course, these sorts of transformations are most effective when applied to the whole program. Unfortunately, this isn't possible with macros alone, which are localized. Still, even localized transformations can be very effective.