anchor.diff:      {?FORALL(Ops, ops(), check_model(Ops) =:= true),
        [{iters, 1000},
         {diag, fun check_model/1}]}.
  +
  +prop_invariants_concurrent_() ->
  +    {?FORALL(Ops, ops_conc(), check_invariants(Ops)),
  +     [{iters, 1000}]}.
  
positive.code: ops() ->
      list(op()).
  
  op() ->
      frequency([{1, op_flush()},
                 {20, ?LET(Key, key(),
  
negative.code:                  recent_count = RecentCount,
                   stale_count = StaleCount}.
  
  dispatch_op({concurrent, Ops}) ->
      Results =
          async:with_many(
            fun (Op) ->
                    receive race -> ok end,
                    {Op, eval_mfa(op_to_mfa(Op))}
            end, Ops,
            fun (Asyncs) ->
                    lists:foreach(
                      fun (A) ->
                              async:send(A, race)
                      end, Asyncs),
                      Results = async:wait_many(Asyncs),
                      [R || {_, R} <- Results]
            end),
      {lists:sort(Results), get_cache_state()};
  dispatch_op(Op) ->
      R = eval_mfa(op_to_mfa(Op)),
      {R, get_cache_state()}.
  
  eval_mfa({M, F, A}) ->
      erlang:apply(M, F, A).
  
  op_to_mfa(Op) when is_atom(Op) ->
      op_to_mfa({Op});
  op_to_mfa(Op) when is_tuple(Op) ->
      [F | Args] = tuple_to_list(Op),
      {mru_cache, F, [?CACHE | Args]}.
  
  run_check_cache(Operations, Check) ->
      run_check_cache(Operations,
  