No. It may seem a bit like that, but that is not technically the case.
A subroutine simply runs a particular section of code. A function runs a section of code, but can take parameters to use as local variables within the code block. A function may also return a value when called, which makes it much more than simply calling some code.
A task creates a new microthread within the engine (it also doesn't return a value). This has a bunch of extra processing consequences, but most notably it gets a turn in the running queue. Because of this, if you yield() inside of a task's microthread, it will pass the processing over to the next microthread in queue, or the microthread that started the task if it hasn't yielded before. If you don't yield during a task, the microthread will still be created, it will just end once you reach the end of the task and return to whatever started it. If you yield during a subroutine, or a function, they have not created a separate microthread, and so yield() will yield whatever microthread called said subroutine or function. This is why the often-used wait() function works; it simply puts a bunch of extra yields whereever you call it. Once all of the running microthreads have yielded, the engine runs the rest of the processing required for that frame, updates drawing and the frame counter, and begins the next frame. Now, when the microthread queue starts again, processing will pick back up wherever each microthread yielded before.
It isn't that you "don't need to" go through the whole task at once, nor do you have to go through a whole function at once, since you can easily have a function like
function bla{ doop; yield; doop; } that will run doop(), yield to "wait a frame", then the next frame run doop() again.
Yes, in that example fire() will have to complete before move() starts if fire() is a function since both run in the same microthread, but if fire() is a task then you would have to yield off in order for move() to run before fire() finishes. Also, in both cases fire() and move() will run, or at least begin, on the same frame.
