Add an Fn function to help with type inference

Funcky.Test/FunctionalClass/FnTest.cs

@@ -0,0 +1,14 @@
+namespace Funcky.Test.FunctionalClass;
+
+public sealed class FnTest
+{
+    [Fact]
+    public void FnHelpsToInferAMethodGroupsNaturalType()
+    {
+        var powCurried = Curry(Fn(Math.Pow));
+        var powUncurried = Uncurry(Fn(CurriedPow));
+        var flipped = Flip(Fn(Math.Pow));
+    }
+
+    private static Func<double, double> CurriedPow(double x) => y => Math.Pow(x, y);
+}

Funcky/Extensions/ActionExtensions/Compose.cs

@@ -6,6 +6,7 @@ public static partial class ActionExtensions
     /// Function composition with action.
     /// </summary>
     /// <returns>f ∘ g,v => f(g(v)).</returns>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<TInput> Compose<TInput, TIntermediate>(this Action<TIntermediate> f, Func<TInput, TIntermediate> g)
         => v => f(g(v));
@@ -14,6 +15,7 @@ public static Action<TInput> Compose<TInput, TIntermediate>(this Action<TInterme
     /// Function composition with Action.
     /// </summary>
     /// <returns>f ∘ g, () => f(g()).</returns>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action Compose<TIntermediate>(this Action<TIntermediate> f, Func<TIntermediate> g)
         => () => f(g());

Funcky/Extensions/ActionExtensions/Curry.cs

@@ -5,48 +5,55 @@ public static partial class ActionExtensions
     /// <summary>
     /// Curries the given action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Action<T2>> Curry<T1, T2>(this Action<T1, T2> action)
         => p1 => p2 => action(p1, p2);
 
     /// <summary>
     /// Curries the given action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Action<T3>>> Curry<T1, T2, T3>(this Action<T1, T2, T3> action)
         => p1 => p2 => p3 => action(p1, p2, p3);
 
     /// <summary>
     /// Curries the given action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, Action<T4>>>> Curry<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action)
         => p1 => p2 => p3 => p4 => action(p1, p2, p3, p4);
 
     /// <summary>
     /// Curries the given action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, Func<T4, Action<T5>>>>> Curry<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action)
         => p1 => p2 => p3 => p4 => p5 => action(p1, p2, p3, p4, p5);
 
     /// <summary>
     /// Curries the given action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Action<T6>>>>>> Curry<T1, T2, T3, T4, T5, T6>(this Action<T1, T2, T3, T4, T5, T6> action)
         => p1 => p2 => p3 => p4 => p5 => p6 => action(p1, p2, p3, p4, p5, p6);
 
     /// <summary>
     /// Curries the given action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Func<T6, Action<T7>>>>>>> Curry<T1, T2, T3, T4, T5, T6, T7>(this Action<T1, T2, T3, T4, T5, T6, T7> action)
         => p1 => p2 => p3 => p4 => p5 => p6 => p7 => action(p1, p2, p3, p4, p5, p6, p7);
 
     /// <summary>
     /// Curries the given action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Func<T6, Func<T7, Action<T8>>>>>>>> Curry<T1, T2, T3, T4, T5, T6, T7, T8>(this Action<T1, T2, T3, T4, T5, T6, T7, T8> action)
         => p1 => p2 => p3 => p4 => p5 => p6 => p7 => p8 => action(p1, p2, p3, p4, p5, p6, p7, p8);

Funcky/Extensions/ActionExtensions/Flip.cs

@@ -3,50 +3,57 @@ namespace Funcky.Extensions;
 public static partial class ActionExtensions
 {
     /// <summary>
-    /// Flips the first two arguments of the function.
+    /// Flips the first two arguments of the action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T2, T1> Flip<T1, T2>(this Action<T1, T2> function)
         => (p1, p2) => function(p2, p1);
 
     /// <summary>
-    /// Flips the first two arguments of the function.
+    /// Flips the first two arguments of the action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T2, T1, T3> Flip<T1, T2, T3>(this Action<T1, T2, T3> action)
         => (p1, p2, p3) => action(p2, p1, p3);
 
     /// <summary>
     /// Flips the first two arguments of the action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T2, T1, T3, T4> Flip<T1, T2, T3, T4>(this Action<T1, T2, T3, T4> action)
         => (p1, p2, p3, p4) => action(p2, p1, p3, p4);
 
     /// <summary>
     /// Flips the first two arguments of the action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T2, T1, T3, T4, T5> Flip<T1, T2, T3, T4, T5>(this Action<T1, T2, T3, T4, T5> action)
         => (p1, p2, p3, p4, p5) => action(p2, p1, p3, p4, p5);
 
     /// <summary>
     /// Flips the first two arguments of the action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T2, T1, T3, T4, T5, T6> Flip<T1, T2, T3, T4, T5, T6>(this Action<T1, T2, T3, T4, T5, T6> action)
         => (p1, p2, p3, p4, p5, p6) => action(p2, p1, p3, p4, p5, p6);
 
     /// <summary>
     /// Flips the first two arguments of the action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T2, T1, T3, T4, T5, T6, T7> Flip<T1, T2, T3, T4, T5, T6, T7>(this Action<T1, T2, T3, T4, T5, T6, T7> action)
         => (p1, p2, p3, p4, p5, p6, p7) => action(p2, p1, p3, p4, p5, p6, p7);
 
     /// <summary>
     /// Flips the first two arguments of the action.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T2, T1, T3, T4, T5, T6, T7, T8> Flip<T1, T2, T3, T4, T5, T6, T7, T8>(this Action<T1, T2, T3, T4, T5, T6, T7, T8> action)
         => (p1, p2, p3, p4, p5, p6, p7, p8) => action(p2, p1, p3, p4, p5, p6, p7, p8);

Funcky/Extensions/ActionExtensions/Uncurry.cs

@@ -3,50 +3,57 @@ namespace Funcky.Extensions;
 public static partial class ActionExtensions
 {
     /// <summary>
-    /// Transforms a curried action into a action that takes multiple arguments.
+    /// Transforms a curried action into an action that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T1, T2> Uncurry<T1, T2>(this Func<T1, Action<T2>> action)
         => (p1, p2) => action(p1)(p2);
 
     /// <summary>
-    /// Transforms a curried action into a action that takes multiple arguments.
+    /// Transforms a curried action into an action that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T1, T2, T3> Uncurry<T1, T2, T3>(this Func<T1, Func<T2, Action<T3>>> action)
         => (p1, p2, p3) => action(p1)(p2)(p3);
 
     /// <summary>
-    /// Transforms a curried action into a action that takes multiple arguments.
+    /// Transforms a curried action into an action that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T1, T2, T3, T4> Uncurry<T1, T2, T3, T4>(this Func<T1, Func<T2, Func<T3, Action<T4>>>> action)
         => (p1, p2, p3, p4) => action(p1)(p2)(p3)(p4);
 
     /// <summary>
-    /// Transforms a curried action into a action that takes multiple arguments.
+    /// Transforms a curried action into an action that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T1, T2, T3, T4, T5> Uncurry<T1, T2, T3, T4, T5>(this Func<T1, Func<T2, Func<T3, Func<T4, Action<T5>>>>> action)
         => (p1, p2, p3, p4, p5) => action(p1)(p2)(p3)(p4)(p5);
 
     /// <summary>
-    /// Transforms a curried action into a action that takes multiple arguments.
+    /// Transforms a curried action into an action that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T1, T2, T3, T4, T5, T6> Uncurry<T1, T2, T3, T4, T5, T6>(this Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Action<T6>>>>>> action)
         => (p1, p2, p3, p4, p5, p6) => action(p1)(p2)(p3)(p4)(p5)(p6);
 
     /// <summary>
-    /// Transforms a curried action into a action that takes multiple arguments.
+    /// Transforms a curried action into an action that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T1, T2, T3, T4, T5, T6, T7> Uncurry<T1, T2, T3, T4, T5, T6, T7>(this Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Func<T6, Action<T7>>>>>>> action)
         => (p1, p2, p3, p4, p5, p6, p7) => action(p1)(p2)(p3)(p4)(p5)(p6)(p7);
 
     /// <summary>
-    /// Transforms a curried action into a action that takes multiple arguments.
+    /// Transforms a curried action into an action that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Action<T1, T2, T3, T4, T5, T6, T7, T8> Uncurry<T1, T2, T3, T4, T5, T6, T7, T8>(this Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Func<T6, Func<T7, Action<T8>>>>>>>> action)
         => (p1, p2, p3, p4, p5, p6, p7, p8) => action(p1)(p2)(p3)(p4)(p5)(p6)(p7)(p8);

Funcky/Extensions/FuncExtensions/Compose.cs

@@ -6,6 +6,7 @@ public static partial class FuncExtensions
     /// Function composition.
     /// </summary>
     /// <returns>f ∘ g, v => f(g(v)).</returns>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<TInput, TOutput> Compose<TInput, TIntermediate, TOutput>(this Func<TIntermediate, TOutput> f, Func<TInput, TIntermediate> g)
         => v => f(g(v));
@@ -14,6 +15,7 @@ public static Func<TInput, TOutput> Compose<TInput, TIntermediate, TOutput>(this
     /// Function composition.
     /// </summary>
     /// <returns>f ∘ g,() => f(g()).</returns>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<TOutput> Compose<TIntermediate, TOutput>(this Func<TIntermediate, TOutput> f, Func<TIntermediate> g)
         => () => f(g());

Funcky/Extensions/FuncExtensions/Curry.cs

@@ -5,48 +5,55 @@ public static partial class FuncExtensions
     /// <summary>
     /// Curries the given function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, TResult>> Curry<T1, T2, TResult>(this Func<T1, T2, TResult> function)
         => p1 => p2 => function(p1, p2);
 
     /// <summary>
     /// Curries the given function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, TResult>>> Curry<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function)
         => p1 => p2 => p3 => function(p1, p2, p3);
 
     /// <summary>
     /// Curries the given function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, Func<T4, TResult>>>> Curry<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function)
         => p1 => p2 => p3 => p4 => function(p1, p2, p3, p4);
 
     /// <summary>
     /// Curries the given function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, TResult>>>>> Curry<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> function)
         => p1 => p2 => p3 => p4 => p5 => function(p1, p2, p3, p4, p5);
 
     /// <summary>
     /// Curries the given function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Func<T6, TResult>>>>>> Curry<T1, T2, T3, T4, T5, T6, TResult>(this Func<T1, T2, T3, T4, T5, T6, TResult> function)
         => p1 => p2 => p3 => p4 => p5 => p6 => function(p1, p2, p3, p4, p5, p6);
 
     /// <summary>
     /// Curries the given function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Func<T6, Func<T7, TResult>>>>>>> Curry<T1, T2, T3, T4, T5, T6, T7, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, TResult> function)
         => p1 => p2 => p3 => p4 => p5 => p6 => p7 => function(p1, p2, p3, p4, p5, p6, p7);
 
     /// <summary>
     /// Curries the given function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Func<T6, Func<T7, Func<T8, TResult>>>>>>>> Curry<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function)
         => p1 => p2 => p3 => p4 => p5 => p6 => p7 => p8 => function(p1, p2, p3, p4, p5, p6, p7, p8);

Funcky/Extensions/FuncExtensions/Flip.cs

@@ -5,48 +5,55 @@ public static partial class FuncExtensions
     /// <summary>
     /// Flips the first two arguments of the function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T2, T1, TResult> Flip<T1, T2, TResult>(this Func<T1, T2, TResult> function)
         => (p1, p2) => function(p2, p1);
 
     /// <summary>
     /// Flips the first two arguments of the function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T2, T1, T3, TResult> Flip<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> function)
         => (p1, p2, p3) => function(p2, p1, p3);
 
     /// <summary>
     /// Flips the first two arguments of the function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T2, T1, T3, T4, TResult> Flip<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> function)
         => (p1, p2, p3, p4) => function(p2, p1, p3, p4);
 
     /// <summary>
     /// Flips the first two arguments of the function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T2, T1, T3, T4, T5, TResult> Flip<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> function)
         => (p1, p2, p3, p4, p5) => function(p2, p1, p3, p4, p5);
 
     /// <summary>
     /// Flips the first two arguments of the function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T2, T1, T3, T4, T5, T6, TResult> Flip<T1, T2, T3, T4, T5, T6, TResult>(this Func<T1, T2, T3, T4, T5, T6, TResult> function)
         => (p1, p2, p3, p4, p5, p6) => function(p2, p1, p3, p4, p5, p6);
 
     /// <summary>
     /// Flips the first two arguments of the function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T2, T1, T3, T4, T5, T6, T7, TResult> Flip<T1, T2, T3, T4, T5, T6, T7, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, TResult> function)
         => (p1, p2, p3, p4, p5, p6, p7) => function(p2, p1, p3, p4, p5, p6, p7);
 
     /// <summary>
     /// Flips the first two arguments of the function.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T2, T1, T3, T4, T5, T6, T7, T8, TResult> Flip<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function)
         => (p1, p2, p3, p4, p5, p6, p7, p8) => function(p2, p1, p3, p4, p5, p6, p7, p8);

Funcky/Extensions/FuncExtensions/Uncurry.cs

@@ -5,48 +5,55 @@ public static partial class FuncExtensions
     /// <summary>
     /// Transforms a curried function into a function that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, T2, TResult> Uncurry<T1, T2, TResult>(this Func<T1, Func<T2, TResult>> function)
         => (p1, p2) => function(p1)(p2);
 
     /// <summary>
     /// Transforms a curried function into a function that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, T2, T3, TResult> Uncurry<T1, T2, T3, TResult>(this Func<T1, Func<T2, Func<T3, TResult>>> function)
         => (p1, p2, p3) => function(p1)(p2)(p3);
 
     /// <summary>
     /// Transforms a curried function into a function that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, T2, T3, T4, TResult> Uncurry<T1, T2, T3, T4, TResult>(this Func<T1, Func<T2, Func<T3, Func<T4, TResult>>>> function)
         => (p1, p2, p3, p4) => function(p1)(p2)(p3)(p4);
 
     /// <summary>
     /// Transforms a curried function into a function that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, T2, T3, T4, T5, TResult> Uncurry<T1, T2, T3, T4, T5, TResult>(this Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, TResult>>>>> function)
         => (p1, p2, p3, p4, p5) => function(p1)(p2)(p3)(p4)(p5);
 
     /// <summary>
     /// Transforms a curried function into a function that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, T2, T3, T4, T5, T6, TResult> Uncurry<T1, T2, T3, T4, T5, T6, TResult>(this Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Func<T6, TResult>>>>>> function)
         => (p1, p2, p3, p4, p5, p6) => function(p1)(p2)(p3)(p4)(p5)(p6);
 
     /// <summary>
     /// Transforms a curried function into a function that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, T2, T3, T4, T5, T6, T7, TResult> Uncurry<T1, T2, T3, T4, T5, T6, T7, TResult>(this Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Func<T6, Func<T7, TResult>>>>>>> function)
         => (p1, p2, p3, p4, p5, p6, p7) => function(p1)(p2)(p3)(p4)(p5)(p6)(p7);
 
     /// <summary>
     /// Transforms a curried function into a function that takes multiple arguments.
     /// </summary>
+    /// <seealso cref="Fn{T}"/>
     [Pure]
     public static Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> Uncurry<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this Func<T1, Func<T2, Func<T3, Func<T4, Func<T5, Func<T6, Func<T7, Func<T8, TResult>>>>>>>> function)
         => (p1, p2, p3, p4, p5, p6, p7, p8) => function(p1)(p2)(p3)(p4)(p5)(p6)(p7)(p8);