diff --git a/AgileMapper.UnitTests/Configuration/WhenConfiguringEnumMapping.cs b/AgileMapper.UnitTests/Configuration/WhenConfiguringEnumMapping.cs
index 11e4f85da..cf95a09eb 100644
--- a/AgileMapper.UnitTests/Configuration/WhenConfiguringEnumMapping.cs
+++ b/AgileMapper.UnitTests/Configuration/WhenConfiguringEnumMapping.cs
@@ -36,7 +36,7 @@ public void ShouldRemovePairedEnumsFromEnumMismatchWarnings()
                 mapper.WhenMapping
                     .PairEnum(PaymentTypeUk.Cheque).With(PaymentTypeUs.Check);
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicTwoFields<PaymentTypeUk, PaymentTypeUs>>()
                     .OnTo<PublicTwoFields<PaymentTypeUs, PaymentTypeUk>>();
 
diff --git a/AgileMapper.UnitTests/Dictionaries/WhenViewingDictionaryMappingPlans.cs b/AgileMapper.UnitTests/Dictionaries/WhenViewingDictionaryMappingPlans.cs
index a74d8717e..54d81176a 100644
--- a/AgileMapper.UnitTests/Dictionaries/WhenViewingDictionaryMappingPlans.cs
+++ b/AgileMapper.UnitTests/Dictionaries/WhenViewingDictionaryMappingPlans.cs
@@ -11,7 +11,7 @@ public class WhenViewingDictionaryMappingPlans
         [Fact]
         public void ShouldShowATargetObjectMappingPlan()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<Dictionary<string, string>>()
                 .ToANew<CustomerViewModel>();
 
@@ -25,7 +25,7 @@ public void ShouldShowATargetObjectMappingPlan()
         [Fact]
         public void ShouldShowATargetComplexTypeCollectionMappingPlan()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<Dictionary<string, object>>()
                 .ToANew<Collection<Address>>();
 
@@ -39,7 +39,7 @@ public void ShouldShowATargetComplexTypeCollectionMappingPlan()
         [Fact]
         public void ShouldShowASourceObjectMappingPlan()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<MysteryCustomer>()
                 .ToANew<Dictionary<string, object>>();
 
@@ -51,7 +51,7 @@ public void ShouldShowASourceObjectMappingPlan()
         [Fact]
         public void ShouldShowASourceComplexTypeEnumerableMappingPlan()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<IEnumerable<CustomerViewModel>>()
                 .ToANew<Dictionary<string, string>>();
 
diff --git a/AgileMapper.UnitTests/WhenMappingCircularReferences.cs b/AgileMapper.UnitTests/WhenMappingCircularReferences.cs
index 2bf841df6..ac419949c 100644
--- a/AgileMapper.UnitTests/WhenMappingCircularReferences.cs
+++ b/AgileMapper.UnitTests/WhenMappingCircularReferences.cs
@@ -307,7 +307,7 @@ public void ShouldMapNestedMultiplyRecursiveRelationships()
         [Fact]
         public void ShouldGenerateAMappingPlanForLinkRelationships()
         {
-            var plan = Mapper.GetPlanFor<Video>().Over<Video>();
+            string plan = Mapper.GetPlanFor<Video>().Over<Video>();
 
             plan.ShouldNotBeNull();
             plan.ShouldContain("WhenMappingCircularReferences.Video -> WhenMappingCircularReferences.Video");
@@ -317,7 +317,7 @@ public void ShouldGenerateAMappingPlanForLinkRelationships()
         [Fact]
         public void ShouldGenerateAMappingPlanForAOneToOneRelationship()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<Parent>()
                 .ToANew<Parent>();
 
diff --git a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
index 08b82bb6c..5b7faf92e 100644
--- a/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
+++ b/AgileMapper.UnitTests/WhenViewingMappingPlans.cs
@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Collections.ObjectModel;
     using System.Text.RegularExpressions;
     using Shouldly;
     using TestClasses;
@@ -12,17 +13,92 @@ public class WhenViewingMappingPlans
         [Fact]
         public void ShouldIncludeASimpleTypeMemberMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicField<string>>()
                 .ToANew<PublicProperty<string>>();
 
             plan.ShouldContain("publicProperty_String.Value = pfsToPpsData.Source.Value;");
         }
 
+        [Fact]
+        public void ShouldGenerateAllRuleSets()
+        {
+            string plan = Mapper
+                .GetPlansFor<PublicField<string>>()
+                .To<PublicProperty<string>>();
+
+            plan.ShouldContain("Rule Set: CreateNew");
+            plan.ShouldContain("Rule Set: Merge");
+            plan.ShouldContain("Rule Set: Overwrite");
+        }
+
+        [Fact]
+        public void ShouldSupportAnonymousSourceTypesFromTheStaticApi()
+        {
+            string plan = Mapper
+                .GetPlanFor(new { Name = default(string), Discount = default(int) })
+                .ToANew<MysteryCustomer>();
+
+            plan.ShouldContain("Map AnonymousType<string, int> -> MysteryCustomer");
+            plan.ShouldContain("mysteryCustomer.Name = fatsiToMcData.Source.Name;");
+            plan.ShouldContain("mysteryCustomer.Discount = (decimal)fatsiToMcData.Source.Discount;");
+            plan.ShouldContain("// No data source for Report");
+        }
+
+        [Fact]
+        public void ShouldSupportAnonymousSourceTypesFromTheInstanceApi()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                string plan = mapper
+                    .GetPlanFor(new { Name = default(string), AddressLine1 = default(string) })
+                    .OnTo<Customer>();
+
+                plan.ShouldContain("Map AnonymousType<string, string> -> Customer");
+                plan.ShouldContain("customer.Name = sourceF__AnonymousType29_String_String.Name;");
+                plan.ShouldContain("address.Line1 = sourceF__AnonymousType29_String_String.AddressLine1;");
+            }
+        }
+
+        [Fact]
+        public void ShouldSupportStructsFromTheStaticApi()
+        {
+            string plan = Mapper
+                .GetPlanFor<PublicTwoFieldsStruct<int, int>>()
+                .Over<PublicTwoFieldsStruct<string, string>>();
+
+            plan.ShouldContain("publicTwoFieldsStruct_String_String.Value1 = ptfsiiToPtfsssData.Source.Value1.ToString();");
+        }
+
+        [Fact]
+        public void ShouldSupportStructMergePlansFromTheStaticApi()
+        {
+            string plan = Mapper
+                .GetPlanFor<PublicTwoFieldsStruct<int, int>>()
+                .OnTo<PublicTwoFieldsStruct<string, string>>();
+
+            plan.ShouldContain("publicTwoFieldsStruct_String_String.Value1 = ptfsiiToPtfsssData.Source.Value1.ToString();");
+        }
+
+        [Fact]
+        public void ShouldSupportStructsFromTheInstanceApi()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                string plan = mapper
+                    .GetPlanFor<PublicPropertyStruct<string>>()
+                    .ToANew<PublicCtorStruct<string>>();
+
+                plan.ShouldContain("Map PublicPropertyStruct<string> -> PublicCtorStruct<string>");
+                plan.ShouldContain("return new PublicCtorStruct");
+                plan.ShouldContain("ppssToPcssData.Source.Value");
+            }
+        }
+
         [Fact]
         public void ShouldIncludeAComplexTypeMemberMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PersonViewModel>()
                 .ToANew<Person>();
 
