Adding a Map<TDest>() method.

[luigicfilho]

This method will work to help the mapping from the TValue object inside of the Result to a different object.

Goal: Help with decoupling between layers, since we will not have to have Mapping files on extension of the object with reference to another layer.

Plan:
Method code:

public Result<TDest> Map<TDest>(
        Action<PropertyMapBuilder<TSource, TDest>>? configure = null,
        bool caseInsensitive = true)
        where TDest : new()
    {
        if (!IsSuccess || Value is null)
            return new Result<TDest>(default!, false);

        var builder = new PropertyMapBuilder<TSource, TDest>();
        configure?.Invoke(builder);
        var customMap = builder.Build();

        var stringComparer = caseInsensitive
            ? StringComparer.OrdinalIgnoreCase
            : StringComparer.Ordinal;

        var sourceProps = typeof(TSource)
            .GetProperties(BindingFlags.Public | BindingFlags.Instance)
            .ToDictionary(p => p.Name, p => p, stringComparer);

        var destProps = typeof(TDest)
            .GetProperties(BindingFlags.Public | BindingFlags.Instance);

        var dest = new TDest();

        foreach (var destProp in destProps)
        {
            if (!destProp.CanWrite)
                continue;

            // resolve source property name
            string sourceName = customMap.TryGetValue(destProp.Name, out var mappedFrom)
                                ? mappedFrom
                                : destProp.Name;

            if (!sourceProps.TryGetValue(sourceName, out var sourceProp))
                continue;

            object? sourceValue = sourceProp.GetValue(Value);
            if (sourceValue is null)
            {
                // set to null only if nullable
                if (IsNullable(destProp.PropertyType))
                    destProp.SetValue(dest, null);
                continue;
            }

            if (destProp.PropertyType.IsAssignableFrom(sourceProp.PropertyType))
            {
                destProp.SetValue(dest, sourceValue);
                continue;
            }

            // attempt type conversion
            try
            {
                object? converted = Convert.ChangeType(sourceValue, Nullable.GetUnderlyingType(destProp.PropertyType) ?? destProp.PropertyType);
                destProp.SetValue(dest, converted);
            }
            catch
            {
                // if incompatible, just skip
            }
        }

        return new Result<TDest>(dest);
    }

    private static bool IsNullable(Type type) =>
        !type.IsValueType || Nullable.GetUnderlyingType(type) != null;
}

Helper class

public sealed class PropertyMapBuilder<TSource, TDest>
{
    private readonly Dictionary<string, string> _map =
        new(StringComparer.OrdinalIgnoreCase);

    public PropertyMapBuilder<TSource, TDest> Map(
        Expression<Func<TDest, object?>> dest,
        Expression<Func<TSource, object?>> src)
    {
        string destName = GetPropertyName(dest);
        string srcName = GetPropertyName(src);
        _map[destName] = srcName;
        return this;
    }

    internal Dictionary<string, string> Build() => _map;

    private static string GetPropertyName(LambdaExpression expr)
    {
        MemberExpression? m = expr.Body switch
        {
            MemberExpression me => me,
            UnaryExpression { Operand: MemberExpression u } => u,
            _ => null
        };

        if (m?.Member is not PropertyInfo pi)
            throw new ArgumentException("Expression must select a property");

        return pi.Name;
    }
}

Need investigate the limitations of this code, how to better do it.