code: @Override
      public V applyIfAbsent(K key, IFunction<? super K, ? extends V> mappingFunction) {
          checkNotNull(key);
          checkNotNull(mappingFunction);
  
          int hash = hashOf(key);
          Segment<K, V> segment = segmentFor(hash);
          V v = segment.get(key, hash);
          return v == null ? segment.put(key, hash, null, mappingFunction, true) : v;
      }
docs: *
  {@inheritDoc}
  
  @throws UnsupportedOperationException {@inheritDoc}
  @throws ClassCastException            {@inheritDoc}
  @throws NullPointerException          {@inheritDoc}
  @implSpec The default implementation is equivalent to the following steps for this
  {@code map}, then returning the current value or {@code null} if now
  absent:
  <p>
  <pre> {@code
  if (map.get(key) == null) {
  V newValue = mappingFunction.apply(key);
  if (newValue != null)
  return map.putIfAbsent(key, newValue);
  }
  }</pre>
  <p>
  The default implementation may retry these steps when multiple
  threads attempt updates including potentially calling the mapping
  function multiple times.
  <p>
  <p>This implementation assumes that the ConcurrentMap cannot contain null
  values and {@code get()} returning null unambiguously means the key is
  absent. Implementations which support null values <strong>must</strong>
  override this default implementation.