@@ -33,7 +109,7 @@ public void ShouldIncludeAComplexTypeMemberMapping()
         [Fact]
         public void ShouldIncludeASimpleTypeEnumerableMemberMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicProperty<int[]>>()
                 .ToANew<PublicField<IEnumerable<int>>>();
 
@@ -47,7 +123,7 @@ public void ShouldIncludeASimpleTypeEnumerableMemberMapping()
         [Fact]
         public void ShouldIncludeASimpleTypeMemberConversion()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicProperty<Guid>>()
                 .ToANew<PublicField<string>>();
 
@@ -66,7 +142,7 @@ public void ShouldIncludeAConfiguredExpression()
                     .Map((p, pvm) => p.Title + " " + p.Name)
                     .To(pvm => pvm.Name);
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<Person>()
                     .Over<PersonViewModel>();
 
@@ -77,7 +153,7 @@ public void ShouldIncludeAConfiguredExpression()
         [Fact]
         public void ShouldIncludeARootComplexTypeEnumerableMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<IEnumerable<Person>>()
                 .OnTo<IEnumerable<PersonViewModel>>();
 
@@ -88,7 +164,7 @@ public void ShouldIncludeARootComplexTypeEnumerableMapping()
         [Fact]
         public void ShouldIncludeAComplexTypeEnumerableMemberMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<IList<PersonViewModel>>()
                 .Over<IEnumerable<Person>>();
 
@@ -104,7 +180,7 @@ public void ShouldIncludeAComplexTypeEnumerableMemberMapping()
         [Fact]
         public void ShouldIncludeAMemberWithNoDataSource()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PersonViewModel>()
                 .OnTo<Person>();
 
@@ -121,7 +197,7 @@ public void ShouldIncludeAnIgnoredMember()
                     .To<PersonViewModel>()
                     .Ignore(pvm => pvm.AddressLine1);
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<Person>()
                     .ToANew<PersonViewModel>();
 
@@ -141,7 +217,7 @@ public void ShouldNotIncludeASourceMemberWithTheSameConditionAsAConfiguredMember
                     .Map((pf, pp) => pf.Value.Value)
                     .To(pp => pp.Value);
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicField<PublicField<string>>>()
                     .ToANew<PublicProperty<string>>();
 
@@ -153,7 +229,7 @@ public void ShouldNotIncludeASourceMemberWithTheSameConditionAsAConfiguredMember
         [Fact]
         public void ShouldShowInlineMappers()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicField<PublicField<PublicField<int>>>>()
                 .ToANew<PublicField<PublicSealed<PublicSealed<long>>>>();
 
@@ -165,7 +241,7 @@ public void ShouldShowInlineMappers()
         [Fact]
         public void ShouldShowMapChildCalls()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicProperty<object>>()
                 .ToANew<PublicSetMethod<Customer>>();
 
@@ -178,7 +254,7 @@ public void ShouldShowMapChildCalls()
         [Fact]
         public void ShouldShowNestedMapChildCalls()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicProperty<PublicField<object>>>()
                 .ToANew<PublicSetMethod<PublicProperty<Order>>>();
 
@@ -201,7 +277,7 @@ public void ShouldShowMapChildObjectCalls()
                     .To(ptf => ptf.Value1);
 
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicProperty<string>>()
                     .ToANew<PublicTwoFields<string, object>>();
 
@@ -214,7 +290,7 @@ public void ShouldShowMapChildObjectCalls()
         [Fact]
         public void ShouldShowMapElementCalls()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicProperty<object[]>>()
                 .ToANew<PublicSetMethod<ICollection<Product>>>();
 
@@ -227,7 +303,7 @@ public void ShouldShowMapElementCalls()
         [Fact]
         public void ShouldShowDictionaryElementMapping()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<List<PublicField<Dictionary<int, string>>>>()
                 .ToANew<List<PublicField<Dictionary<int, string>>>>();
 
@@ -241,7 +317,7 @@ public void ShouldShowObjectTracking()
             {
                 mapper.WhenMapping.TrackMappedObjects();
 
-                var plan = mapper.GetPlanFor<Parent>().ToANew<Parent>();
+                string plan = mapper.GetPlanFor<Parent>().ToANew<Parent>();
 
                 plan.ShouldContain("pToPData.TryGet(sourceChild.EldestParent, out parent)");
                 plan.ShouldContain("pToPData.Register(sourceChild.EldestParent, parent)");
@@ -251,7 +327,7 @@ public void ShouldShowObjectTracking()
         [Fact]
         public void ShouldNotDuplicateChildMappingPlans()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicTwoFields<object, object>>()
                 .ToANew<PublicTwoParamCtor<Product, Product>>();
 
@@ -263,7 +339,7 @@ public void ShouldNotDuplicateChildMappingPlans()
         [Fact]
         public void ShouldNotRangeCheckNullableToNonNullableValues()
         {
-            var plan = Mapper.GetPlanFor<PublicField<int?>>().ToANew<PublicField<int>>();
+            string plan = Mapper.GetPlanFor<PublicField<int?>>().ToANew<PublicField<int>>();
 
             plan.ShouldNotContain("int.MinValue");
         }
@@ -271,7 +347,7 @@ public void ShouldNotRangeCheckNullableToNonNullableValues()
         [Fact]
         public void ShouldShowEnumMismatches()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<OrderUs>()
                 .ToANew<OrderUk>();
 
@@ -293,7 +369,7 @@ public void ShouldShowMultipleEnumSourceMembers()
                     .If((s, o) => s.Value1 == PaymentTypeUk.Cheque)
                     .Map((s, o) => s.Value2).To(o => o.PaymentType);
 
-                var plan = mapper
+                string plan = mapper
                     .GetPlanFor<PublicTwoFields<PaymentTypeUk, PaymentTypeUs>>()
                     .ToANew<OrderUs>();
 
@@ -307,7 +383,7 @@ public void ShouldShowMultipleEnumSourceMembers()
         [Fact]
         public void ShouldShowNestedEnumMismatches()
         {
-            var plan = Mapper
+            string plan = Mapper
                 .GetPlanFor<PublicField<OrderUs>>()
                 .ToANew<PublicProperty<OrderUk>>();
 
@@ -318,7 +394,7 @@ public void ShouldShowNestedEnumMismatches()
         [Fact]
         public void ShouldNotAssignATargetMemberToItself()
         {
-            var plan = Mapper.GetPlanFor<PublicField<string>>().OnTo<PublicField<string>>();
+            string plan = Mapper.GetPlanFor<PublicField<string>>().OnTo<PublicField<string>>();
 
             plan.ShouldNotContain("publicField_String.Value = publicField_String.Value");
         }
@@ -332,10 +408,98 @@ public void ShouldIncludeMemberFilterExpressions()
                     .To<Address>()
                     .IgnoreTargetMembersWhere(member => member.IsPropertyMatching(p => p.Name == "Line2"));
 
-                var plan = mapper.GetPlanFor<Address>().ToANew<Address>();
+                string plan = mapper.GetPlanFor<Address>().ToANew<Address>();
 
                 plan.ShouldContain("member.IsPropertyMatching(p => p.Name == \"Line2\")");
             }
         }
