diff --git a/src/Optional.Tests/EitherTests.cs b/src/Optional.Tests/EitherTests.cs
index a025602..a09892a 100644
--- a/src/Optional.Tests/EitherTests.cs
+++ b/src/Optional.Tests/EitherTests.cs
@@ -653,6 +653,9 @@ public void Either_Transformation()
 
             var noneExUpper = none.MapException(x => x.ToUpper());
             var someExUpper = some.MapException(x => x.ToUpper());
+            
+            var noneBothUpper = none.Map(x => string.Concat(x.Reverse()), x => x.ToUpper());
+            var someBothReverse = some.Map(x => string.Concat(x.Reverse()), x => x.ToUpper());
 
             Assert.IsFalse(noneUpper.HasValue);
             Assert.IsTrue(someUpper.HasValue);
@@ -660,6 +663,8 @@ public void Either_Transformation()
             Assert.AreEqual(someUpper.ValueOr("ex"), "VAL");
             Assert.AreEqual(noneExUpper.Match(val => val, ex => ex), "EX");
             Assert.AreEqual(someExUpper.Match(val => val, ex => ex), "val");
+            Assert.AreEqual(noneBothUpper.Match(val => val, ex => ex), "EX");
+            Assert.AreEqual(someBothReverse.Match(val => val, ex => ex), "lav");
 
             var noneNotNull = none.FlatMap(x => x.SomeNotNull<string, string>("ex1"));
             var someNotNull = some.FlatMap(x => x.SomeNotNull<string, string>("ex1"));
diff --git a/src/Optional/Option_Either.cs b/src/Optional/Option_Either.cs
index b2179d7..ffa0412 100644
--- a/src/Optional/Option_Either.cs
+++ b/src/Optional/Option_Either.cs
@@ -403,6 +403,23 @@ public Option<TResult, TException> Map<TResult>(Func<T, TResult> mapping)
             );
         }
 
+        /// <summary>
+        /// Transforms both, the inner value or the exceptional value in an optional.
+        /// </summary>
+        /// <param name="valueMapping">The transformation function for the inner value.</param>
+        /// <param name="exceptionMapping">The transformation function for the exceptional value.</param>
+        /// <returns>The transformed optional.</returns>
+        public Option<TResult, TExceptionResult> Map<TResult, TExceptionResult>(Func<T, TResult> valueMapping, Func<TException, TExceptionResult> exceptionMapping)
+        {
+            if (valueMapping == null) throw new ArgumentNullException(nameof(valueMapping));
+            if (exceptionMapping == null) throw new ArgumentNullException(nameof(exceptionMapping));
+
+            return Match(
+                some: value => Option.Some<TResult, TExceptionResult>(valueMapping(value)),
+                none: exception => Option.None<TResult, TExceptionResult>(exceptionMapping(exception))
+            );
+        }
+
         /// <summary>
         /// Transforms the exceptional value in an optional.
         /// If the instance is not empty, no transformation is carried out.