title: Why would an algebraic type be only an initial algebra (or vice versa)?
body: <p>In the <code>recursion-schemes</code> package we can express the fact that a (strictly-positive) algebraic data type</p>
  
  <ol>
  <li>has a signature functor, <code>f</code></li>
  <li>is the initial <code>f</code>-algebra, and</li>
  <li>is the final <code>f</code>-coalgebra</li>
  </ol>
  
  <p>For instance, we can do so for <code>[a]</code> with the following code</p>
  
  <pre><code>-- (1) define and declare the signature functor, here called Base
  
  data instance Prim [a] x = Nil | Cons a x deriving Functor
  type instance Base [a] = Prim [a]
  
  -- (2) demonstrate the initial algebra
  instance Foldable [a] where
    project []     = Nil
    project (a:as) = Cons a as
  
  -- (3) demonstrate the final coalgebra
  instance Unfoldable [a] where
    embed Nil         = []
    embed (Cons a as) = a:as
  </code></pre>
  
  <p>Notably, for any type where we have (1), (2), and (3) we ought to have that <code>(project, embed)</code> witnesses an isomorphism.</p>
  
  <p>It's my understanding that data types at large (or at least strictly-positive ones) are always final/initial co/algebras of some signature functor—in fact, they are always <em>both</em>.</p>
  
  <p>So my question is: why have <code>Foldable</code> and <code>Unfoldable</code> as separate classes? When would a data type be just one or the other?</p>
  
  <p>Currently I can imagine this might be valuable for abstract data types which only want to provide either a folding or unfolding interface, but are there other times as well?</p>