+
+        [Fact]
+        public void ShouldIncludeUnmappableStructComplexTypeMemberDetails()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                string plan = mapper
+                    .GetPlanFor<PublicTwoFields<Person, string>>()
+                    .ToANew<PublicTwoFieldsStruct<Person, int>>();
+
+                plan.ShouldContain("int.TryParse(ptfpsToPtfspiData.Source.Value2");
+                plan.ShouldContain("Person member on a struct");
+            }
+        }
+
+        [Fact]
+        public void ShouldIncludeUnmappableReadOnlyArrayMemberDetails()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<PublicField<string[]>>()
+                    .To<PublicReadOnlyField<int[]>>()
+                    .Map(ctx => ctx.Source.Value)
+                    .ToCtor<int[]>();
+
+                string plan = mapper
+                    .GetPlanFor<PublicField<string[]>>()
+                    .ToANew<PublicReadOnlyField<int[]>>();
+
+                plan.ShouldContain("readonly array");
+            }
+        }
+
+        [Fact]
+        public void ShouldIncludeUnmappableReadOnlyReadOnlyCollectionMemberDetails()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<PublicField<string[]>>()
+                    .To<PublicReadOnlyField<ReadOnlyCollection<int>>>()
+                    .Map(ctx => ctx.Source.Value)
+                    .ToCtor("readOnlyValue");
+
+                string plan = mapper
+                    .GetPlanFor<PublicField<string[]>>()
+                    .ToANew<PublicReadOnlyField<ReadOnlyCollection<int>>>();
+
+                plan.ShouldContain("readonly ReadOnlyCollection<int>");
+            }
+        }
+
+        [Fact]
+        public void ShouldIncludeUnmappableReadOnlyIntMemberDetails()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .From<PublicField<string>>()
+                    .To<PublicReadOnlyField<int>>()
+                    .Map(ctx => ctx.Source.Value)
+                    .ToCtor("readOnlyValue");
+
+                string plan = mapper
+                    .GetPlanFor<PublicField<string>>()
+                    .ToANew<PublicReadOnlyField<int>>();
+
+                plan.ShouldContain("readonly int");
+            }
+        }
+
+        [Fact]
+        public void ShouldShowAllCachedMappingPlans()
+        {
+            Mapper.GetPlanFor<PublicField<string>>().ToANew<PublicProperty<int>>();
+            Mapper.GetPlanFor<Customer>().ToANew<CustomerViewModel>();
+            Mapper.GetPlansFor(new MegaProduct()).To<ProductDtoMega>();
+
+            var plan = Mapper.GetPlansInCache();
+
+            plan.ShouldContain("PublicField<string> -> PublicProperty<int>");
+            plan.ShouldContain("Customer -> CustomerViewModel");
+            plan.ShouldContain("MegaProduct -> ProductDtoMega");
+            plan.ShouldContain("Rule set: CreateNew");
+            plan.ShouldContain("Rule set: Merge");
+            plan.ShouldContain("Rule set: Overwrite");
+        }
     }
 }
