Release/0.4.0

Docs/releases.md

@@ -1,8 +1,13 @@
 # Releases
 
+# New in 0.4.0
+* Code refactoring
+* Ability to optimize Delta when calling sub-state reducers ([#8](https://github.com/mrpmorris/Reducible/issues/8))
+
 ## New in 0.3.0
 * Code refactoring
 * Renamed `Reducer.CreateBuilder` to `Reducer.CreateCompositeBuilder`
+* Allowed `.When` to be chained
 
 ## New in 0.2.0
 * Code refactoring

Source/Morris.Reducible/Builder.cs

@@ -6,25 +6,4 @@ public abstract class Builder<TState, TDelta>
 {
 	internal protected abstract Func<TState, TDelta, ReducerResult<TState>> Build(
 		Func<TState, TDelta, ReducerResult<TState>> next);
-
-
-	//public ObjectResultMapper<TState, TSubState, TDelta> WhenReducedBy<TSubState>(
-	//	Func<TState, TSubState> subStateSelector,
-	//	Func<TSubState, TDelta, ReducerResult<TSubState>> reducer)
-	//=>
-	//	new ObjectResultMapper<TState, TSubState, TDelta>(subStateSelector, reducer);
-
-	//public ImmutableArrayResultMapper<TState, TElement, TDelta> WhenReducedBy<TElement>(
-	//	Func<TState, ImmutableArray<TElement>> subStateSelector,
-	//	Func<TElement, TDelta, ReducerResult<TElement>> reducer)
-	//	=>
-	//		new ImmutableArrayResultMapper<TState, TElement, TDelta>(subStateSelector, reducer);
-
-	//public Func<TState, TDelta, ReducerResult<TState>> Then(Func<TState, TDelta, ReducerResult<TState>> reducer)
-	//{
-	//	if (reducer is null)
-	//		throw new ArgumentNullException(nameof(reducer));
-
-	//	return reducer;
-	//}
 }

Source/Morris.Reducible/Reducer.cs

@@ -6,12 +6,9 @@ namespace Morris.Reducible;
 
 public static partial class Reducer
 {
-	public static Builder<TState, TDelta> Given<TState, TDelta>() =>
+	public static GivenBuilder<TState, TDelta> Given<TState, TDelta>() =>
 		new GivenBuilder<TState, TDelta>();
 
-	//public static CompositeBuilder<TState> CreateCompositeBuilder<TState>() =>
-	//	new CompositeBuilder<TState>();
-
 	public static Func<TState, TDelta, ReducerResult<TState>> Combine<TState, TDelta>(
 		params Func<TState, TDelta, ReducerResult<TState>>[] reducers)
 	{

Source/Morris.Reducible/ThenExtensions.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Immutable;
 
 namespace Morris.Reducible;
 

Source/Morris.Reducible/WhenBuilder.cs

@@ -4,10 +4,12 @@ namespace Morris.Reducible;
 
 public class WhenBuilder<TState, TDelta> : Builder<TState, TDelta>
 {
+	private readonly GivenBuilder<TState, TDelta> SourceBuilder;
 	private readonly Func<TState, TDelta, bool> Condition;
 
-	internal WhenBuilder(Func<TState, TDelta, bool> condition)
+	internal WhenBuilder(GivenBuilder<TState, TDelta> sourceBuilder, Func<TState, TDelta, bool> condition)
 	{
+		SourceBuilder = sourceBuilder ?? throw new ArgumentNullException(nameof(sourceBuilder));
 		Condition = condition ?? throw new ArgumentNullException(nameof(condition));
 	}
 
@@ -16,10 +18,13 @@ protected internal override Func<TState, TDelta, ReducerResult<TState>> Build(
 	{
 		if (next is null)
 			throw new ArgumentNullException(nameof(next));
-		return (TState state, TDelta delta) =>
+
+		Func<TState, TDelta, ReducerResult<TState>> process = (state, delta) =>
 			!Condition(state, delta)
 			? (false, state)
 			: next(state, delta);
+
+		return SourceBuilder.Build(process);
 	}
 }
 

Source/Morris.Reducible/WhenBuilderExtensions.cs

@@ -5,9 +5,9 @@ namespace Morris.Reducible;
 public static class WhenExtensions
 {
 	public static WhenBuilder<TState, TDelta> When<TState, TDelta>(
-		this Builder<TState, TDelta> builder,
+		this GivenBuilder<TState, TDelta> source,
 		Func<TState, TDelta, bool> condition)
 		=>
-			new WhenBuilder<TState, TDelta>(condition);
+			new WhenBuilder<TState, TDelta>(source, condition);
 }
 

Source/Morris.Reducible/WhenIEnumerableByBuilder.cs → Source/Morris.Reducible/WhenIEnumerableReducedByBuilder.cs

@@ -4,19 +4,22 @@
 
 namespace Morris.Reducible;
 
-public class WhenIEnumerableReducedByBuilder<TState, TElement, TDelta>
+public class WhenIEnumerableReducedByBuilder<TState, TElement, TDelta, TOptimizedDelta>
 {
-	private readonly Builder<TState, TDelta> SourceBuilder;
+	private readonly GivenBuilder<TState, TDelta> SourceBuilder;
 	private readonly Func<TState, IEnumerable<TElement>> SubStateSelector;
-	private readonly Func<TElement, TDelta, ReducerResult<TElement>> ElementReducer;
+	private readonly Func<TDelta, TOptimizedDelta> OptimizeDelta;
+	private readonly Func<TElement, TOptimizedDelta, ReducerResult<TElement>> ElementReducer;
 
 	internal WhenIEnumerableReducedByBuilder(
-		Builder<TState, TDelta> sourceBuilder,
+		GivenBuilder<TState, TDelta> sourceBuilder,
 		Func<TState, IEnumerable<TElement>> subStateSelector,
-		Func<TElement, TDelta, ReducerResult<TElement>> elementReducer)
+		Func<TDelta, TOptimizedDelta> optimizeDelta,
+		Func<TElement, TOptimizedDelta, ReducerResult<TElement>> elementReducer)
 	{
 		SourceBuilder = sourceBuilder ?? throw new ArgumentNullException(nameof(sourceBuilder));
 		SubStateSelector = subStateSelector ?? throw new ArgumentNullException(nameof(subStateSelector));
+		OptimizeDelta = optimizeDelta ?? throw new ArgumentNullException(nameof(optimizeDelta));
 		ElementReducer = elementReducer ?? throw new ArgumentNullException(nameof(elementReducer));
 	}
 
@@ -25,16 +28,17 @@ public Func<TState, TDelta, ReducerResult<TState>> Then(Func<TState, IEnumerable
 		if (mapper is null)
 			throw new ArgumentNullException(nameof(mapper));
 
-		return (TState state, TDelta delta) =>
+		Func<TState, TDelta, ReducerResult<TState>> process = (state, delta) =>
 		{
+			TOptimizedDelta optimizedDelta = OptimizeDelta(delta);
 			IEnumerable<TElement> elements = SubStateSelector(state);
 
 			var list = new List<TElement>();
 
 			bool anyChanged = false;
 			foreach(TElement element in elements)
 			{
-				(bool changed, TElement newElement) = ElementReducer(element, delta);
+				(bool changed, TElement newElement) = ElementReducer(element, optimizedDelta);
 				list.Add(newElement);
 				if (changed)
 					anyChanged = true;
@@ -44,5 +48,7 @@ public Func<TState, TDelta, ReducerResult<TState>> Then(Func<TState, IEnumerable
 				? (true, mapper(state, list.ToImmutableArray()))
 				: (false, state);
 		};
+
+		return SourceBuilder.Build(process);
 	}
 }

Source/Morris.Reducible/WhenIEnumerableReducedByBuilderExtensions.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+
+namespace Morris.Reducible;
+
+public static class WhenIEnumerableReducedByBuilderExtensions
+{
+	public static WhenIEnumerableReducedByBuilder<TState, TElement, TDelta, TDelta>
+		WhenReducedBy<TState, TElement, TDelta>(
+			this GivenBuilder<TState, TDelta> sourceBuilder,
+			Func<TState, IEnumerable<TElement>> subStateSelector,
+			Func<TElement, TDelta, ReducerResult<TElement>> elementReducer)
+		=>
+			new WhenIEnumerableReducedByBuilder<TState, TElement, TDelta, TDelta>(
+				sourceBuilder,
+				subStateSelector,
+				delta => delta,
+				elementReducer);
+
+	public static WhenIEnumerableReducedByBuilder<TState, TElement, TDelta, TOptimizedDelta>
+		WhenReducedBy<TState, TElement, TDelta, TOptimizedDelta>(
+			this GivenBuilder<TState, TDelta> sourceBuilder,
+			Func<TState, IEnumerable<TElement>> subStateSelector,
+			Func<TDelta, TOptimizedDelta> optimizeDelta,
+			Func<TElement, TOptimizedDelta, ReducerResult<TElement>> elementReducer)
+		=>
+			new WhenIEnumerableReducedByBuilder<TState, TElement, TDelta, TOptimizedDelta>(
+				sourceBuilder,
+				subStateSelector,
+				optimizeDelta,
+				elementReducer);
+}

Source/Morris.Reducible/WhenImmutableArrayReducedByBuilder.cs

@@ -3,37 +3,41 @@
 
 namespace Morris.Reducible;
 
-public class WhenImmutableArrayReducedByBuilder<TState, TElement, TDelta>
+public class WhenImmutableArrayReducedByBuilder<TState, TElement, TDeltaIn, TOptimizedDelta>
 {
-	private readonly Builder<TState, TDelta> SourceBuilder;
+	private readonly GivenBuilder<TState, TDeltaIn> SourceBuilder;
 	private readonly Func<TState, ImmutableArray<TElement>> SubStateSelector;
-	private readonly Func<TElement, TDelta, ReducerResult<TElement>> ElementReducer;
+	private readonly Func<TDeltaIn, TOptimizedDelta> OptimizeDelta;
+	private readonly Func<TElement, TOptimizedDelta, ReducerResult<TElement>> ElementReducer;
 
 	internal WhenImmutableArrayReducedByBuilder(
-		Builder<TState, TDelta> sourceBuilder,
+		GivenBuilder<TState, TDeltaIn> sourceBuilder,
 		Func<TState, ImmutableArray<TElement>> subStateSelector,
-		Func<TElement, TDelta, ReducerResult<TElement>> elementReducer)
+		Func<TDeltaIn, TOptimizedDelta> optimizeDelta,
+		Func<TElement, TOptimizedDelta, ReducerResult<TElement>> elementReducer)
 	{
 		SourceBuilder = sourceBuilder ?? throw new ArgumentNullException(nameof(sourceBuilder));
 		SubStateSelector = subStateSelector ?? throw new ArgumentNullException(nameof(subStateSelector));
+		OptimizeDelta = optimizeDelta ?? throw new ArgumentNullException(nameof(optimizeDelta));
 		ElementReducer = elementReducer ?? throw new ArgumentNullException(nameof(elementReducer));
 	}
 
-	public Func<TState, TDelta, ReducerResult<TState>> Then(Func<TState, ImmutableArray<TElement>, TState> mapper)
+	public Func<TState, TDeltaIn, ReducerResult<TState>> Then(Func<TState, ImmutableArray<TElement>, TState> mapper)
 	{
 		if (mapper is null)
 			throw new ArgumentNullException(nameof(mapper));
 
-		return (TState state, TDelta delta) =>
+		Func<TState, TDeltaIn, ReducerResult<TState>> process = (state, delta) =>
 		{
+			TOptimizedDelta optimizedDelta = OptimizeDelta(delta);
 			ImmutableArray<TElement> elements = SubStateSelector(state);
 
 			var arrayBuilder = ImmutableArray.CreateBuilder<TElement>();
 
 			bool anyChanged = false;
 			for (int o = 0; o < elements.Length; o++)
 			{
-				(bool changed, TElement element) = ElementReducer(elements[o], delta);
+				(bool changed, TElement element) = ElementReducer(elements[o], optimizedDelta);
 				arrayBuilder.Add(element);
 				if (changed)
 					anyChanged = true;
@@ -43,5 +47,7 @@ public Func<TState, TDelta, ReducerResult<TState>> Then(Func<TState, ImmutableAr
 				? (true, mapper(state, arrayBuilder.ToImmutableArray()))
 				: (false, state);
 		};
+
+		return SourceBuilder.Build(process);
 	}
 }

Source/Morris.Reducible/WhenImmutableArrayReducedByBuilderExtensions.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Immutable;
+
+namespace Morris.Reducible;
+
+public static class WhenImmutableArrayReducedByBuilderExtensions
+{
+	public static WhenImmutableArrayReducedByBuilder<TState, TElement, TDelta, TDelta>
+		WhenReducedBy<TState, TElement, TDelta>(
+			this GivenBuilder<TState, TDelta> sourceBuilder,
+			Func<TState, ImmutableArray<TElement>> subStateSelector,
+			Func<TElement, TDelta, ReducerResult<TElement>> elementReducer)
+		=>
+			new WhenImmutableArrayReducedByBuilder<TState, TElement, TDelta, TDelta>(
+				sourceBuilder,
+				subStateSelector,
+				delta => delta,
+				elementReducer);
+
+	public static WhenImmutableArrayReducedByBuilder<TState, TElement, TDelta, TOptimizedDelta>
+		WhenReducedBy<TState, TElement, TDelta, TOptimizedDelta>(
+			this GivenBuilder<TState, TDelta> sourceBuilder,
+			Func<TState, ImmutableArray<TElement>> subStateSelector,
+			Func<TDelta, TOptimizedDelta> optimizeDelta,
+			Func<TElement, TOptimizedDelta, ReducerResult<TElement>> elementReducer)
+		=>
+			new WhenImmutableArrayReducedByBuilder<TState, TElement, TDelta, TOptimizedDelta>(
+				sourceBuilder,
+				subStateSelector,
+				optimizeDelta,
+				elementReducer);
+}