For codata vs data, this post worked for me: http://blog.sigfpe.com/2007/07/data-and-codata.html

Roughly, data is of finite size, and codata is of infinite size. Consider a (normal finite) list vs an infinite lazy list.

The standard pattern for working with data is to break it into smaller pieces, using pattern matching, till you hit a base case. In Scheme (hopefully close enough to CL you can read it; and not using pattern matching, but whateva) you write stuff like

   (define (foldr f zero lst)
     (cond lst
       [(null? lst) zero]
       [else (f (car lst) (foldr f zero (cdr lst)))]))

We break lst into smaller pieces till we hit the base case of the empty list. Classic stuff and everyone knows it.

Now what about codata? You can't break down infinite data till you hit a base case, because there is no base case. It's infinite! So you apply the Fundamental Theorem of Pretending You Understand Category Theory, and prepend co- to all technical terms in the description for data.

So if data is processed using pattern matching and recursion, then codata is processed using copattern matching and corecursion.

By a strange quirk of fate this actually makes sense. You can read more about corecursion (aka coinduction) on your local Internet, and I guess copatterns, as described in the post, are the next piece of the puzzle.

There is a slight analogy with setf but it doesn't go very far.

HTH.