diff --git a/BitFaster.Caching.Benchmarks/Lru/LruAsyncGet.cs b/BitFaster.Caching.Benchmarks/Lru/LruAsyncGet.cs
index 02742ee1..50677f18 100644
--- a/BitFaster.Caching.Benchmarks/Lru/LruAsyncGet.cs
+++ b/BitFaster.Caching.Benchmarks/Lru/LruAsyncGet.cs
@@ -20,7 +20,7 @@ public class LruAsyncGet
     {
         // if the cache value is a value type, value task has no effect - so use string to repro.
         private static readonly IAsyncCache<int, string> concurrentLru = new ConcurrentLruBuilder<int, string>().AsAsyncCache().Build();
-        private static readonly IAsyncCache<int, string> atomicConcurrentLru = new ConcurrentLruBuilder<int, string>().AsAsyncCache().WithAtomicCreate().Build();
+        private static readonly IAsyncCache<int, string> atomicConcurrentLru = new ConcurrentLruBuilder<int, string>().AsAsyncCache().WithAtomicValueFactory().Build();
 
         private static Task<string> returnTask = Task.FromResult("1");
 
diff --git a/BitFaster.Caching.Benchmarks/Lru/LruJustGetOrAdd.cs b/BitFaster.Caching.Benchmarks/Lru/LruJustGetOrAdd.cs
index d7a90a91..7d71d992 100644
--- a/BitFaster.Caching.Benchmarks/Lru/LruJustGetOrAdd.cs
+++ b/BitFaster.Caching.Benchmarks/Lru/LruJustGetOrAdd.cs
@@ -44,7 +44,7 @@ public class LruJustGetOrAdd
         private static readonly FastConcurrentLru<int, int> fastConcurrentLru = new FastConcurrentLru<int, int>(8, 9, EqualityComparer<int>.Default);
         private static readonly FastConcurrentTLru<int, int> fastConcurrentTLru = new FastConcurrentTLru<int, int>(8, 9, EqualityComparer<int>.Default, TimeSpan.FromMinutes(1));
 
-        private static readonly ICache<int, int> atomicFastLru = new ConcurrentLruBuilder<int, int>().WithConcurrencyLevel(8).WithCapacity(9).WithAtomicCreate().Build();
+        private static readonly ICache<int, int> atomicFastLru = new ConcurrentLruBuilder<int, int>().WithConcurrencyLevel(8).WithCapacity(9).WithAtomicValueFactory().Build();
 
         private static readonly int key = 1;
         private static System.Runtime.Caching.MemoryCache memoryCache = System.Runtime.Caching.MemoryCache.Default;
diff --git a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs
index 9ffa9a59..c8920345 100644
--- a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs
+++ b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs
@@ -196,7 +196,7 @@ public void TestPartitionCapacity()
         public void WithScopedValues()
         {
             IScopedCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
-                .WithScopedValues()
+                .AsScopedCache()
                 .WithCapacity(3)
                 .Build();
 
@@ -209,7 +209,7 @@ public void WithScopedValues()
         public void WithAtomicFactory()
         {
             ICache<int, int> lru = new ConcurrentLruBuilder<int, int>()
-                .WithAtomicCreate()
+                .WithAtomicValueFactory()
                 .WithCapacity(3)
                 .Build();
 
@@ -233,8 +233,8 @@ public void AsAsync()
         public void WithAtomicWithScope()
         {
             IScopedCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
-                .WithAtomicCreate()
-                .WithScopedValues()
+                .WithAtomicValueFactory()
+                .AsScopedCache()
                 .WithCapacity(3)
                 .Build();
 
@@ -247,8 +247,8 @@ public void WithAtomicWithScope()
         public void WithScopedWithAtomic()
         {
             IScopedCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
-                .WithScopedValues()
-                .WithAtomicCreate()
+                .AsScopedCache()
+                .WithAtomicValueFactory()
                 .WithCapacity(3)
                 .Build();
 
@@ -262,7 +262,7 @@ public void AsAsyncWithScoped()
         {
             IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
                 .AsAsyncCache()
-                .WithScopedValues()
+                .AsScopedCache()
                 .WithCapacity(3)
                 .Build();
 
@@ -276,7 +276,7 @@ public void AsAsyncWithScoped()
         public void WithScopedAsAsync()
         {
             IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
-                .WithScopedValues()
+                .AsScopedCache()
                 .AsAsyncCache()           
                 .WithCapacity(3)
                 .Build();
@@ -290,7 +290,7 @@ public void WithScopedAsAsync()
         public void WithAtomicAsAsync()
         {
             IAsyncCache<int, int> lru = new ConcurrentLruBuilder<int, int>()
-                .WithAtomicCreate()
+                .WithAtomicValueFactory()
                 .AsAsyncCache()
                 .WithCapacity(3)
                 .Build();
@@ -304,7 +304,7 @@ public void AsAsyncWithAtomic()
         {
             IAsyncCache<int, int> lru = new ConcurrentLruBuilder<int, int>()
                 .AsAsyncCache()
-                .WithAtomicCreate()
+                .WithAtomicValueFactory()
                 .WithCapacity(3)
                 .Build();
 
@@ -315,11 +315,9 @@ public void AsAsyncWithAtomic()
         [Fact]
         public void WithAtomicWithScopedAsAsync()
         {
-            // TODO: this will not resolve a TLru
-
             IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
-                .WithAtomicCreate()
-                .WithScopedValues()
+                .WithAtomicValueFactory()
+                .AsScopedCache()
                 .AsAsyncCache()
                 .WithCapacity(3)
                 .Build();
@@ -331,12 +329,10 @@ public void WithAtomicWithScopedAsAsync()
         [Fact]
         public void WithAtomicAsAsyncWithScoped()
         {
-            // TODO: this will not resolve a TLru
-
             IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
-                .WithAtomicCreate()
+                .WithAtomicValueFactory()
                 .AsAsyncCache()
-                .WithScopedValues()
+                .AsScopedCache()
                 .WithCapacity(3)
                 .Build();
 
@@ -347,11 +343,9 @@ public void WithAtomicAsAsyncWithScoped()
         [Fact]
         public void WithScopedWithAtomicAsAsync()
         {
-            // TODO: this will not resolve a TLru
-
             IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
-                .WithScopedValues()
-                .WithAtomicCreate()
+                .AsScopedCache()
+                .WithAtomicValueFactory()
                 .AsAsyncCache()
                 .WithCapacity(3)
                 .Build();
@@ -363,12 +357,10 @@ public void WithScopedWithAtomicAsAsync()
         [Fact]
         public void WithScopedAsAsyncWithAtomic()
         {
-            // TODO: this will not resolve a TLru
-
             IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
-                .WithScopedValues()
+                .AsScopedCache()
                 .AsAsyncCache()
-                .WithAtomicCreate()
+                .WithAtomicValueFactory()
                 .WithCapacity(3)
                 .Build();
 
@@ -379,12 +371,10 @@ public void WithScopedAsAsyncWithAtomic()
         [Fact]
         public void AsAsyncWithScopedWithAtomic()
         {
-            // TODO: this will not resolve a TLru
-
             IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
                 .AsAsyncCache()
-                .WithScopedValues()
-                .WithAtomicCreate()
+                .AsScopedCache()
+                .WithAtomicValueFactory()
                 .WithCapacity(3)
                 .Build();
 
@@ -395,12 +385,10 @@ public void AsAsyncWithScopedWithAtomic()
         [Fact]
         public void AsAsyncWithAtomicWithScoped()
         {
-            // TODO: this will not resolve a TLru
-
             IScopedAsyncCache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
                 .AsAsyncCache()
-                .WithAtomicCreate()
-                .WithScopedValues()
+                .WithAtomicValueFactory()
+                .AsScopedCache()
                 .WithCapacity(3)
                 .Build();
 
diff --git a/BitFaster.Caching/Lru/Builder/AsyncAtomicLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs
similarity index 69%
rename from BitFaster.Caching/Lru/Builder/AsyncAtomicLruBuilder.cs
rename to BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs
index f92c26c6..601400e3 100644
--- a/BitFaster.Caching/Lru/Builder/AsyncAtomicLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicAsyncConcurrentLruBuilder.cs
@@ -7,11 +7,11 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
-    public class AsyncAtomicLruBuilder<K, V> : LruBuilderBase<K, V, AsyncAtomicLruBuilder<K, V>, IAsyncCache<K, V>>
+    public class AtomicAsyncConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, AtomicAsyncConcurrentLruBuilder<K, V>, IAsyncCache<K, V>>
     {
         private readonly ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>> inner;
 
-        internal AsyncAtomicLruBuilder(ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>> inner)
+        internal AtomicAsyncConcurrentLruBuilder(ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>> inner)
             : base(inner.info)
         {
             this.inner = inner;
diff --git a/BitFaster.Caching/Lru/Builder/AtomicLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs
similarity index 71%
rename from BitFaster.Caching/Lru/Builder/AtomicLruBuilder.cs
rename to BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs
index cc1940b5..e1b1050e 100644
--- a/BitFaster.Caching/Lru/Builder/AtomicLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicConcurrentLruBuilder.cs
@@ -7,11 +7,11 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
-    public class AtomicLruBuilder<K, V> : LruBuilderBase<K, V, AtomicLruBuilder<K, V>, ICache<K, V>>
+    public class AtomicConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, AtomicConcurrentLruBuilder<K, V>, ICache<K, V>>
     {
         private readonly ConcurrentLruBuilder<K, AtomicFactory<K, V>> inner;
 
-        internal AtomicLruBuilder(ConcurrentLruBuilder<K, AtomicFactory<K, V>> inner)
+        internal AtomicConcurrentLruBuilder(ConcurrentLruBuilder<K, AtomicFactory<K, V>> inner)
             : base(inner.info)
         {
             this.inner = inner;
diff --git a/BitFaster.Caching/Lru/Builder/ScopedAsyncAtomicLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicScopedAsyncConcurrentLruBuilder.cs
similarity index 70%
rename from BitFaster.Caching/Lru/Builder/ScopedAsyncAtomicLruBuilder.cs
rename to BitFaster.Caching/Lru/Builder/AtomicScopedAsyncConcurrentLruBuilder.cs
index 8553f91f..316792df 100644
--- a/BitFaster.Caching/Lru/Builder/ScopedAsyncAtomicLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicScopedAsyncConcurrentLruBuilder.cs
@@ -7,11 +7,11 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
-    public sealed class ScopedAsyncAtomicLruBuilder<K, V> : LruBuilderBase<K, V, ScopedAsyncAtomicLruBuilder<K, V>, IScopedAsyncCache<K, V>> where V : IDisposable
+    public sealed class AtomicScopedAsyncConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, AtomicScopedAsyncConcurrentLruBuilder<K, V>, IScopedAsyncCache<K, V>> where V : IDisposable
     {
         private readonly AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>> inner;
 
-        internal ScopedAsyncAtomicLruBuilder(AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>> inner)
+        internal AtomicScopedAsyncConcurrentLruBuilder(AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>> inner)
             : base(inner.info)
         {
             this.inner = inner;
diff --git a/BitFaster.Caching/Lru/Builder/ScopedAtomicLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs
similarity index 68%
rename from BitFaster.Caching/Lru/Builder/ScopedAtomicLruBuilder.cs
rename to BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs
index 25b15daf..dd89bbc4 100644
--- a/BitFaster.Caching/Lru/Builder/ScopedAtomicLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/AtomicScopedConcurrentLruBuilder.cs
@@ -7,11 +7,11 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
-    public class ScopedAtomicLruBuilder<K, V> : LruBuilderBase<K, V, ScopedAtomicLruBuilder<K, V>, IScopedCache<K, V>> where V : IDisposable
+    public class AtomicScopedConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, AtomicScopedConcurrentLruBuilder<K, V>, IScopedCache<K, V>> where V : IDisposable
     {
         private readonly ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>> inner;
 
-        internal ScopedAtomicLruBuilder(ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>> inner)
+        internal AtomicScopedConcurrentLruBuilder(ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>> inner)
             : base(inner.info)
         {
             this.inner = inner;
diff --git a/BitFaster.Caching/Lru/Builder/ScopedAsyncLruBuilder.cs b/BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs
similarity index 71%
rename from BitFaster.Caching/Lru/Builder/ScopedAsyncLruBuilder.cs
rename to BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs
index 2b280728..f1952876 100644
--- a/BitFaster.Caching/Lru/Builder/ScopedAsyncLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/ScopedAsyncConcurrentLruBuilder.cs
@@ -6,11 +6,11 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
-    public sealed class ScopedAsyncLruBuilder<K, V> : LruBuilderBase<K, V, ScopedAsyncLruBuilder<K, V>, IScopedAsyncCache<K, V>> where V : IDisposable
+    public sealed class ScopedAsyncConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, ScopedAsyncConcurrentLruBuilder<K, V>, IScopedAsyncCache<K, V>> where V : IDisposable
     {
         private readonly AsyncConcurrentLruBuilder<K, Scoped<V>> inner;
 
-        internal ScopedAsyncLruBuilder(AsyncConcurrentLruBuilder<K, Scoped<V>> inner)
+        internal ScopedAsyncConcurrentLruBuilder(AsyncConcurrentLruBuilder<K, Scoped<V>> inner)
             : base(inner.info)
         {
             this.inner = inner;
diff --git a/BitFaster.Caching/Lru/Builder/ScopedLruBuilder.cs b/BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs
similarity index 71%
rename from BitFaster.Caching/Lru/Builder/ScopedLruBuilder.cs
rename to BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs
index 8007103a..c0fe8167 100644
--- a/BitFaster.Caching/Lru/Builder/ScopedLruBuilder.cs
+++ b/BitFaster.Caching/Lru/Builder/ScopedConcurrentLruBuilder.cs
@@ -7,11 +7,11 @@
 
 namespace BitFaster.Caching.Lru.Builder
 {
-    public sealed class ScopedLruBuilder<K, V, W> : LruBuilderBase<K, V, ScopedLruBuilder<K, V, W>, IScopedCache<K, V>> where V : IDisposable where W : IScoped<V>
+    public sealed class ScopedConcurrentLruBuilder<K, V, W> : LruBuilderBase<K, V, ScopedConcurrentLruBuilder<K, V, W>, IScopedCache<K, V>> where V : IDisposable where W : IScoped<V>
     {
         private readonly ConcurrentLruBuilder<K, W> inner;
 
-        internal ScopedLruBuilder(ConcurrentLruBuilder<K, W> inner)
+        internal ScopedConcurrentLruBuilder(ConcurrentLruBuilder<K, W> inner)
             : base(inner.info)
         {
             this.inner = inner;
diff --git a/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs
index 91b3431d..57381fd1 100644
--- a/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs
+++ b/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs
@@ -24,7 +24,7 @@ namespace BitFaster.Caching.Lru
     public sealed class ConcurrentLruBuilder<K, V> : LruBuilderBase<K, V, ConcurrentLruBuilder<K, V>, ICache<K, V>>
     {
         /// <summary>
-        /// Creates a ConcurrentLruBuilder.
+        /// Creates a ConcurrentLruBuilder. Chain method calls onto ConcurrentLruBuilder to configure the cache then call Build to create a cache instance.
         /// </summary>
         public ConcurrentLruBuilder()
             : base(new LruInfo<K>())
diff --git a/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs b/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs
index 8805d849..a123050c 100644
--- a/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs
+++ b/BitFaster.Caching/Lru/ConcurrentLruBuilderExtensions.cs
@@ -11,83 +11,167 @@ namespace BitFaster.Caching.Lru
     public static class ConcurrentLruBuilderExtensions
     {
         /// <summary>
-        /// Wrap IDisposable values in a lifetime scope. Scoped caches return lifetimes that prevent
+        /// Build an IScopedCache. IDisposable values are wrapped in a lifetime scope. Scoped caches return lifetimes that prevent
         /// values from being disposed until the calling code completes.
         /// </summary>
         /// <typeparam name="K">The type of keys in the cache.</typeparam>
         /// <typeparam name="V">The type of values in the cache.</typeparam>
         /// <param name="builder">The ConcurrentLruBuilder to chain method calls onto.</param>
-        /// <returns>A ScopedLruBuilder</returns>
-        public static ScopedLruBuilder<K, V, Scoped<V>> WithScopedValues<K, V>(this ConcurrentLruBuilder<K, V> builder) where V : IDisposable
+        /// <returns>A ScopedConcurrentLruBuilder.</returns>
+        public static ScopedConcurrentLruBuilder<K, V, Scoped<V>> AsScopedCache<K, V>(this ConcurrentLruBuilder<K, V> builder) where V : IDisposable
         {
-            var scoped = new ConcurrentLruBuilder<K, Scoped<V>>(builder.info);
-            return new ScopedLruBuilder<K, V, Scoped<V>>(scoped);
+            var convertBuilder = new ConcurrentLruBuilder<K, Scoped<V>>(builder.info);
+            return new ScopedConcurrentLruBuilder<K, V, Scoped<V>>(convertBuilder);
         }
 
-        public static AtomicLruBuilder<K, V> WithAtomicCreate<K, V>(this ConcurrentLruBuilder<K, V> b)
+        /// <summary>
+        /// Build an IScopedCache. IDisposable values are wrapped in a lifetime scope. Scoped caches return lifetimes that prevent
+        /// values from being disposed until the calling code completes.
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <param name="builder">The AtomicConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>An AtomicScopedConcurrentLruBuilder.</returns>
+        public static AtomicScopedConcurrentLruBuilder<K, V> AsScopedCache<K, V>(this AtomicConcurrentLruBuilder<K, V> builder) where V : IDisposable
         {
-            var a = new ConcurrentLruBuilder<K, AtomicFactory<K, V>>(b.info);
-            return new AtomicLruBuilder<K, V>(a);
+            var convertBuilder = new ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>>(builder.info);
+            return new AtomicScopedConcurrentLruBuilder<K, V>(convertBuilder);
         }
 
-        public static ScopedAtomicLruBuilder<K, V> WithAtomicCreate<K, V, W>(this ScopedLruBuilder<K, V, W> b) where V : IDisposable where W : IScoped<V>
+        /// <summary>
+        /// Build an IScopedAsyncCache. IDisposable values are wrapped in a lifetime scope. Scoped caches return lifetimes that prevent
+        /// values from being disposed until the calling code completes.
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <param name="builder">The AsyncConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>A ScopedAsyncConcurrentLruBuilder.</returns>
+        public static ScopedAsyncConcurrentLruBuilder<K, V> AsScopedCache<K, V>(this AsyncConcurrentLruBuilder<K, V> builder) where V : IDisposable
         {
-            var atomicScoped = new ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>>(b.info);
-
-            return new ScopedAtomicLruBuilder<K, V>(atomicScoped);
+            var convertBuilder = new AsyncConcurrentLruBuilder<K, Scoped<V>>(builder.info);
+            return new ScopedAsyncConcurrentLruBuilder<K, V>(convertBuilder);
         }
 
-        public static ScopedAtomicLruBuilder<K, V> WithScopedValues<K, V>(this AtomicLruBuilder<K, V> b) where V : IDisposable
+        /// <summary>
+        /// Build an IScopedAsyncCache. IDisposable values are wrapped in a lifetime scope. Scoped caches return lifetimes that prevent
+        /// values from being disposed until the calling code completes.
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <param name="builder">The AtomicAsyncConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>An AtomicScopedAsyncConcurrentLruBuilder.</returns>
+        public static AtomicScopedAsyncConcurrentLruBuilder<K, V> AsScopedCache<K, V>(this AtomicAsyncConcurrentLruBuilder<K, V> builder) where V : IDisposable
         {
-            var atomicScoped = new ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>>(b.info);
-            return new ScopedAtomicLruBuilder<K, V>(atomicScoped);
+            var convertBuilder = new AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>>(builder.info);
+            return new AtomicScopedAsyncConcurrentLruBuilder<K, V>(convertBuilder);
         }
 
-        public static AsyncConcurrentLruBuilder<K, V> AsAsyncCache<K, V>(this ConcurrentLruBuilder<K, V> builder)
+        /// <summary>
+        /// Execute the cache's GetOrAdd value factory atomically, such that it is applied at most once per key. Other threads
+        /// attempting to update the same key will be blocked until value factory completes.
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <param name="builder">The ConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>An AtomicConcurrentLruBuilder.</returns>
+        public static AtomicConcurrentLruBuilder<K, V> WithAtomicValueFactory<K, V>(this ConcurrentLruBuilder<K, V> builder)
         {
-            return new AsyncConcurrentLruBuilder<K, V>(builder.info);
+            var convertBuilder = new ConcurrentLruBuilder<K, AtomicFactory<K, V>>(builder.info);
+            return new AtomicConcurrentLruBuilder<K, V>(convertBuilder);
         }
 
-        public static ScopedAsyncLruBuilder<K, V> WithScopedValues<K, V>(this AsyncConcurrentLruBuilder<K, V> b) where V : IDisposable
+        /// <summary>
+        /// Execute the cache's ScopedGetOrAdd value factory atomically, such that it is applied at most once per key. Other threads
+        /// attempting to update the same key will be blocked until value factory completes.
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <typeparam name="W">The wrapped value type.</typeparam>
+        /// <param name="builder">The ScopedConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>An AtomicScopedConcurrentLruBuilder.</returns>
+        public static AtomicScopedConcurrentLruBuilder<K, V> WithAtomicValueFactory<K, V, W>(this ScopedConcurrentLruBuilder<K, V, W> builder) where V : IDisposable where W : IScoped<V>
         {
-            var asyncScoped = new AsyncConcurrentLruBuilder<K, Scoped<V>>(b.info);
-            return new ScopedAsyncLruBuilder<K, V>(asyncScoped);
+            var convertBuilder = new ConcurrentLruBuilder<K, ScopedAtomicFactory<K, V>>(builder.info);
+            return new AtomicScopedConcurrentLruBuilder<K, V>(convertBuilder);
         }
 
-        public static ScopedAsyncLruBuilder<K, V> AsAsyncCache<K, V>(this ScopedLruBuilder<K, V, Scoped<V>> b) where V : IDisposable
+        /// <summary>
+        /// Execute the cache's GetOrAddAsync value factory atomically, such that it is applied at most once per key. Other threads
+        /// attempting to update the same key will wait on the same value factory task.
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <param name="builder">The AsyncConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>An AtomicAsyncConcurrentLruBuilder.</returns>
+        public static AtomicAsyncConcurrentLruBuilder<K, V> WithAtomicValueFactory<K, V>(this AsyncConcurrentLruBuilder<K, V> builder)
         {
-            var asyncScoped = new AsyncConcurrentLruBuilder<K, Scoped<V>>(b.info);
-            return new ScopedAsyncLruBuilder<K, V>(asyncScoped);
+            var convertBuilder = new ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>>(builder.info);
+            return new AtomicAsyncConcurrentLruBuilder<K, V>(convertBuilder);
         }
 
-        public static AsyncAtomicLruBuilder<K, V> AsAsyncCache<K, V>(this AtomicLruBuilder<K, V> b)
+        /// <summary>
+        /// Execute the cache's ScopedGetOrAddAsync value factory atomically, such that it is applied at most once per key. Other threads
+        /// attempting to update the same key will wait on the same value factory task.
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <param name="builder">The ScopedAsyncConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>An AtomicScopedAsyncConcurrentLruBuilder.</returns>
+        public static AtomicScopedAsyncConcurrentLruBuilder<K, V> WithAtomicValueFactory<K, V>(this ScopedAsyncConcurrentLruBuilder<K, V> builder) where V : IDisposable
         {
-            var a = new ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>>(b.info);
-            return new AsyncAtomicLruBuilder<K, V>(a);
+            var convertBuilder = new AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>>(builder.info);
+            return new AtomicScopedAsyncConcurrentLruBuilder<K, V>(convertBuilder);
         }
 
-        public static AsyncAtomicLruBuilder<K, V> WithAtomicCreate<K, V>(this AsyncConcurrentLruBuilder<K, V> b)
+        /// <summary>
+        /// Build an IAsyncCache, the GetOrAdd method becomes GetOrAddAsync. 
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <param name="builder">The ConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>An AsyncConcurrentLruBuilder.</returns>
+        public static AsyncConcurrentLruBuilder<K, V> AsAsyncCache<K, V>(this ConcurrentLruBuilder<K, V> builder)
         {
-            var a = new ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>>(b.info);
-            return new AsyncAtomicLruBuilder<K, V>(a);
+            return new AsyncConcurrentLruBuilder<K, V>(builder.info);
         }
 
-        public static ScopedAsyncAtomicLruBuilder<K, V> AsAsyncCache<K, V>(this ScopedAtomicLruBuilder<K, V> b) where V : IDisposable
+        /// <summary>
+        /// Build an IScopedAsyncCache, the ScopedGetOrAdd method becomes ScopedGetOrAddAsync. 
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <param name="builder">The ScopedConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>A ScopedAsyncConcurrentLruBuilder.</returns>
+        public static ScopedAsyncConcurrentLruBuilder<K, V> AsAsyncCache<K, V>(this ScopedConcurrentLruBuilder<K, V, Scoped<V>> builder) where V : IDisposable
         {
-            var a = new AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>>(b.info);
-            return new ScopedAsyncAtomicLruBuilder<K, V>(a);
+            var convertBuilder = new AsyncConcurrentLruBuilder<K, Scoped<V>>(builder.info);
+            return new ScopedAsyncConcurrentLruBuilder<K, V>(convertBuilder);
         }
 
-        public static ScopedAsyncAtomicLruBuilder<K, V> WithScopedValues<K, V>(this AsyncAtomicLruBuilder<K, V> b) where V : IDisposable
+        /// <summary>
+        /// Build an IAsyncCache, the GetOrAdd method becomes GetOrAddAsync. 
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <param name="builder">The AtomicConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>An AtomicAsyncConcurrentLruBuilder.</returns>
+        public static AtomicAsyncConcurrentLruBuilder<K, V> AsAsyncCache<K, V>(this AtomicConcurrentLruBuilder<K, V> builder)
         {
-            var a = new AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>>(b.info);
-            return new ScopedAsyncAtomicLruBuilder<K, V>(a);
+            var convertBuilder = new ConcurrentLruBuilder<K, AsyncAtomicFactory<K, V>>(builder.info);
+            return new AtomicAsyncConcurrentLruBuilder<K, V>(convertBuilder);
         }
 
-        public static ScopedAsyncAtomicLruBuilder<K, V> WithAtomicCreate<K, V>(this ScopedAsyncLruBuilder<K, V> b) where V : IDisposable
+        /// <summary>
+        /// Build an IScopedAsyncCache, the ScopedGetOrAdd method becomes ScopedGetOrAddAsync.
+        /// </summary>
+        /// <typeparam name="K">The type of keys in the cache.</typeparam>
+        /// <typeparam name="V">The type of values in the cache.</typeparam>
+        /// <param name="builder">The AtomicScopedConcurrentLruBuilder to chain method calls onto.</param>
+        /// <returns>An AtomicScopedAsyncConcurrentLruBuilder.</returns>
+        public static AtomicScopedAsyncConcurrentLruBuilder<K, V> AsAsyncCache<K, V>(this AtomicScopedConcurrentLruBuilder<K, V> builder) where V : IDisposable
         {
-            var a = new AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>>(b.info);
-            return new ScopedAsyncAtomicLruBuilder<K, V>(a);
+            var convertBuilder = new AsyncConcurrentLruBuilder<K, ScopedAsyncAtomicFactory<K, V>>(builder.info);
+            return new AtomicScopedAsyncConcurrentLruBuilder<K, V>(convertBuilder);
         }
     }
 }