IndexableProperties.cs

///////////////////////////////////////////////////////////////////////
//             AUTOGENERATED 2022-02-11 09:35:27.335281              //
//   All your changes to this file will be lost upon re-generation.  //
///////////////////////////////////////////////////////////////////////

using System.Runtime.CompilerServices;
using System.Collections.Generic;
using System.Linq;
using System;

namespace Unknown6656;


public static class Indexer
{
    public static Indexer<int, T> AsIndexer<T>(this T[] array) => (array as IList<T>).AsIndexer();

    public static Indexer<int, T> AsIndexer<T>(this IList<T> list) => new(idx => list[idx], (idx, value) => list[idx] = value);

    public static Indexer<int, T> AsIndexer<T>(this IEnumerable<T> collection) => (collection as IList<T> ?? collection.ToList()).AsIndexer();

    public static Indexer<K, V> AsIndexer<K, V>(this IDictionary<K, V> dictionary)
        where K : notnull => new(key => dictionary[key], (key, value) => dictionary[key] = value);

    public static ReadOnlyIndexer<K, V> AsReadOnlyIndexer<K, V>(this IDictionary<K, V> dictionary)
        where K : notnull => new(key => dictionary[key]);

    public static ReadOnlyIndexer<K, V> AsReadOnlyIndexer<K, V>(this IReadOnlyDictionary<K, V> dictionary)
        where K : notnull => new(key => dictionary[key]);

    public static ReadOnlyIndexer<int, T> AsReadOnlyIndexer<T>(this T[] array) => (array as IReadOnlyList<T>).AsIndexer();

    public static ReadOnlyIndexer<int, T> AsReadOnlyIndexer<T>(this IReadOnlyList<T> list) => new(idx => list[idx]);