diff --git a/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs b/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
new file mode 100644
index 000000000..bf3aabbfc
--- /dev/null
+++ b/AgileMapper/Api/IPlanTargetTypeAndRuleSetSelector.cs
@@ -0,0 +1,47 @@
+namespace AgileObjects.AgileMapper.Api
+{
+    using Plans;
+
+    /// <summary>
+    /// Provides options to create and compile mapping functions for a particular type of mapping from the 
+    /// source type being configured to a specified target type.
+    /// </summary>
+    public interface IPlanTargetTypeAndRuleSetSelector<TSource>
+    {
+        /// <summary>
+        /// Create and compile mapping functions for a create new mapping from the source type being 
+        /// configured to the type specified by the type argument.
+        /// </summary>
+        /// <typeparam name="TResult">The type of object for which to create the mapping plan.</typeparam>
+        /// <returns>
+        /// A <see cref="MappingPlan{TSource,TTarget}"/> object detailing the function to be executed 
+        /// during a mapping. To see a string representation of the function assign the result to a string
+        /// variable, or call .ToString().
+        /// </returns>
+        MappingPlan<TSource, TResult> ToANew<TResult>();
+
+        /// <summary>
+        /// Create and compile mapping functions for an OnTo (merge) mapping from the source type being 
+        /// configured to the type specified by the type argument.
+        /// </summary>
+        /// <typeparam name="TTarget">The type of object for which to create the mapping plan.</typeparam>
+        /// <returns>
+        /// A <see cref="MappingPlan{TSource,TTarget}"/> detailing the function to be executed during a mapping. 
+        /// To see a string representation of the function, assign the result to an explitly-typed string variable, 
+        /// or call .ToString().
+        /// </returns>
+        MappingPlan<TSource, TTarget> OnTo<TTarget>();
+
+        /// <summary>
+        /// Create and compile mapping functions for an Over (overwrite) mapping from the source type being 
+        /// configured to the type specified by the type argument.
+        /// </summary>
+        /// <typeparam name="TTarget">The type of object for which to create the mapping plan.</typeparam>
+        /// <returns>
+        /// A <see cref="MappingPlan{TSource,TTarget}"/> detailing the function to be executed during a mapping. 
+        /// To see a string representation of the function, assign the result to an explitly-typed string variable, 
+        /// or call .ToString().
+        /// </returns>
+        MappingPlan<TSource, TTarget> Over<TTarget>();
+    }
+}
\ No newline at end of file
diff --git a/AgileMapper/Api/IPlanTargetTypeSelector.cs b/AgileMapper/Api/IPlanTargetTypeSelector.cs
new file mode 100644
index 000000000..86fc18d45
--- /dev/null
+++ b/AgileMapper/Api/IPlanTargetTypeSelector.cs
@@ -0,0 +1,23 @@
+namespace AgileObjects.AgileMapper.Api
+{
+    using Plans;
+
+    /// <summary>
+    /// Provides the option to create and compile mapping functions for mappings from the source type 
+    /// being configured to a specified target type, for all mapping types (create new, merge, overwrite).
+    /// </summary>
+    public interface IPlanTargetTypeSelector
+    {
+        /// <summary>
+        /// Create and compile mapping functions from the source type being configured to the type specified 
+        /// by the type argument, for all mapping types (create new, merge, overwrite).
+        /// </summary>
+        /// <typeparam name="TTarget">The type of object for which to create the mapping plans.</typeparam>
+        /// <returns>
+        /// A <see cref="MappingPlanSet"/> detailing the functions to be executed during a mapping. To see 
+        /// string representations of the functions, assign the result to an explicitly-typed string variable, 
+        /// or call .ToString().
+        /// </returns>
+        MappingPlanSet To<TTarget>();
+    }
+}
\ No newline at end of file
diff --git a/AgileMapper/Api/PlanTargetTypeSelector.cs b/AgileMapper/Api/PlanTargetTypeSelector.cs
index e8d48a16e..0e8c972bf 100644
--- a/AgileMapper/Api/PlanTargetTypeSelector.cs
+++ b/AgileMapper/Api/PlanTargetTypeSelector.cs
@@ -1,52 +1,40 @@
 namespace AgileObjects.AgileMapper.Api
 {
+    using System.Linq;
     using Plans;
 
-    /// <summary>
-    /// Provides options to create and compile mapping functions for a particular type of mapping from the 
-    /// source type being configured to a specified target type.
-    /// </summary>
-    /// <typeparam name="TSource">The source type to which the configuration should apply.</typeparam>
-    public class PlanTargetTypeSelector<TSource>
+    internal class PlanTargetTypeSelector<TSource> : IPlanTargetTypeSelector, IPlanTargetTypeAndRuleSetSelector<TSource>
     {
         private readonly MapperContext _mapperContext;
 
         internal PlanTargetTypeSelector(MapperContext mapperContext)
         {
             _mapperContext = mapperContext;
+        }
+
+        public MappingPlanSet To<TTarget>()
+        {
+            return new MappingPlanSet(
+                _mapperContext
+                    .RuleSets
+                    .All
+                    .Select(GetMappingPlan<TTarget>)
+                    .ToArray());
         }
 
-        /// <summary>
-        /// Create and compile mapping functions for a create new mapping from the source type being 
-        /// configured to the type specified by the type argument.
-        /// </summary>
-        /// <typeparam name="TResult">The type of object for which to create the mapping plans.</typeparam>
-        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
-        public string ToANew<TResult>() where TResult : class
-            => GetMappingPlan<TResult>(_mapperContext.RuleSets.CreateNew);
-
-        /// <summary>
-        /// Create and compile mapping functions for an OnTo (merge) mapping from the source type being 
-        /// configured to the type specified by the type argument.
-        /// </summary>
-        /// <typeparam name="TTarget">The type of object for which to create the mapping plans.</typeparam>
-        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
-        public string OnTo<TTarget>() where TTarget : class
-            => GetMappingPlan<TTarget>(_mapperContext.RuleSets.Merge);
-
-        /// <summary>
-        /// Create and compile mapping functions for an Over (overwrite) mapping from the source type being 
-        /// configured to the type specified by the type argument.
-        /// </summary>
-        /// <typeparam name="TTarget">The type of object for which to create the mapping plans.</typeparam>
-        /// <returns>A string mapping plan showing the functions to be executed during a mapping.</returns>
-        public string Over<TTarget>() where TTarget : class
+        public MappingPlan<TSource, TResult> ToANew<TResult>()
+            => GetMappingPlan<TResult>(_mapperContext.RuleSets.CreateNew);
+
+        public MappingPlan<TSource, TTarget> OnTo<TTarget>()
+            => GetMappingPlan<TTarget>(_mapperContext.RuleSets.Merge);
+
+        public MappingPlan<TSource, TTarget> Over<TTarget>()
             => GetMappingPlan<TTarget>(_mapperContext.RuleSets.Overwrite);
 
-        private string GetMappingPlan<TTarget>(MappingRuleSet ruleSet)
+        private MappingPlan<TSource, TTarget> GetMappingPlan<TTarget>(MappingRuleSet ruleSet)
         {
             var planContext = new MappingExecutor<TSource>(ruleSet, _mapperContext);
-
+
             return new MappingPlan<TSource, TTarget>(planContext);
         }
     }
diff --git a/AgileMapper/Caching/ArrayCache.cs b/AgileMapper/Caching/ArrayCache.cs
index cc0936d91..d93bd27c1 100644
--- a/AgileMapper/Caching/ArrayCache.cs
+++ b/AgileMapper/Caching/ArrayCache.cs
@@ -108,21 +108,6 @@ private T[] ResizeToCapacity<T>(T[] existingArray)
             return biggerArray;
         }
 
-        //public void CloneTo(ICache<TKey, TValue> otherCache)
-        //{
-        //    for (var i = 0; i < _length; i++)
-        //    {
-        //        var value = _values[i];
-
-        //        if (value is ICloneable cloneable)
-        //        {
-        //            value = (TValue)cloneable.Clone();
-        //        }
-
-        //        otherCache.GetOrAdd(_keys[i], m => value);
-        //    }
-        //}
-
         public void Empty()
         {
             for (var i = 0; i < _length; i++)
@@ -133,18 +118,5 @@ public void Empty()
 
             _length = 0;
         }
-
-        //object ICloneable.Clone()
-        //{
-        //    var cache = new ArrayCache<TKey, TValue>(Math.Max(_length, DefaultCapacity));
-
-        //    for (var i = 0; i < _length; i++)
-        //    {
-        //        cache._keys[i] = _keys[i];
-        //        cache._values[i] = _values[i];
-        //    }
-
-        //    return cache;
-        //}
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/Caching/ICache.cs b/AgileMapper/Caching/ICache.cs
index c947def62..f116d7b9d 100644
--- a/AgileMapper/Caching/ICache.cs
+++ b/AgileMapper/Caching/ICache.cs
@@ -13,7 +13,5 @@ internal interface ICache<TKey, TValue> : ICache
         IEnumerable<TValue> Values { get; }
 
         TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory);
-
-        //void CloneTo(ICache<TKey, TValue> otherCache);
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/IMapper.cs b/AgileMapper/IMapper.cs
index 9f52404eb..4a3f62a1d 100644
--- a/AgileMapper/IMapper.cs
+++ b/AgileMapper/IMapper.cs
@@ -15,16 +15,62 @@ public interface IMapper : IDisposable
         /// <returns>A cloned copy of this mapper.</returns>
         IMapper CloneSelf();
 
