Segementing a recursive tree in haskell
I'll start with something unrelated to recursion: A first cleanup step might be to reduce the repetition in segment:

segment els @ (head:tail) =
  let constr = case head of
                 Emph ch        -&gt; Just (Emph, ch)
                 Strong ch      -&gt; Just (Strong, ch)
                 Strikeout ch   -&gt; Just (Strikeout, ch)
                 Superscript ch -&gt; Just (Superscript, ch)
                 Subscript ch   -&gt; Just (Subscript, ch)
                 SmallCaps ch   -&gt; Just (SmallCaps, ch)
                 Quoted qt ch   -&gt; Just (Quoted qt, ch)
                 Cite cs ch     -&gt; Just (Cite cs, ch)
                 Span attr ch   -&gt; Just (Span attr, ch)
                 _              -&gt; Nothing
      sentence = Span ("", ["sentence"], [])
  in case constr of
    Just (inlnConstr, ch) -&gt; map inlnConstr (segment ch) ++ segment tail
    _               -&gt;
      maybe [sentence els] (\i -&gt; (sentence $ take i els) : segment (drop i els))
        $ (1 +) &lt;$&gt; List.findIndex split els


Note that we not only cut away the repeating (segment ch) and ++ segment tail, but also the toList, which is just an id here (as the result of segment already is a List.

Next would be the splitting, which could be done using break instead of findIndex, drop, and take:

      case break split els of
        (_, [])    -&gt; [sentence els]
        (xs, y:ys) -&gt; sentence (xs ++ [y]) : segment ys


The last part of your post might better be asked on stackoverflow, as there is no working code for this yet.