    public static ReadOnlyIndexer<int, T> AsReadOnlyIndexer<T>(this IEnumerable<T> collection) => (collection as IList<T> ?? collection.ToList()).AsReadOnlyIndexer();
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Value>
{
    public Action<Index1, Value> SetterFunction { get; private set; }
    public Func<Index1, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Value>(Indexer<Index1, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Value>(Indexer<Index1, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Value> getter, Action<Index1, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Value> getter, WriteOnlyIndexer<Index1, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Value>
{
    public Action<Index1, Value> SetterFunction { get; private set; }
    // public Func<Index1, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Value>(WriteOnlyIndexer<Index1, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Value>(Action<Index1, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Value>
{
    // public Action<Index1, Value> SetterFunction { get; private set; }
    public Func<Index1, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Value>(ReadOnlyIndexer<Index1, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Value>(Func<Index1, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, Value>(Index1 i1);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Value>
{
    private readonly RefFunc<Index1, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1] => ref _func(i1);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Value> AsReadOnly() => new((Index1 i1) => _func(i1));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Value> AsWriteOnly() => new((Index1 i1, Value v) => _func(i1) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Value>(RefIndexer<Index1, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Value>(RefIndexer<Index1, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Value>(RefIndexer<Index1, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Value>(RefIndexer<Index1, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Value>(RefFunc<Index1, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Value>
{
    public Action<Index1, Index2, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Value> Curry(Index1 i1) => new(
(i2) => this[i1, i2],(i2, value) => this[i1, i2] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Value>(Indexer<Index1, Index2, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Value>(Indexer<Index1, Index2, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Value> getter, Action<Index1, Index2, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Value> getter, WriteOnlyIndexer<Index1, Index2, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Value>
{
    public Action<Index1, Index2, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Value> Curry(Index1 i1) => new(
(i2, value) => this[i1, i2] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Value>(WriteOnlyIndexer<Index1, Index2, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Value>(Action<Index1, Index2, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Value>
{
    // public Action<Index1, Index2, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Value> Curry(Index1 i1) => new(
(i2) => this[i1, i2]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Value>(ReadOnlyIndexer<Index1, Index2, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Value>(Func<Index1, Index2, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, Value>(Index1 i1, Index2 i2);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Value>
{
    private readonly RefFunc<Index1, Index2, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2] => ref _func(i1, i2);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Value> AsReadOnly() => new((Index1 i1, Index2 i2) => _func(i1, i2));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Value v) => _func(i1, i2) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Value>(RefIndexer<Index1, Index2, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Value>(RefIndexer<Index1, Index2, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Value>(RefIndexer<Index1, Index2, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Value>(RefIndexer<Index1, Index2, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Value>(RefFunc<Index1, Index2, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Value>
{
    public Action<Index1, Index2, Index3, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Value> Curry(Index1 i1) => new(
(i2, i3) => this[i1, i2, i3],(i2, i3, value) => this[i1, i2, i3] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Value> Curry(Index1 i1, Index2 i2) => new(
(i3) => this[i1, i2, i3],(i3, value) => this[i1, i2, i3] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Value>(Indexer<Index1, Index2, Index3, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Value>(Indexer<Index1, Index2, Index3, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Value> getter, Action<Index1, Index2, Index3, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Value>
{
    public Action<Index1, Index2, Index3, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Value> Curry(Index1 i1) => new(
(i2, i3, value) => this[i1, i2, i3] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, value) => this[i1, i2, i3] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Value>(Action<Index1, Index2, Index3, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Value>
{
    // public Action<Index1, Index2, Index3, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Value> Curry(Index1 i1) => new(
(i2, i3) => this[i1, i2, i3]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Value> Curry(Index1 i1, Index2 i2) => new(
(i3) => this[i1, i2, i3]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Value>(Func<Index1, Index2, Index3, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, Value>(Index1 i1, Index2 i2, Index3 i3);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3] => ref _func(i1, i2, i3);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3) => _func(i1, i2, i3));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Value v) => _func(i1, i2, i3) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Value>(RefIndexer<Index1, Index2, Index3, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Value>(RefIndexer<Index1, Index2, Index3, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Value>(RefIndexer<Index1, Index2, Index3, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Value>(RefIndexer<Index1, Index2, Index3, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Value>(RefFunc<Index1, Index2, Index3, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Value>
{
    public Action<Index1, Index2, Index3, Index4, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Value> Curry(Index1 i1) => new(
(i2, i3, i4) => this[i1, i2, i3, i4],(i2, i3, i4, value) => this[i1, i2, i3, i4] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4) => this[i1, i2, i3, i4],(i3, i4, value) => this[i1, i2, i3, i4] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4) => this[i1, i2, i3, i4],(i4, value) => this[i1, i2, i3, i4] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Value>(Indexer<Index1, Index2, Index3, Index4, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Value>(Indexer<Index1, Index2, Index3, Index4, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Value> getter, Action<Index1, Index2, Index3, Index4, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Value>
{
    public Action<Index1, Index2, Index3, Index4, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Value> Curry(Index1 i1) => new(
(i2, i3, i4, value) => this[i1, i2, i3, i4] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, value) => this[i1, i2, i3, i4] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, value) => this[i1, i2, i3, i4] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Value>(Action<Index1, Index2, Index3, Index4, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Value> Curry(Index1 i1) => new(
(i2, i3, i4) => this[i1, i2, i3, i4]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4) => this[i1, i2, i3, i4]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4) => this[i1, i2, i3, i4]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Value>(Func<Index1, Index2, Index3, Index4, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => ref _func(i1, i2, i3, i4);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4) => _func(i1, i2, i3, i4));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Value v) => _func(i1, i2, i3, i4) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Value>(RefIndexer<Index1, Index2, Index3, Index4, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Value>(RefIndexer<Index1, Index2, Index3, Index4, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Value>(RefIndexer<Index1, Index2, Index3, Index4, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Value>(RefIndexer<Index1, Index2, Index3, Index4, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Value>(RefFunc<Index1, Index2, Index3, Index4, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5) => this[i1, i2, i3, i4, i5],(i2, i3, i4, i5, value) => this[i1, i2, i3, i4, i5] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5) => this[i1, i2, i3, i4, i5],(i3, i4, i5, value) => this[i1, i2, i3, i4, i5] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5) => this[i1, i2, i3, i4, i5],(i4, i5, value) => this[i1, i2, i3, i4, i5] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5) => this[i1, i2, i3, i4, i5],(i5, value) => this[i1, i2, i3, i4, i5] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, value) => this[i1, i2, i3, i4, i5] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, value) => this[i1, i2, i3, i4, i5] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, value) => this[i1, i2, i3, i4, i5] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, value) => this[i1, i2, i3, i4, i5] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value>(Action<Index1, Index2, Index3, Index4, Index5, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5) => this[i1, i2, i3, i4, i5]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5) => this[i1, i2, i3, i4, i5]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5) => this[i1, i2, i3, i4, i5]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5) => this[i1, i2, i3, i4, i5]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value>(Func<Index1, Index2, Index3, Index4, Index5, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => ref _func(i1, i2, i3, i4, i5);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => _func(i1, i2, i3, i4, i5));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Value v) => _func(i1, i2, i3, i4, i5) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6) => this[i1, i2, i3, i4, i5, i6],(i2, i3, i4, i5, i6, value) => this[i1, i2, i3, i4, i5, i6] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6) => this[i1, i2, i3, i4, i5, i6],(i3, i4, i5, i6, value) => this[i1, i2, i3, i4, i5, i6] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6) => this[i1, i2, i3, i4, i5, i6],(i4, i5, i6, value) => this[i1, i2, i3, i4, i5, i6] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6) => this[i1, i2, i3, i4, i5, i6],(i5, i6, value) => this[i1, i2, i3, i4, i5, i6] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6) => this[i1, i2, i3, i4, i5, i6],(i6, value) => this[i1, i2, i3, i4, i5, i6] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Index6, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Index6, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, value) => this[i1, i2, i3, i4, i5, i6] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, value) => this[i1, i2, i3, i4, i5, i6] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, value) => this[i1, i2, i3, i4, i5, i6] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, value) => this[i1, i2, i3, i4, i5, i6] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, value) => this[i1, i2, i3, i4, i5, i6] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Index6, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Index6, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>(Action<Index1, Index2, Index3, Index4, Index5, Index6, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Index6, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6) => this[i1, i2, i3, i4, i5, i6]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6) => this[i1, i2, i3, i4, i5, i6]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6) => this[i1, i2, i3, i4, i5, i6]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6) => this[i1, i2, i3, i4, i5, i6]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6) => this[i1, i2, i3, i4, i5, i6]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Index6, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>(Func<Index1, Index2, Index3, Index4, Index5, Index6, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5, Index6 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Index6, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <param name="i6"><typeparamref name="Index6"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, in Index6, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => ref _func(i1, i2, i3, i4, i5, i6);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => _func(i1, i2, i3, i4, i5, i6));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Value v) => _func(i1, i2, i3, i4, i5, i6) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7) => this[i1, i2, i3, i4, i5, i6, i7],(i2, i3, i4, i5, i6, i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7) => this[i1, i2, i3, i4, i5, i6, i7],(i3, i4, i5, i6, i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7) => this[i1, i2, i3, i4, i5, i6, i7],(i4, i5, i6, i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7) => this[i1, i2, i3, i4, i5, i6, i7],(i5, i6, i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7) => this[i1, i2, i3, i4, i5, i6, i7],(i6, i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7) => this[i1, i2, i3, i4, i5, i6, i7],(i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, value) => this[i1, i2, i3, i4, i5, i6, i7] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7) => this[i1, i2, i3, i4, i5, i6, i7]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7) => this[i1, i2, i3, i4, i5, i6, i7]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7) => this[i1, i2, i3, i4, i5, i6, i7]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7) => this[i1, i2, i3, i4, i5, i6, i7]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7) => this[i1, i2, i3, i4, i5, i6, i7]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7) => this[i1, i2, i3, i4, i5, i6, i7]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5, Index6, Index7 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> parameter type.</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <param name="i6"><typeparamref name="Index6"/> parameter</param>
/// <param name="i7"><typeparamref name="Index7"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, in Index6, in Index7, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => ref _func(i1, i2, i3, i4, i5, i6, i7);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => _func(i1, i2, i3, i4, i5, i6, i7));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Value v) => _func(i1, i2, i3, i4, i5, i6, i7) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8],(i2, i3, i4, i5, i6, i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8],(i3, i4, i5, i6, i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8],(i4, i5, i6, i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8],(i5, i6, i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8],(i6, i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8],(i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8) => this[i1, i2, i3, i4, i5, i6, i7, i8],(i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, value) => this[i1, i2, i3, i4, i5, i6, i7, i8] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8) => this[i1, i2, i3, i4, i5, i6, i7, i8]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8) => this[i1, i2, i3, i4, i5, i6, i7, i8]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> parameter type.</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> parameter type.</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <param name="i6"><typeparamref name="Index6"/> parameter</param>
/// <param name="i7"><typeparamref name="Index7"/> parameter</param>
/// <param name="i8"><typeparamref name="Index8"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, in Index6, in Index7, in Index8, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => ref _func(i1, i2, i3, i4, i5, i6, i7, i8);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => _func(i1, i2, i3, i4, i5, i6, i7, i8));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Value v) => _func(i1, i2, i3, i4, i5, i6, i7, i8) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9],(i2, i3, i4, i5, i6, i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9],(i3, i4, i5, i6, i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9],(i4, i5, i6, i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9],(i5, i6, i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9],(i6, i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9],(i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9],(i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9],(i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> parameter type.</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> parameter type.</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> parameter type.</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <param name="i6"><typeparamref name="Index6"/> parameter</param>
/// <param name="i7"><typeparamref name="Index7"/> parameter</param>
/// <param name="i8"><typeparamref name="Index8"/> parameter</param>
/// <param name="i9"><typeparamref name="Index9"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, in Index6, in Index7, in Index8, in Index9, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => ref _func(i1, i2, i3, i4, i5, i6, i7, i8, i9);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Value v) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10],(i2, i3, i4, i5, i6, i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10],(i3, i4, i5, i6, i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10],(i4, i5, i6, i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10],(i5, i6, i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10],(i6, i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10],(i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10],(i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10],(i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10],(i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> parameter type.</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> parameter type.</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> parameter type.</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> parameter type.</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <param name="i6"><typeparamref name="Index6"/> parameter</param>
/// <param name="i7"><typeparamref name="Index7"/> parameter</param>
/// <param name="i8"><typeparamref name="Index8"/> parameter</param>
/// <param name="i9"><typeparamref name="Index9"/> parameter</param>
/// <param name="i10"><typeparamref name="Index10"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, in Index6, in Index7, in Index8, in Index9, in Index10, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => ref _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Value v) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11],(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11],(i3, i4, i5, i6, i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11],(i4, i5, i6, i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11],(i5, i6, i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11],(i6, i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11],(i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11],(i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11],(i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11],(i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11],(i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index11, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index11, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> parameter type.</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> parameter type.</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> parameter type.</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> parameter type.</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> parameter type.</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <param name="i6"><typeparamref name="Index6"/> parameter</param>
/// <param name="i7"><typeparamref name="Index7"/> parameter</param>
/// <param name="i8"><typeparamref name="Index8"/> parameter</param>
/// <param name="i9"><typeparamref name="Index9"/> parameter</param>
/// <param name="i10"><typeparamref name="Index10"/> parameter</param>
/// <param name="i11"><typeparamref name="Index11"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, in Index6, in Index7, in Index8, in Index9, in Index10, in Index11, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => ref _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Value v) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i4, i5, i6, i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i5, i6, i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i6, i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12],(i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index11, Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index11, Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index12, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index12, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> parameter type.</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> parameter type.</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> parameter type.</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> parameter type.</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> parameter type.</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> parameter type.</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <param name="i6"><typeparamref name="Index6"/> parameter</param>
/// <param name="i7"><typeparamref name="Index7"/> parameter</param>
/// <param name="i8"><typeparamref name="Index8"/> parameter</param>
/// <param name="i9"><typeparamref name="Index9"/> parameter</param>
/// <param name="i10"><typeparamref name="Index10"/> parameter</param>
/// <param name="i11"><typeparamref name="Index11"/> parameter</param>
/// <param name="i12"><typeparamref name="Index12"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, in Index6, in Index7, in Index8, in Index9, in Index10, in Index11, in Index12, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12] => ref _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Value v) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i5, i6, i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i6, i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12) => new(
(i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13],(i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12, i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12) => new(
(i13, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index11, Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index11, Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index12, Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index12, Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12, i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index13, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index13, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12) => new(
(i13) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> parameter type.</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> parameter type.</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> parameter type.</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> parameter type.</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> parameter type.</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> parameter type.</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> parameter type.</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <param name="i6"><typeparamref name="Index6"/> parameter</param>
/// <param name="i7"><typeparamref name="Index7"/> parameter</param>
/// <param name="i8"><typeparamref name="Index8"/> parameter</param>
/// <param name="i9"><typeparamref name="Index9"/> parameter</param>
/// <param name="i10"><typeparamref name="Index10"/> parameter</param>
/// <param name="i11"><typeparamref name="Index11"/> parameter</param>
/// <param name="i12"><typeparamref name="Index12"/> parameter</param>
/// <param name="i13"><typeparamref name="Index13"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, in Index6, in Index7, in Index8, in Index9, in Index10, in Index11, in Index12, in Index13, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13] => ref _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Value v) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index14">Generic <typeparamref name="Index14"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i6, i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12) => new(
(i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13) => new(
(i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14],(i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index14">Generic <typeparamref name="Index14"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12, i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12) => new(
(i13, i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13) => new(
(i14, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index14">Generic <typeparamref name="Index14"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index11, Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index11, Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index12, Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index12, Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12, i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index13, Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index13, Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12) => new(
(i13, i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index14, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index14, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13) => new(
(i14) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> parameter type.</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> parameter type.</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> parameter type.</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> parameter type.</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> parameter type.</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> parameter type.</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> parameter type.</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> parameter type.</typeparam>
/// <typeparam name="Index14">Generic <typeparamref name="Index14"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <param name="i6"><typeparamref name="Index6"/> parameter</param>
/// <param name="i7"><typeparamref name="Index7"/> parameter</param>
/// <param name="i8"><typeparamref name="Index8"/> parameter</param>
/// <param name="i9"><typeparamref name="Index9"/> parameter</param>
/// <param name="i10"><typeparamref name="Index10"/> parameter</param>
/// <param name="i11"><typeparamref name="Index11"/> parameter</param>
/// <param name="i12"><typeparamref name="Index12"/> parameter</param>
/// <param name="i13"><typeparamref name="Index13"/> parameter</param>
/// <param name="i14"><typeparamref name="Index14"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, in Index6, in Index7, in Index8, in Index9, in Index10, in Index11, in Index12, in Index13, in Index14, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index14">Generic <typeparamref name="Index14"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14] => ref _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14, Value v) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Value> func) => new(func);
}

/// <summary>
/// Represents a read/write indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index14">Generic <typeparamref name="Index14"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index15">Generic <typeparamref name="Index15"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12) => new(
(i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13) => new(
(i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <returns>Partially applied indexer</returns>
    public Indexer<Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14) => new(
(i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15],(i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <param name="i15">Index no. 15</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14, Index15 i15]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value);
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);
    }

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> AsWriteOnly() => new(SetterFunction);

    /// <summary>
    /// Returns the write-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> AsReadOnly() => new(GetterFunction);

    /// <summary>
    /// Returns the read-only indexer derived from the given indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> getter, Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> setter)
    {
        SetterFunction = setter ?? throw new ArgumentNullException(nameof(setter));
        GetterFunction = getter ?? throw new ArgumentNullException(nameof(getter));
    }

    /// <summary>
    /// Creates a new indexer.
    /// </summary>
    /// <param name="getter">Getter function</param>
    /// <param name="setter">Setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Indexer(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> getter, WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> setter)
        : this(getter.AsFunction(), setter.AsFunction())
    {
    }
}

/// <summary>
/// Represents a write-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index14">Generic <typeparamref name="Index14"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index15">Generic <typeparamref name="Index15"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>
{
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> SetterFunction { get; private set; }
    // public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12, i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12) => new(
(i13, i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13) => new(
(i14, i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <returns>Partially applied indexer</returns>
    public WriteOnlyIndexer<Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14) => new(
(i15, value) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15] = value    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <param name="i15">Index no. 15</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14, Index15 i15]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        set => SetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, value);
    }

    /// <summary>
    /// Creates a new write-only indexer.
    /// </summary>
    /// <param name="func">The indexer's setter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> func) => SetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> AsFunction() => SetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> func) => new(func);
}

/// <summary>
/// Represents a read-only indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index14">Generic <typeparamref name="Index14"/> indexing type (the key type)</typeparam>
/// <typeparam name="Index15">Generic <typeparamref name="Index15"/> indexing type (the key type)</typeparam>
/// <typeparam name="Value">Generic value type</typeparam>
public sealed partial class ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>
{
    // public Action<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> SetterFunction { get; private set; }
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> GetterFunction { get; private set; }


    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1] => Curry(i1);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1) => new(
(i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2] => Curry(i1, i2);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2) => new(
(i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3] => Curry(i1, i2, i3);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3) => new(
(i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4] => Curry(i1, i2, i3, i4);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4) => new(
(i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5] => Curry(i1, i2, i3, i4, i5);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5) => new(
(i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6] => Curry(i1, i2, i3, i4, i5, i6);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6) => new(
(i7, i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7] => Curry(i1, i2, i3, i4, i5, i6, i7);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7) => new(
(i8, i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8] => Curry(i1, i2, i3, i4, i5, i6, i7, i8);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8) => new(
(i9, i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index10, Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9) => new(
(i10, i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index11, Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index11, Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10) => new(
(i11, i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index12, Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index12, Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11) => new(
(i12, i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index13, Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index13, Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12) => new(
(i13, i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index14, Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index14, Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13) => new(
(i14, i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's curryied accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index15, Value> this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14] => Curry(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14);

    /// <summary>
    /// Returns a partially applied indexer based on the given indices.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <returns>Partially applied indexer</returns>
    public ReadOnlyIndexer<Index15, Value> Curry(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14) => new(
(i15) => this[i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15]    );

    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <param name="i15">Index no. 15</param>
    /// <returns>Value</returns>
    public Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14, Index15 i15]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => GetterFunction(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);
    }

    /// <summary>
    /// Creates a new read-only indexer.
    /// </summary>
    /// <param name="func">The indexer's getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> func) => GetterFunction = func ?? throw new ArgumentNullException(nameof(func));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> AsFunction() => GetterFunction;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> indexer) => indexer.AsFunction();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(Func<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> func) => new(func);
}

/// <summary>
/// Represents a ref function of the form "Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15 -> <see langword="ref"/> Value".
/// </summary>
/// <inheritdoc cref="Func{Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value}"/>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> parameter type.</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> parameter type.</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> parameter type.</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> parameter type.</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> parameter type.</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> parameter type.</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> parameter type.</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> parameter type.</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> parameter type.</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> parameter type.</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> parameter type.</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> parameter type.</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> parameter type.</typeparam>
/// <typeparam name="Index14">Generic <typeparamref name="Index14"/> parameter type.</typeparam>
/// <typeparam name="Index15">Generic <typeparamref name="Index15"/> parameter type.</typeparam>
/// <typeparam name="Value">Generic <typeparamref name="Value"/> return type.</typeparam>
/// <param name="i1"><typeparamref name="Index1"/> parameter</param>
/// <param name="i2"><typeparamref name="Index2"/> parameter</param>
/// <param name="i3"><typeparamref name="Index3"/> parameter</param>
/// <param name="i4"><typeparamref name="Index4"/> parameter</param>
/// <param name="i5"><typeparamref name="Index5"/> parameter</param>
/// <param name="i6"><typeparamref name="Index6"/> parameter</param>
/// <param name="i7"><typeparamref name="Index7"/> parameter</param>
/// <param name="i8"><typeparamref name="Index8"/> parameter</param>
/// <param name="i9"><typeparamref name="Index9"/> parameter</param>
/// <param name="i10"><typeparamref name="Index10"/> parameter</param>
/// <param name="i11"><typeparamref name="Index11"/> parameter</param>
/// <param name="i12"><typeparamref name="Index12"/> parameter</param>
/// <param name="i13"><typeparamref name="Index13"/> parameter</param>
/// <param name="i14"><typeparamref name="Index14"/> parameter</param>
/// <param name="i15"><typeparamref name="Index15"/> parameter</param>
/// <returns><see langword="ref"/> <typeparamref name="Value"/> return value.</returns>
public delegate ref Value RefFunc<in Index1, in Index2, in Index3, in Index4, in Index5, in Index6, in Index7, in Index8, in Index9, in Index10, in Index11, in Index12, in Index13, in Index14, in Index15, Value>(Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14, Index15 i15);

/// <summary>
/// Represents a read/write <see langword="ref"/> indexer to be used for indexable properties.
/// </summary>
/// <typeparam name="Index1">Generic <typeparamref name="Index1"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index2">Generic <typeparamref name="Index2"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index3">Generic <typeparamref name="Index3"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index4">Generic <typeparamref name="Index4"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index5">Generic <typeparamref name="Index5"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index6">Generic <typeparamref name="Index6"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index7">Generic <typeparamref name="Index7"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index8">Generic <typeparamref name="Index8"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index9">Generic <typeparamref name="Index9"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index10">Generic <typeparamref name="Index10"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index11">Generic <typeparamref name="Index11"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index12">Generic <typeparamref name="Index12"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index13">Generic <typeparamref name="Index13"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index14">Generic <typeparamref name="Index14"/> indexing type (the key type).</typeparam>
/// <typeparam name="Index15">Generic <typeparamref name="Index15"/> indexing type (the key type).</typeparam>
/// <typeparam name="Value">Generic value type.</typeparam>
public sealed partial class RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>
{
    private readonly RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> _func;


    /// <summary>
    /// The indexer's accessor.
    /// </summary>
    /// <param name="i1">Index no. 1</param>
    /// <param name="i2">Index no. 2</param>
    /// <param name="i3">Index no. 3</param>
    /// <param name="i4">Index no. 4</param>
    /// <param name="i5">Index no. 5</param>
    /// <param name="i6">Index no. 6</param>
    /// <param name="i7">Index no. 7</param>
    /// <param name="i8">Index no. 8</param>
    /// <param name="i9">Index no. 9</param>
    /// <param name="i10">Index no. 10</param>
    /// <param name="i11">Index no. 11</param>
    /// <param name="i12">Index no. 12</param>
    /// <param name="i13">Index no. 13</param>
    /// <param name="i14">Index no. 14</param>
    /// <param name="i15">Index no. 15</param>
    /// <returns>Value reference</returns>
    public ref Value this[Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14, Index15 i15] => ref _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15);


    /// <summary>
    /// Creates a new ref indexer.
    /// </summary>
    /// <param name="func">Ref getter function</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefIndexer(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> func) => _func = func ?? throw new ArgumentNullException(nameof(func));

    public Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> AsIndexer() => new(AsReadOnly(), AsWriteOnly());

    /// <summary>
    /// Returns the read-only indexer derived from the current instance, which includes only the getter-function.
    /// </summary>
    /// <returns>The read-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> AsReadOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14, Index15 i15) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15));

    /// <summary>
    /// Returns the write-only indexer derived from the current instance, which includes only the setter-function.
    /// </summary>
    /// <returns>The write-only indexer.</returns>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> AsWriteOnly() => new((Index1 i1, Index2 i2, Index3 i3, Index4 i4, Index5 i5, Index6 i6, Index7 i7, Index8 i8, Index9 i9, Index10 i10, Index11 i11, Index12 i12, Index13 i13, Index14 i14, Index15 i15, Value v) => _func(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15) = v);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> AsFunction() => _func;

    /// <summary>
    /// Returns the ref function derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic ref indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> indexer) => indexer.AsFunction();

    /// <summary>
    /// Returns the read/write indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator Indexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> indexer) => indexer.AsIndexer();

    /// <summary>
    /// Returns the read-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> indexer) => indexer.AsReadOnly();

    /// <summary>
    /// Returns the write-only indexer derived from the given ref indexer.
    /// </summary>
    /// <param name="indexer">Generic indexer.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator WriteOnlyIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> indexer) => indexer.AsWriteOnly();

    /// <summary>
    /// Returns the ref indexer derived from the given ref function.
    /// </summary>
    /// <param name="func">Generic ref function.</param>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator RefIndexer<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value>(RefFunc<Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Index9, Index10, Index11, Index12, Index13, Index14, Index15, Value> func) => new(func);
}