Почему добавление и окончание для связанных списков просто амортизируют O (1)?

Я взял реализацию цепных списков Окасаки и немного изменил ее, чтобы избежать проблем с булевой слепотой. Помимо этого, сама структура данных остается неизменной:

functor CatList (Q : QUEUE) :> CAT_LIST =
struct
  (* private stuff, not exposed by CAT_LIST *)

  structure L = Lazy
  structure O = Option  (* from basis library *)

  datatype 'a cons = ::: of 'a * 'a cons L.lazy Q.queue

  infixr 5 :::

  (* Q.snoc : 'a Q.queue * 'a -> 'a Q.queue *)
  fun link (x ::: xs, ys) = x ::: Q.snoc (xs, ys)

  (* L.delay : ('a -> 'b) -> ('a -> 'b L.lazy)
   * L.force : 'a L.lazy -> 'a
   * Q.uncons : 'a Q.queue -> ('a * 'a Q.queue lazy) option *)
  fun linkAll (xs, ys) =
    let
      val xs = L.force xs
      val ys = L.force ys
    in
      case Q.uncons ys of
          NONE => xs
        | SOME ys => link (xs, L.delay linkAll ys)
    end

  (* public stuff, exposed by CAT_LIST *)

  type 'a list = 'a cons option

  val empty = NONE

  (* L.pure : 'a -> 'a L.lazy *)
  fun append (xs, NONE) = xs
    | append (NONE, xs) = xs
    | append (SOME xs, SOME ys) = SOME (link (xs, L.pure ys))

  (* Q.empty : 'a Q.queue *)
  fun cons (x, xs) = append (SOME (x ::: Q.empty), xs)
  fun snoc (xs, x) = append (xs, SOME (x ::: Q.empty))

  (* O.map : ('a -> 'b) -> ('a option -> 'b option) *)
  fun uncons NONE = NONE
    | uncons (SOME (x ::: xs)) = SOME (x, L.delay (O.map linkAll) (Q.uncons xs))
end

В своей книге Окасаки утверждает, что при реализации очередей с операциями O(1) (наихудшими или амортизированными) append и uncons амортизируются O(1).

Почему его утверждение не может быть подтверждено? Учитывая реализацию очередей в реальном времени (все операции выполняются в наихудшем случае O(1)), append и uncons мне кажутся наихудшими O(1). Все рекурсивные вызовы в linkAll охраняются L.delay, и ни одна из публичных операций никогда не вызывает более одной приостановки. Мои рассуждения (или мой код) неверны?