+        /// <summary>
+        /// Create and compile mapping functions for a particular type of mapping of the source type specified by 
+        /// the given <paramref name="exampleInstance"/>. Use this overload for anonymous types.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the given <paramref name="exampleInstance"/>.</typeparam>
+        /// <param name="exampleInstance">
+        /// An instance specifying the source type for which a mapping plan should be created.
+        /// </param>
+        /// <returns>
+        /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
+        /// should be cached.
+        /// </returns>
+        IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>(TSource exampleInstance);
+
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type
         /// specified by the type argument.
         /// </summary>
         /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
         /// <returns>
-        /// A PlanTargetTypeSelector with which to specify the type of mapping the functions for which should 
-        /// be cached.
+        /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
+        /// should be cached.
+        /// </returns>
+        IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>();
+
+        /// <summary>
+        /// Create and compile mapping functions for mapping from the source type specified by the given 
+        /// <paramref name="exampleInstance"/>, for all mapping types (create new, merge, overwrite). Use this 
+        /// overload for anonymous types.
+        /// </summary>
+        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
+        /// <param name="exampleInstance">
+        /// An instance specifying the source type for which a mapping plan should be created.
+        /// </param>
+        /// <returns>
+        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
+        /// should be cached.
+        /// </returns>
+        IPlanTargetTypeSelector GetPlansFor<TSource>(TSource exampleInstance);
+
+        /// <summary>
+        /// Create and compile mapping functions for the source type specified by the type argument, for all
+        /// mapping types (create new, merge, overwrite).
+        /// </summary>
+        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
+        /// <returns>
+        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
+        /// should be cached.
         /// </returns>
-        PlanTargetTypeSelector<TSource> GetPlanFor<TSource>();
+        IPlanTargetTypeSelector GetPlansFor<TSource>();
+
+        /// <summary>
+        /// Returns mapping plans for all mapping functions currently cached by the <see cref="IMapper"/>.
+        /// </summary>
+        /// <returns>A string containing the currently-cached functions to be executed during mappings.</returns>
+        string GetPlansInCache();
 
         /// <summary>
         /// Configure callbacks to be executed before a particular type of event occurs for all source
diff --git a/AgileMapper/Mapper.cs b/AgileMapper/Mapper.cs
index d258f4d18..68563185a 100644
--- a/AgileMapper/Mapper.cs
+++ b/AgileMapper/Mapper.cs
@@ -2,6 +2,7 @@
 {
     using Api;
     using Api.Configuration;
+    using Plans;
 
     /// <summary>
     /// Provides a configurable mapping service. Create new instances with Mapper.CreateNew or use the default
@@ -28,7 +29,17 @@ private Mapper(MapperContext mapperContext)
 
         #endregion
 
-        PlanTargetTypeSelector<TSource> IMapper.GetPlanFor<TSource>()
+        IPlanTargetTypeAndRuleSetSelector<TSource> IMapper.GetPlanFor<TSource>(TSource exampleInstance) => GetPlan<TSource>();
+
+        IPlanTargetTypeAndRuleSetSelector<TSource> IMapper.GetPlanFor<TSource>() => GetPlan<TSource>();
+
+        IPlanTargetTypeSelector IMapper.GetPlansFor<TSource>(TSource exampleInstance) => GetPlan<TSource>();
+
+        IPlanTargetTypeSelector IMapper.GetPlansFor<TSource>() => GetPlan<TSource>();
+
+        string IMapper.GetPlansInCache() => MappingPlanSet.For(_mapperContext);
+
+        private PlanTargetTypeSelector<TSource> GetPlan<TSource>()
             => new PlanTargetTypeSelector<TSource>(_mapperContext);
 
         PreEventConfigStartingPoint IMapper.Before => new PreEventConfigStartingPoint(_mapperContext);
@@ -37,16 +48,62 @@ PlanTargetTypeSelector<TSource> IMapper.GetPlanFor<TSource>()
 
         #region Static Access Methods
 
+        /// <summary>
+        /// Create and compile mapping functions for a particular type of mapping of the source type specified by 
+        /// the given <paramref name="exampleInstance"/>. Use this overload for anonymous types.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the given <paramref name="exampleInstance"/>.</typeparam>
+        /// <param name="exampleInstance">
+        /// An instance specifying the source type for which a mapping plan should be created.
+        /// </param>
+        /// <returns>
+        /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
+        /// should be cached.
+        /// </returns>
+        public static IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>(TSource exampleInstance) => GetPlanFor<TSource>();
+
         /// <summary>
         /// Create and compile mapping functions for a particular type of mapping of the source type
         /// specified by the type argument.
         /// </summary>
         /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
         /// <returns>
-        /// A PlanTargetTypeSelector with which to specify the type of mapping the functions for which should 
-        /// be cached.
+        /// An IPlanTargetTypeAndRuleSetSelector with which to specify the type of mapping the functions for which 
+        /// should be cached.
         /// </returns>
-        public static PlanTargetTypeSelector<TSource> GetPlanFor<TSource>() => _default.GetPlanFor<TSource>();
+        public static IPlanTargetTypeAndRuleSetSelector<TSource> GetPlanFor<TSource>() => _default.GetPlanFor<TSource>();
+
+        /// <summary>
+        /// Create and compile mapping functions for mapping from the source type specified by the given 
+        /// <paramref name="exampleInstance"/>, for all mapping types (create new, merge, overwrite). Use this 
+        /// overload for anonymous types.
+        /// </summary>
+        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
+        /// <param name="exampleInstance">
+        /// An instance specifying the source type for which a mapping plan should be created.
+        /// </param>
+        /// <returns>
+        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
+        /// should be cached.
+        /// </returns>
+        public static IPlanTargetTypeSelector GetPlansFor<TSource>(TSource exampleInstance) => GetPlansFor<TSource>();
+
+        /// <summary>
+        /// Create and compile mapping functions for the source type specified by the type argument, for all
+        /// mapping types (create new, merge, overwrite).
+        /// </summary>
+        /// <typeparam name="TSource">The source type for which to create the mapping functions.</typeparam>
+        /// <returns>
+        /// An IPlanTargetTypeSelector with which to specify the target type the mapping functions for which 
+        /// should be cached.
+        /// </returns>
+        public static IPlanTargetTypeSelector GetPlansFor<TSource>() => _default.GetPlansFor<TSource>();
+
+        /// <summary>
+        /// Returns mapping plans for all mapping functions currently cached by the default <see cref="IMapper"/>.
+        /// </summary>
+        /// <returns>A string containing the currently-cached functions to be executed during mappings.</returns>
+        public static string GetPlansInCache() => _default.GetPlansInCache();
 
         /// <summary>
         /// Configure callbacks to be executed before a particular type of event occurs for all source
diff --git a/AgileMapper/MappingExecutor.cs b/AgileMapper/MappingExecutor.cs
index 460d81d6b..177c6f132 100644
--- a/AgileMapper/MappingExecutor.cs
+++ b/AgileMapper/MappingExecutor.cs
@@ -68,7 +68,7 @@ private ObjectMappingData<TSource, TTarget> CreateTypedRootMappingData<TTarget>(
                 _source,
                 target,
                 null, // <- No enumerable index because we're at the root
-                new RootObjectMapperKey(MappingTypes.Fixed<TSource, TTarget>(), this),
+                new RootObjectMapperKey(MappingTypes<TSource, TTarget>.Fixed, this),
                 this,
                 parent: null);
         }
