How to use com.oath.cyclops.util.box

/**
 * @param varFn New value
 * @return  this object with mutated value
 */
public MutableByte mutate(final ByteFunction varFn) {
  return set(varFn.apply(getAsByte()));
}

/**
 * @param varFn New value
 * @return  this object with mutated value
 */
public MutableShort mutate(final ShortFunction varFn) {
  return set(varFn.apply(get()));
}

/**
 * @param varFn New value
 * @return  this object with mutated value
 */
public MutableBoolean mutate(final BooleanFunction varFn) {
  return set(varFn.apply(getAsBoolean()));
}

/**
 * @param varFn New value
 * @return  this object with mutated value
 */
public MutableChar mutate(final CharFunction varFn) {
  return set(varFn.apply(get()));
}

/**
 * @param value Create an initialised ImmutableClosedValue with specified value
 * @return Initialised ImmutableClosedValue
 */
public static <T> LazyImmutable<T> of(final T value) {
  final LazyImmutable<T> v = new LazyImmutable<>();
  v.setOnce(value);
  return v;
}

/**
 * Get the current value or set if it has not been set yet
 *
 * @param lazy Supplier to generate new value
 * @return Current value
 */
public T computeIfAbsent(final Supplier<T> lazy) {
  final T val = get();
  if (val == UNSET)
    return setOnceFromSupplier(lazy);
  return val;
}

public <T1> Mutable<T1> mapInput(final Function<T1, T> fn) {
  final Mutable<T> host = this;
  return new Mutable<T1>() {
    @Override
    public Mutable<T1> set(final T1 value) {
      host.set(fn.apply(value));
      return this;
    }
  };
}

/**
 * Create an intermediate unbound (or unitialised) ImmutableClosedValue)
 *
 * @return unitialised ImmutableClosedValue
 */
public static <T> LazyImmutable<T> unbound() {
  return new LazyImmutable<>();
}

  @Override
  public void accept(final int value) {
    set(value);

  }
}

  @Override
  public void accept(final long value) {
    set(value);

  }
}

@Override
public Long get() {
  return getAsLong();
}

@Override
public void accept(final T t) {
  set(t);
}

@Override
public void accept(final Float t) {
  set(t);
}

@Override
public Character get() {
  return getAsChar();
}

@Override
public Byte get() {
  return getAsByte();
}

/**
 * @param varFn New value
 * @return  this object with mutated value
 */
public MutableFloat mutate(final FloatFunction varFn) {
  var = varFn.apply(var);
  return this;
}

@Override
public Short get() {
  return getAsShort();
}

@Override
public Boolean get() {
  return getAsBoolean();
}

public <R> Mutable<R> mapOutput(final Function<T, R> fn) {
  final Mutable<T> host = this;
  return new Mutable<R>() {
    @Override
    public R get() {
      return fn.apply(host.get());
    }
  };
}

/**
 * @return a defined, but unitialised LazyImmutable
 */
public static <T> LazyImmutable<T> def() {
  return new LazyImmutable<>();
}