public sealed record Integer(int Value);

public sealed record Integer(int Value)
{
    public Integer Triple() => new Integer(Value * 3);
}

public int SomeMethod(Integer number)
{
    var tripled = number.Triple();
    if (tripled.Value > 5)
        return tripled.Value;
    else
        return 1;
}

public int SomeMethod(Integer number)
    => number.Tripled.Value > 5 ? number.Tripled.Value : 1;

public sealed record Number(int Value)
{
    public int Number Tripled => new Number(@this.Value * 3);
}

public sealed record Number : IEquatable<Number>
{
    public int Value { get; init; }  // we have to overload the ctor, so it anyway makes no sense to put it as a record's parameter
    public int Number Tripled => tripled.Value;
    private Lazy<Number> tripled;
    public Number(int value)
    {
        Value = value;
        tripled = new(() => value * 3);  // we cannot do it when assigning a field because you cannot address other fields from a field's initialization
    }
    // because Equals, generated for records, is generated based on its fields, hence, Lazy<T> affects the comparison
    public bool Equals(Number number) => Value == number.Value;
    // same logic with GetHashCode
    public override int GetHashCode() => Value.GetHashCode();
}

public sealed record Number(int Value)
{
    public Number Tripled => tripled.GetValue(this, @this => new Integer(@this.Value * 3));
    private static ConditionalWeakTable<Number, Number> tripled = new();
}

public struct FieldCache<T> : IEquatable<FieldCache<T>>
{
    private T value;
    private object holder; // we will only compare references, hence there is no need to make it generic
    // like I said earlier, to avoid affects of the field on Equals and GetHashCode we make it permanently true and 0
    public bool Equals(FieldCache<T> _) => true;
    public override int GetHashCode() => 0;
}

public struct FieldCache<T> : IEquatable<FieldCache<T>>
{
        public T GetValue<TThis>(Func<TThis, T> factory, TThis @this)
          // record is class internally. We need the holder to
          // be a reference type so that we could safely compare by it
          where TThis : class
        {
            // if the holder's reference has changed or is null
            if (!ReferenceEquals(@this, holder))
                lock (@this)
                {
                    if (!ReferenceEquals(@this, holder))
                    {
                        // we pass this to the factory, so that the
                        // property using FieldCache could address
                        // local properties/fields or methods
                        // without the need to recreate a capturing lambda
                        value = factory(@this);
                        holder = @this;
                    }
                }
            return value;
        }
}

public sealed record Number(int Value)
{
    public int Number Tripled => tripled.GetValue(@this => new Number(@this.Value * 3), @this);
    private FieldCache<Number> tripled;
}