diff --git a/AgileMapper/MappingRuleSetCollection.cs b/AgileMapper/MappingRuleSetCollection.cs
index f9e53f80c..47d619d01 100644
--- a/AgileMapper/MappingRuleSetCollection.cs
+++ b/AgileMapper/MappingRuleSetCollection.cs
@@ -40,6 +40,8 @@ public MappingRuleSetCollection()
             _ruleSets = new List<MappingRuleSet> { CreateNew, Merge, Overwrite };
         }
 
+        public IEnumerable<MappingRuleSet> All => _ruleSets;
+
         public MappingRuleSet CreateNew => _createNew;
 
         public MappingRuleSet Merge => _merge;
diff --git a/AgileMapper/Members/MappingTypes.cs b/AgileMapper/Members/MappingTypes.cs
index c3982fd71..22d226a50 100644
--- a/AgileMapper/Members/MappingTypes.cs
+++ b/AgileMapper/Members/MappingTypes.cs
@@ -6,7 +6,7 @@ namespace AgileObjects.AgileMapper.Members
 
     internal class MappingTypes
     {
-        private MappingTypes(
+        public MappingTypes(
             Type sourceType,
             Type targetType,
             bool runtimeTypesAreTheSame,
@@ -20,13 +20,11 @@ private MappingTypes(
 
         #region Factory Method
 
-        public static MappingTypes Fixed<TSource, TTarget>() => MappingTypesCache<TSource, TTarget>.Instance;
-
         public static MappingTypes For<TSource, TTarget>(TSource source, TTarget target)
         {
-            if (MappingTypesCache<TSource, TTarget>.SkipTypesCheck)
+            if (MappingTypes<TSource, TTarget>.SkipTypesCheck)
             {
-                return Fixed<TSource, TTarget>();
+                return MappingTypes<TSource, TTarget>.Fixed;
             }
 
             var runtimeSourceTypeNeeded = TypeInfo<TSource>.RuntimeTypeNeeded;
@@ -78,7 +76,7 @@ public static MappingTypes For<TSource, TTarget>(TSource source, TTarget target)
 
             if (!runtimeTypesNeeded)
             {
-                return Fixed<TSource, TTarget>();
+                return MappingTypes<TSource, TTarget>.Fixed;
             }
 
             var isEnumerable = TypeInfo<TTarget>.IsEnumerable ||
@@ -121,17 +119,17 @@ public MappingTypes WithTypes<TNewSource, TNewTarget>()
                 RuntimeTypesAreTheSame,
                 IsEnumerable);
         }
+    }
 
-        private static class MappingTypesCache<TSource, TTarget>
-        {
-            public static readonly bool SkipTypesCheck =
-                !(TypeInfo<TSource>.RuntimeTypeNeeded || TypeInfo<TTarget>.RuntimeTypeNeeded);
-
-            public static readonly MappingTypes Instance = new MappingTypes(
-                typeof(TSource),
-                typeof(TTarget),
-                true, // <- runtimeTypesAreTheSame
-                TypeInfo<TTarget>.IsEnumerable);
-        }
+    internal static class MappingTypes<TSource, TTarget>
+    {
+        public static readonly bool SkipTypesCheck =
+            !(TypeInfo<TSource>.RuntimeTypeNeeded || TypeInfo<TTarget>.RuntimeTypeNeeded);
+
+        public static readonly MappingTypes Fixed = new MappingTypes(
+            typeof(TSource),
+            typeof(TTarget),
+            true, // <- runtimeTypesAreTheSame
+            TypeInfo<TTarget>.IsEnumerable);
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/Members/MemberExtensions.cs b/AgileMapper/Members/MemberExtensions.cs
index a85a27a62..b07f347cf 100644
--- a/AgileMapper/Members/MemberExtensions.cs
+++ b/AgileMapper/Members/MemberExtensions.cs
@@ -92,7 +92,7 @@ public static bool IsUnmappable(this QualifiedMember member, out string reason)
                 member.Type.IsGenericType() &&
                (member.Type.GetGenericTypeDefinition() == typeof(ReadOnlyCollection<>)))
             {
-                reason = "readonly ReadOnlyCollection";
+                reason = "readonly " + member.Type.GetFriendlyName();
                 return true;
             }
 
diff --git a/AgileMapper/ObjectPopulation/IObjectMapper.cs b/AgileMapper/ObjectPopulation/IObjectMapper.cs
index 3a44f8ccb..14c9bcf7e 100644
--- a/AgileMapper/ObjectPopulation/IObjectMapper.cs
+++ b/AgileMapper/ObjectPopulation/IObjectMapper.cs
@@ -1,5 +1,6 @@
 namespace AgileObjects.AgileMapper.ObjectPopulation
 {
+    using System.Collections.Generic;
     using System.Linq.Expressions;
 
     internal interface IObjectMapper : IObjectMapperFunc
@@ -9,5 +10,7 @@ internal interface IObjectMapper : IObjectMapperFunc
         LambdaExpression MappingLambda { get; }
 
         ObjectMapperData MapperData { get; }
+
+        IEnumerable<IObjectMapper> SubMappers { get; }
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/ObjectPopulation/MappingDataFactory.cs b/AgileMapper/ObjectPopulation/MappingDataFactory.cs
index a90474b89..633ce04fd 100644
--- a/AgileMapper/ObjectPopulation/MappingDataFactory.cs
+++ b/AgileMapper/ObjectPopulation/MappingDataFactory.cs
@@ -25,7 +25,7 @@ public static ObjectMappingData<TSource, TTarget> ForChild<TSource, TTarget>(
             var mapperKey = new ChildObjectMapperKey(
                 targetMemberRegistrationName,
                 dataSourceIndex,
-                MappingTypes.Fixed<TSource, TTarget>());
+                MappingTypes<TSource, TTarget>.Fixed);
 
             var mappingData = CreateMappingData(source, target, enumerableIndex, mapperKey, parent);
 
@@ -53,7 +53,7 @@ public static ObjectMappingData<TSourceElement, TTargetElement> ForElement<TSour
             int enumerableIndex,
             IObjectMappingDataUntyped parent)
         {
-            var mapperKey = new ElementObjectMapperKey(MappingTypes.Fixed<TSourceElement, TTargetElement>());
+            var mapperKey = new ElementObjectMapperKey(MappingTypes<TSourceElement, TTargetElement>.Fixed);
 
             var mappingData = CreateMappingData(sourceElement, targetElement, enumerableIndex, mapperKey, parent);
 
diff --git a/AgileMapper/ObjectPopulation/ObjectMapper.cs b/AgileMapper/ObjectPopulation/ObjectMapper.cs
index 5362dd3b2..f653ff460 100644
--- a/AgileMapper/ObjectPopulation/ObjectMapper.cs
+++ b/AgileMapper/ObjectPopulation/ObjectMapper.cs
@@ -1,6 +1,7 @@
 namespace AgileObjects.AgileMapper.ObjectPopulation
 {
     using System;
+    using System.Collections.Generic;
     using System.Linq.Expressions;
 #if NET_STANDARD
     using System.Reflection;
@@ -84,6 +85,8 @@ private ICache<ObjectMapperKeyBase, IObjectMapperFunc> CreateRecursionMapperFunc
 
         public ObjectMapperData MapperData { get; }
 
+        public IEnumerable<IObjectMapper> SubMappers => _subMappersByKey?.Values ?? Enumerable<IObjectMapper>.Empty;
+
         public object Map(IObjectMappingData mappingData) => Map((ObjectMappingData<TSource, TTarget>)mappingData);
 
         public TTarget Map(ObjectMappingData<TSource, TTarget> mappingData) => _mapperFunc.Invoke(mappingData);
diff --git a/AgileMapper/ObjectPopulation/ObjectMapperFactory.cs b/AgileMapper/ObjectPopulation/ObjectMapperFactory.cs
index 75783cecb..9f1650c7c 100644
--- a/AgileMapper/ObjectPopulation/ObjectMapperFactory.cs
+++ b/AgileMapper/ObjectPopulation/ObjectMapperFactory.cs
@@ -25,6 +25,8 @@ public ObjectMapperFactory(MapperContext mapperContext)
             _rootMappersCache = mapperContext.Cache.CreateScoped<ObjectMapperKeyBase, IObjectMapper>();
         }
 
+        public IEnumerable<IObjectMapper> RootMappers => _rootMappersCache.Values;
+
         public ObjectMapper<TSource, TTarget> GetOrCreateRoot<TSource, TTarget>(ObjectMappingData<TSource, TTarget> mappingData)
         {
             mappingData.MapperKey.MappingData = mappingData;
diff --git a/AgileMapper/Plans/CachedMapperMappingPlan.cs b/AgileMapper/Plans/CachedMapperMappingPlan.cs
new file mode 100644
index 000000000..2b4976088
--- /dev/null
+++ b/AgileMapper/Plans/CachedMapperMappingPlan.cs
@@ -0,0 +1,46 @@
+namespace AgileObjects.AgileMapper.Plans
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using ObjectPopulation;
+
+    internal class CachedMapperMappingPlan : IMappingPlan
+    {
+        private readonly List<IObjectMapper> _cachedMappers;
+
+        public CachedMapperMappingPlan(IObjectMapper mapper)
+        {
+            _cachedMappers = new List<IObjectMapper>();
+
+            Expand(mapper);
+        }
+
+        private void Expand(IObjectMapper mapper)
+        {
+            _cachedMappers.Add(mapper);
+
+            foreach (var subMapper in mapper.SubMappers)
+            {
+                Expand(subMapper);
+            }
+        }
+
+        /// <summary>
+        /// Converts the given <paramref name="mappingPlan"/> to its string representation.
+        /// </summary>
+        /// <param name="mappingPlan">The <see cref="CachedMapperMappingPlan"/> to convert.</param>
+        /// <returns>The string representation of the given <paramref name="mappingPlan"/>.</returns>
+        public static implicit operator string(CachedMapperMappingPlan mappingPlan)
+        {
+            return string.Join(
+                Environment.NewLine + Environment.NewLine,
+                mappingPlan._cachedMappers.Select(GetDescription));
+        }
+
+        private static string GetDescription(IObjectMapper mapper)
+            => MappingPlanFunction.For(mapper.MappingLambda, mapper.MapperData);
+
+        public override string ToString() => this;
+    }
+}
\ No newline at end of file
diff --git a/AgileMapper/Plans/EnumMappingMismatchFinder.cs b/AgileMapper/Plans/EnumMappingMismatchFinder.cs
index cb10acb50..b7640abbb 100644
--- a/AgileMapper/Plans/EnumMappingMismatchFinder.cs
+++ b/AgileMapper/Plans/EnumMappingMismatchFinder.cs
@@ -25,18 +25,16 @@ private EnumMappingMismatchFinder(
             _assignmentReplacements = new Dictionary<Expression, Expression>();
         }
 
-        public static Expression Process(Expression lambda, IObjectMappingData mappingData)
+        public static Expression Process(Expression lambda, ObjectMapperData mapperData)
         {
-            var targetMemberDatas = GetAllTargetMemberDatas(mappingData);
+            var targetMemberDatas = GetAllTargetMemberDatas(mapperData);
 
             if (targetMemberDatas.None())
             {
                 return lambda;
             }
 
-            var finder = new EnumMappingMismatchFinder(
-                mappingData.MapperData,
-                targetMemberDatas);
+            var finder = new EnumMappingMismatchFinder(mapperData, targetMemberDatas);
 
             finder.Visit(lambda);
 
@@ -45,8 +43,8 @@ public static Expression Process(Expression lambda, IObjectMappingData mappingDa
             return updatedLambda;
         }
 
-        private static TargetMemberData[] GetAllTargetMemberDatas(IObjectMappingData mappingData)
-            => EnumerateTargetMemberDatas(mappingData.MapperData).ToArray();
+        private static TargetMemberData[] GetAllTargetMemberDatas(ObjectMapperData mapperData)
+            => EnumerateTargetMemberDatas(mapperData).ToArray();
 
         private static IEnumerable<TargetMemberData> EnumerateTargetMemberDatas(ObjectMapperData mapperData)
         {
diff --git a/AgileMapper/Plans/IMappingPlan.cs b/AgileMapper/Plans/IMappingPlan.cs
new file mode 100644
index 000000000..a3c1660b2
--- /dev/null
+++ b/AgileMapper/Plans/IMappingPlan.cs
@@ -0,0 +1,6 @@
+namespace AgileObjects.AgileMapper.Plans
+{
+    internal interface IMappingPlan
+    {
+    }
+}
\ No newline at end of file
diff --git a/AgileMapper/Plans/MappingPlan.cs b/AgileMapper/Plans/MappingPlan.cs
index 958ec8341..066f1c3f1 100644
--- a/AgileMapper/Plans/MappingPlan.cs
+++ b/AgileMapper/Plans/MappingPlan.cs
@@ -7,11 +7,23 @@
     using ObjectPopulation;
     using NetStandardPolyfills;
 
-    internal class MappingPlan<TSource, TTarget>
+    /// <summary>
+    /// Contains details of the mapping plan for a mapping between a particular source and target type,
+    /// for a particular mapping type (create new, merge, overwrite).
+    /// </summary>
+    /// <typeparam name="TSource">
+    /// The type of source object from which the mapping described by the
+    /// <see cref="MappingPlan{TSource,TTarget}"/> is performed.
+    /// </typeparam>
+    /// <typeparam name="TTarget">
+    /// The type of target object to which the mapping described by the
+    /// <see cref="MappingPlan{TSource,TTarget}"/> is performed.
+    /// </typeparam>
+    public class MappingPlan<TSource, TTarget> : IMappingPlan
     {
         private readonly List<MappingPlanData> _generatedPlanData;
 
-        public MappingPlan(IMappingContext mappingContext)
+        internal MappingPlan(IMappingContext mappingContext)
         {
             _generatedPlanData = new List<MappingPlanData>();
 
@@ -53,6 +65,11 @@ private void Expand(MappingPlanData planData)
 
         private static bool IsObjectMemberMapping(MethodCallExpression mapCall) => mapCall.Arguments.Count == 4;
 
+        /// <summary>
+        /// Converts the given <paramref name="mappingPlan"/> to its string representation.
+        /// </summary>
+        /// <param name="mappingPlan">The <see cref="MappingPlan{TSource,TTarget}"/> to convert.</param>
+        /// <returns>The string representation of the given <paramref name="mappingPlan"/>.</returns>
         public static implicit operator string(MappingPlan<TSource, TTarget> mappingPlan)
         {
             return string.Join(
@@ -96,5 +113,11 @@ private static bool IsMapCall(MethodCallExpression methodCall)
                        (methodCall.Object.Type.GetGenericTypeDefinition() == typeof(IObjectMappingData<,>));
             }
         }
+
+        /// <summary>
+        /// Returns the string representation of the <see cref="MappingPlan{TSource,TTarget}"/>.
+        /// </summary>
+        /// <returns>The string representation of the <see cref="MappingPlan{TSource,TTarget}"/>.</returns>
+        public override string ToString() => this;
     }
 }
diff --git a/AgileMapper/Plans/MappingPlanData.cs b/AgileMapper/Plans/MappingPlanData.cs
index 712f478dd..c477367b0 100644
--- a/AgileMapper/Plans/MappingPlanData.cs
+++ b/AgileMapper/Plans/MappingPlanData.cs
@@ -11,8 +11,6 @@
     using Extensions;
     using Members;
     using ObjectPopulation;
-    using ReadableExpressions;
-    using ReadableExpressions.Extensions;
 
     internal class MappingPlanData
     {
@@ -128,29 +126,6 @@ public override bool Equals(object obj)
         #endregion
         public override int GetHashCode() => 0;
 
-        public string GetDescription()
-        {
-            var lambda = GetFinalMappingLambda();
-
-            var sourceType = _mappingTypes.SourceType.GetFriendlyName();
-            var targetType = _mappingTypes.TargetType.GetFriendlyName();
-
-            return $@"
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-// Map {sourceType} -> {targetType}
-// Rule Set: {_mappingData.MappingContext.RuleSet.Name}
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-
-{lambda.ToReadableString()}".TrimStart();
-        }
-
-        private Expression GetFinalMappingLambda()
-        {
-            var lambdaWithEnumMismatches = EnumMappingMismatchFinder.Process(Lambda, _mappingData);
-
-            return lambdaWithEnumMismatches;
-        }
+        public string GetDescription() => MappingPlanFunction.For(Lambda, _mappingData.MapperData);
     }
 }
\ No newline at end of file
diff --git a/AgileMapper/Plans/MappingPlanFunction.cs b/AgileMapper/Plans/MappingPlanFunction.cs
new file mode 100644
index 000000000..c591305c8
--- /dev/null
+++ b/AgileMapper/Plans/MappingPlanFunction.cs
@@ -0,0 +1,35 @@
+namespace AgileObjects.AgileMapper.Plans
+{
+    using System.Linq.Expressions;
+    using ObjectPopulation;
+    using ReadableExpressions;
+    using ReadableExpressions.Extensions;
+
+    internal static class MappingPlanFunction
+    {
+        public static string For(Expression lambda, ObjectMapperData mapperData)
+        {
+            lambda = GetFinalMappingLambda(lambda, mapperData);
+
+            var sourceType = mapperData.SourceType.GetFriendlyName();
+            var targetType = mapperData.TargetType.GetFriendlyName();
+
+            return $@"
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+// Map {sourceType} -> {targetType}
+// Rule Set: {mapperData.RuleSet.Name}
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+
+{lambda.ToReadableString()}".TrimStart();
+        }
+
+        private static Expression GetFinalMappingLambda(Expression lambda, ObjectMapperData mapperData)
+        {
+            var lambdaWithEnumMismatches = EnumMappingMismatchFinder.Process(lambda, mapperData);
+
+            return lambdaWithEnumMismatches;
+        }
+    }
+}
\ No newline at end of file
diff --git a/AgileMapper/Plans/MappingPlanSet.cs b/AgileMapper/Plans/MappingPlanSet.cs
new file mode 100644
index 000000000..1d64ca902
--- /dev/null
+++ b/AgileMapper/Plans/MappingPlanSet.cs
@@ -0,0 +1,50 @@
+namespace AgileObjects.AgileMapper.Plans
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    /// <summary>
+    /// Contains sets of details of mapping plans for mappings between a particular source and target types,
+    /// for particular mapping types (create new, merge, overwrite).
+    /// </summary>
+    public class MappingPlanSet
+    {
+        private readonly IEnumerable<IMappingPlan> _mappingPlans;
+
+        internal MappingPlanSet(IEnumerable<IMappingPlan> mappingPlans)
+        {
+            _mappingPlans = mappingPlans;
+        }
+
+        internal static MappingPlanSet For(MapperContext mapperContext)
+        {
+            return new MappingPlanSet(mapperContext
+                .ObjectMapperFactory
+                .RootMappers
+                .Select(mapper => new CachedMapperMappingPlan(mapper))
+                .ToArray());
+        }
+
+        /// <summary>
+        /// Converts the given <paramref name="mappingPlans">MappingPlanSet</paramref> to its string 
+        /// representation.
+        /// </summary>
+        /// <param name="mappingPlans">The <see cref="MappingPlan{TSource,TTarget}"/> to convert.</param>
+        /// <returns>
+        /// The string representation of the <paramref name="mappingPlans">MappingPlanSet</paramref>.
+        /// </returns>
+        public static implicit operator string(MappingPlanSet mappingPlans)
+        {
+            return string.Join(
+                Environment.NewLine + Environment.NewLine,
+                mappingPlans._mappingPlans.Select(plan => plan.ToString()));
+        }
+
+        /// <summary>
+        /// Returns the string representation of the <see cref="MappingPlanSet"/>.
+        /// </summary>
+        /// <returns>The string representation of the <see cref="MappingPlanSet"/>.</returns>
+        public override string ToString() => this;
+    }
+}
\ No newline at end of file