upon 0.10.0

//! Code generated by *./tools/gen-functions*. DO NOT EDIT.

#![allow(clippy::needless_lifetimes)]

use std::collections::BTreeMap;

use crate::functions::args::{ListRef, MapRef, StringRef, ValueRef};
use crate::functions::{Function, FunctionArg, FunctionArgs, FunctionReturn};
use crate::Value;

#[doc(hidden)]
impl<Func, R> Function<R, (StringRef,)> for Func
where
    Func: Fn(&str) -> R,
    R: FunctionReturn,

    (StringRef,): for<'a> FunctionArgs<Output<'a> = (&'a str,)>,
{
    fn call<'a>(&self, (a,): (&'a str,)) -> R {
        self(a)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ListRef,)> for Func
where
    Func: Fn(&[Value]) -> R,
    R: FunctionReturn,

    (ListRef,): for<'a> FunctionArgs<Output<'a> = (&'a [Value],)>,
{
    fn call<'a>(&self, (a,): (&'a [Value],)) -> R {
        self(a)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (MapRef,)> for Func
where
    Func: Fn(&BTreeMap<String, Value>) -> R,
    R: FunctionReturn,

    (MapRef,): for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>,)>,
{
    fn call<'a>(&self, (a,): (&'a BTreeMap<String, Value>,)) -> R {
        self(a)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ValueRef,)> for Func
where
    Func: Fn(&Value) -> R,
    R: FunctionReturn,

    (ValueRef,): for<'a> FunctionArgs<Output<'a> = (&'a Value,)>,
{
    fn call<'a>(&self, (a,): (&'a Value,)) -> R {
        self(a)
    }
}

#[doc(hidden)]
impl<Func, R, A> Function<R, (A, StringRef)> for Func
where
    Func: Fn(A, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,

    (A, StringRef): for<'a> FunctionArgs<Output<'a> = (A, &'a str)>,
{
    fn call<'a>(&self, (a, b): (A, &'a str)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R, A> Function<R, (A, ValueRef)> for Func
where
    Func: Fn(A, &Value) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,

    (A, ValueRef): for<'a> FunctionArgs<Output<'a> = (A, &'a Value)>,
{
    fn call<'a>(&self, (a, b): (A, &'a Value)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (StringRef, B)> for Func
where
    Func: Fn(&str, B) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (StringRef, B): for<'a> FunctionArgs<Output<'a> = (&'a str, B)>,
{
    fn call<'a>(&self, (a, b): (&'a str, B)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (StringRef, StringRef)> for Func
where
    Func: Fn(&str, &str) -> R,
    R: FunctionReturn,

    (StringRef, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b): (&'a str, &'a str)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (StringRef, ValueRef)> for Func
where
    Func: Fn(&str, &Value) -> R,
    R: FunctionReturn,

    (StringRef, ValueRef): for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value)>,
{
    fn call<'a>(&self, (a, b): (&'a str, &'a Value)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (ListRef, B)> for Func
where
    Func: Fn(&[Value], B) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (ListRef, B): for<'a> FunctionArgs<Output<'a> = (&'a [Value], B)>,
{
    fn call<'a>(&self, (a, b): (&'a [Value], B)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ListRef, StringRef)> for Func
where
    Func: Fn(&[Value], &str) -> R,
    R: FunctionReturn,

    (ListRef, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str)>,
{
    fn call<'a>(&self, (a, b): (&'a [Value], &'a str)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ListRef, ValueRef)> for Func
where
    Func: Fn(&[Value], &Value) -> R,
    R: FunctionReturn,

    (ListRef, ValueRef): for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value)>,
{
    fn call<'a>(&self, (a, b): (&'a [Value], &'a Value)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (MapRef, B)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (MapRef, B): for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B)>,
{
    fn call<'a>(&self, (a, b): (&'a BTreeMap<String, Value>, B)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (MapRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str) -> R,
    R: FunctionReturn,

    (MapRef, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str)>,
{
    fn call<'a>(&self, (a, b): (&'a BTreeMap<String, Value>, &'a str)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (MapRef, ValueRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value) -> R,
    R: FunctionReturn,

    (MapRef, ValueRef): for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a Value)>,
{
    fn call<'a>(&self, (a, b): (&'a BTreeMap<String, Value>, &'a Value)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (ValueRef, B)> for Func
where
    Func: Fn(&Value, B) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (ValueRef, B): for<'a> FunctionArgs<Output<'a> = (&'a Value, B)>,
{
    fn call<'a>(&self, (a, b): (&'a Value, B)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ValueRef, StringRef)> for Func
where
    Func: Fn(&Value, &str) -> R,
    R: FunctionReturn,

    (ValueRef, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str)>,
{
    fn call<'a>(&self, (a, b): (&'a Value, &'a str)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ValueRef, ValueRef)> for Func
where
    Func: Fn(&Value, &Value) -> R,
    R: FunctionReturn,

    (ValueRef, ValueRef): for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value)>,
{
    fn call<'a>(&self, (a, b): (&'a Value, &'a Value)) -> R {
        self(a, b)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Function<R, (A, B, StringRef)> for Func
where
    Func: Fn(A, B, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,

    (A, B, StringRef): for<'a> FunctionArgs<Output<'a> = (A, B, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (A, B, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Function<R, (A, StringRef, C)> for Func
where
    Func: Fn(A, &str, C) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (A, StringRef, C): for<'a> FunctionArgs<Output<'a> = (A, &'a str, C)>,
{
    fn call<'a>(&self, (a, b, c): (A, &'a str, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A> Function<R, (A, StringRef, StringRef)> for Func
where
    Func: Fn(A, &str, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,

    (A, StringRef, StringRef): for<'a> FunctionArgs<Output<'a> = (A, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (A, &'a str, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Function<R, (A, ValueRef, C)> for Func
where
    Func: Fn(A, &Value, C) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (A, ValueRef, C): for<'a> FunctionArgs<Output<'a> = (A, &'a Value, C)>,
{
    fn call<'a>(&self, (a, b, c): (A, &'a Value, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A> Function<R, (A, ValueRef, StringRef)> for Func
where
    Func: Fn(A, &Value, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,

    (A, ValueRef, StringRef): for<'a> FunctionArgs<Output<'a> = (A, &'a Value, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (A, &'a Value, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (StringRef, B, C)> for Func
where
    Func: Fn(&str, B, C) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (StringRef, B, C): for<'a> FunctionArgs<Output<'a> = (&'a str, B, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a str, B, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (StringRef, B, StringRef)> for Func
where
    Func: Fn(&str, B, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (StringRef, B, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a str, B, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a str, B, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (StringRef, StringRef, C)> for Func
where
    Func: Fn(&str, &str, C) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (StringRef, StringRef, C): for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a str, &'a str, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&str, &str, &str) -> R,
    R: FunctionReturn,

    (StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a str, &'a str, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (StringRef, ValueRef, C)> for Func
where
    Func: Fn(&str, &Value, C) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (StringRef, ValueRef, C): for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a str, &'a Value, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (StringRef, ValueRef, StringRef)> for Func
where
    Func: Fn(&str, &Value, &str) -> R,
    R: FunctionReturn,

    (StringRef, ValueRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a str, &'a Value, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (ListRef, B, C)> for Func
where
    Func: Fn(&[Value], B, C) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (ListRef, B, C): for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a [Value], B, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (ListRef, B, StringRef)> for Func
where
    Func: Fn(&[Value], B, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (ListRef, B, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a [Value], B, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ListRef, StringRef, C)> for Func
where
    Func: Fn(&[Value], &str, C) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ListRef, StringRef, C): for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a [Value], &'a str, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ListRef, StringRef, StringRef)> for Func
where
    Func: Fn(&[Value], &str, &str) -> R,
    R: FunctionReturn,

    (ListRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a [Value], &'a str, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ListRef, ValueRef, C)> for Func
where
    Func: Fn(&[Value], &Value, C) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ListRef, ValueRef, C): for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a [Value], &'a Value, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ListRef, ValueRef, StringRef)> for Func
where
    Func: Fn(&[Value], &Value, &str) -> R,
    R: FunctionReturn,

    (ListRef, ValueRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a [Value], &'a Value, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (MapRef, B, C)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, C) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (MapRef, B, C): for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a BTreeMap<String, Value>, B, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (MapRef, B, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (MapRef, B, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a BTreeMap<String, Value>, B, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (MapRef, StringRef, C)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, C) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (MapRef, StringRef, C):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a BTreeMap<String, Value>, &'a str, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (MapRef, StringRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str) -> R,
    R: FunctionReturn,

    (MapRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a BTreeMap<String, Value>, &'a str, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (MapRef, ValueRef, C)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, C) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (MapRef, ValueRef, C):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a BTreeMap<String, Value>, &'a Value, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (MapRef, ValueRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, &str) -> R,
    R: FunctionReturn,

    (MapRef, ValueRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a BTreeMap<String, Value>, &'a Value, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (ValueRef, B, C)> for Func
where
    Func: Fn(&Value, B, C) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (ValueRef, B, C): for<'a> FunctionArgs<Output<'a> = (&'a Value, B, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a Value, B, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (ValueRef, B, StringRef)> for Func
where
    Func: Fn(&Value, B, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (ValueRef, B, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a Value, B, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a Value, B, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ValueRef, StringRef, C)> for Func
where
    Func: Fn(&Value, &str, C) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ValueRef, StringRef, C): for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a Value, &'a str, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ValueRef, StringRef, StringRef)> for Func
where
    Func: Fn(&Value, &str, &str) -> R,
    R: FunctionReturn,

    (ValueRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a Value, &'a str, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ValueRef, ValueRef, C)> for Func
where
    Func: Fn(&Value, &Value, C) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ValueRef, ValueRef, C): for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, C)>,
{
    fn call<'a>(&self, (a, b, c): (&'a Value, &'a Value, C)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ValueRef, ValueRef, StringRef)> for Func
where
    Func: Fn(&Value, &Value, &str) -> R,
    R: FunctionReturn,

    (ValueRef, ValueRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, &'a str)>,
{
    fn call<'a>(&self, (a, b, c): (&'a Value, &'a Value, &'a str)) -> R {
        self(a, b, c)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C> Function<R, (A, B, C, StringRef)> for Func
where
    Func: Fn(A, B, C, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (A, B, C, StringRef): for<'a> FunctionArgs<Output<'a> = (A, B, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, B, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, D> Function<R, (A, B, StringRef, D)> for Func
where
    Func: Fn(A, B, &str, D) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, B, StringRef, D): for<'a> FunctionArgs<Output<'a> = (A, B, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, B, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Function<R, (A, B, StringRef, StringRef)> for Func
where
    Func: Fn(A, B, &str, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,

    (A, B, StringRef, StringRef): for<'a> FunctionArgs<Output<'a> = (A, B, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, B, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, D> Function<R, (A, StringRef, C, D)> for Func
where
    Func: Fn(A, &str, C, D) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, StringRef, C, D): for<'a> FunctionArgs<Output<'a> = (A, &'a str, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, &'a str, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Function<R, (A, StringRef, C, StringRef)> for Func
where
    Func: Fn(A, &str, C, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (A, StringRef, C, StringRef): for<'a> FunctionArgs<Output<'a> = (A, &'a str, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, &'a str, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, D> Function<R, (A, StringRef, StringRef, D)> for Func
where
    Func: Fn(A, &str, &str, D) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, StringRef, StringRef, D): for<'a> FunctionArgs<Output<'a> = (A, &'a str, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, &'a str, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A> Function<R, (A, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(A, &str, &str, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,

    (A, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (A, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, D> Function<R, (A, ValueRef, C, D)> for Func
where
    Func: Fn(A, &Value, C, D) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, ValueRef, C, D): for<'a> FunctionArgs<Output<'a> = (A, &'a Value, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, &'a Value, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Function<R, (A, ValueRef, C, StringRef)> for Func
where
    Func: Fn(A, &Value, C, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (A, ValueRef, C, StringRef): for<'a> FunctionArgs<Output<'a> = (A, &'a Value, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, &'a Value, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, D> Function<R, (A, ValueRef, StringRef, D)> for Func
where
    Func: Fn(A, &Value, &str, D) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, ValueRef, StringRef, D): for<'a> FunctionArgs<Output<'a> = (A, &'a Value, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, &'a Value, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A> Function<R, (A, ValueRef, StringRef, StringRef)> for Func
where
    Func: Fn(A, &Value, &str, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,

    (A, ValueRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (A, &'a Value, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (A, &'a Value, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Function<R, (StringRef, B, C, D)> for Func
where
    Func: Fn(&str, B, C, D) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, B, C, D): for<'a> FunctionArgs<Output<'a> = (&'a str, B, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, B, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (StringRef, B, C, StringRef)> for Func
where
    Func: Fn(&str, B, C, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (StringRef, B, C, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a str, B, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, B, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Function<R, (StringRef, B, StringRef, D)> for Func
where
    Func: Fn(&str, B, &str, D) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, B, StringRef, D): for<'a> FunctionArgs<Output<'a> = (&'a str, B, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, B, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (StringRef, B, StringRef, StringRef)> for Func
where
    Func: Fn(&str, B, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (StringRef, B, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, B, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, B, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (StringRef, StringRef, C, D)> for Func
where
    Func: Fn(&str, &str, C, D) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, StringRef, C, D): for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, &'a str, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (StringRef, StringRef, C, StringRef)> for Func
where
    Func: Fn(&str, &str, C, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (StringRef, StringRef, C, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, &'a str, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (StringRef, StringRef, StringRef, D)> for Func
where
    Func: Fn(&str, &str, &str, D) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, StringRef, StringRef, D):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, &'a str, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (StringRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&str, &str, &str, &str) -> R,
    R: FunctionReturn,

    (StringRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (StringRef, ValueRef, C, D)> for Func
where
    Func: Fn(&str, &Value, C, D) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, ValueRef, C, D): for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, &'a Value, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (StringRef, ValueRef, C, StringRef)> for Func
where
    Func: Fn(&str, &Value, C, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (StringRef, ValueRef, C, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, &'a Value, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (StringRef, ValueRef, StringRef, D)> for Func
where
    Func: Fn(&str, &Value, &str, D) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, ValueRef, StringRef, D):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, &'a Value, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (StringRef, ValueRef, StringRef, StringRef)> for Func
where
    Func: Fn(&str, &Value, &str, &str) -> R,
    R: FunctionReturn,

    (StringRef, ValueRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a str, &'a Value, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Function<R, (ListRef, B, C, D)> for Func
where
    Func: Fn(&[Value], B, C, D) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, B, C, D): for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], B, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (ListRef, B, C, StringRef)> for Func
where
    Func: Fn(&[Value], B, C, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (ListRef, B, C, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], B, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Function<R, (ListRef, B, StringRef, D)> for Func
where
    Func: Fn(&[Value], B, &str, D) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, B, StringRef, D): for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], B, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (ListRef, B, StringRef, StringRef)> for Func
where
    Func: Fn(&[Value], B, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (ListRef, B, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], B, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (ListRef, StringRef, C, D)> for Func
where
    Func: Fn(&[Value], &str, C, D) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, StringRef, C, D): for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], &'a str, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ListRef, StringRef, C, StringRef)> for Func
where
    Func: Fn(&[Value], &str, C, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ListRef, StringRef, C, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], &'a str, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (ListRef, StringRef, StringRef, D)> for Func
where
    Func: Fn(&[Value], &str, &str, D) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, StringRef, StringRef, D):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], &'a str, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ListRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&[Value], &str, &str, &str) -> R,
    R: FunctionReturn,

    (ListRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (ListRef, ValueRef, C, D)> for Func
where
    Func: Fn(&[Value], &Value, C, D) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, ValueRef, C, D): for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], &'a Value, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ListRef, ValueRef, C, StringRef)> for Func
where
    Func: Fn(&[Value], &Value, C, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ListRef, ValueRef, C, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], &'a Value, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (ListRef, ValueRef, StringRef, D)> for Func
where
    Func: Fn(&[Value], &Value, &str, D) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, ValueRef, StringRef, D):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], &'a Value, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ListRef, ValueRef, StringRef, StringRef)> for Func
where
    Func: Fn(&[Value], &Value, &str, &str) -> R,
    R: FunctionReturn,

    (ListRef, ValueRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a [Value], &'a Value, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Function<R, (MapRef, B, C, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, C, D) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, B, C, D): for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a BTreeMap<String, Value>, B, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (MapRef, B, C, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, C, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (MapRef, B, C, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a BTreeMap<String, Value>, B, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Function<R, (MapRef, B, StringRef, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, &str, D) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, B, StringRef, D):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a BTreeMap<String, Value>, B, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (MapRef, B, StringRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (MapRef, B, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a BTreeMap<String, Value>, B, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (MapRef, StringRef, C, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, C, D) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, StringRef, C, D):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (MapRef, StringRef, C, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, C, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (MapRef, StringRef, C, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (MapRef, StringRef, StringRef, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, D) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, StringRef, StringRef, D):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (MapRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, &str) -> R,
    R: FunctionReturn,

    (MapRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(
        &self,
        (a, b, c, d): (&'a BTreeMap<String, Value>, &'a str, &'a str, &'a str),
    ) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (MapRef, ValueRef, C, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, C, D) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, ValueRef, C, D):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a BTreeMap<String, Value>, &'a Value, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (MapRef, ValueRef, C, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, C, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (MapRef, ValueRef, C, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a BTreeMap<String, Value>, &'a Value, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (MapRef, ValueRef, StringRef, D)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, &str, D) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, ValueRef, StringRef, D):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a BTreeMap<String, Value>, &'a Value, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (MapRef, ValueRef, StringRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, &str, &str) -> R,
    R: FunctionReturn,

    (MapRef, ValueRef, StringRef, StringRef): for<'a> FunctionArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, &'a str, &'a str),
    >,
{
    fn call<'a>(
        &self,
        (a, b, c, d): (&'a BTreeMap<String, Value>, &'a Value, &'a str, &'a str),
    ) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Function<R, (ValueRef, B, C, D)> for Func
where
    Func: Fn(&Value, B, C, D) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, B, C, D): for<'a> FunctionArgs<Output<'a> = (&'a Value, B, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, B, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (ValueRef, B, C, StringRef)> for Func
where
    Func: Fn(&Value, B, C, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (ValueRef, B, C, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a Value, B, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, B, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Function<R, (ValueRef, B, StringRef, D)> for Func
where
    Func: Fn(&Value, B, &str, D) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, B, StringRef, D): for<'a> FunctionArgs<Output<'a> = (&'a Value, B, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, B, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (ValueRef, B, StringRef, StringRef)> for Func
where
    Func: Fn(&Value, B, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (ValueRef, B, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, B, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, B, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (ValueRef, StringRef, C, D)> for Func
where
    Func: Fn(&Value, &str, C, D) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, StringRef, C, D): for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, &'a str, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ValueRef, StringRef, C, StringRef)> for Func
where
    Func: Fn(&Value, &str, C, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ValueRef, StringRef, C, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, &'a str, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (ValueRef, StringRef, StringRef, D)> for Func
where
    Func: Fn(&Value, &str, &str, D) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, StringRef, StringRef, D):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, &'a str, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ValueRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&Value, &str, &str, &str) -> R,
    R: FunctionReturn,

    (ValueRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (ValueRef, ValueRef, C, D)> for Func
where
    Func: Fn(&Value, &Value, C, D) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, ValueRef, C, D): for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, C, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, &'a Value, C, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ValueRef, ValueRef, C, StringRef)> for Func
where
    Func: Fn(&Value, &Value, C, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ValueRef, ValueRef, C, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, C, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, &'a Value, C, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (ValueRef, ValueRef, StringRef, D)> for Func
where
    Func: Fn(&Value, &Value, &str, D) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, ValueRef, StringRef, D):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, &'a str, D)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, &'a Value, &'a str, D)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ValueRef, ValueRef, StringRef, StringRef)> for Func
where
    Func: Fn(&Value, &Value, &str, &str) -> R,
    R: FunctionReturn,

    (ValueRef, ValueRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d): (&'a Value, &'a Value, &'a str, &'a str)) -> R {
        self(a, b, c, d)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C, D> Function<R, (A, B, C, D, StringRef)> for Func
where
    Func: Fn(A, B, C, D, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, B, C, D, StringRef): for<'a> FunctionArgs<Output<'a> = (A, B, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, B, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C, E> Function<R, (A, B, C, StringRef, E)> for Func
where
    Func: Fn(A, B, C, &str, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, B, C, StringRef, E): for<'a> FunctionArgs<Output<'a> = (A, B, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, B, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, C> Function<R, (A, B, C, StringRef, StringRef)> for Func
where
    Func: Fn(A, B, C, &str, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (A, B, C, StringRef, StringRef): for<'a> FunctionArgs<Output<'a> = (A, B, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, B, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, D, E> Function<R, (A, B, StringRef, D, E)> for Func
where
    Func: Fn(A, B, &str, D, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, B, StringRef, D, E): for<'a> FunctionArgs<Output<'a> = (A, B, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, B, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, D> Function<R, (A, B, StringRef, D, StringRef)> for Func
where
    Func: Fn(A, B, &str, D, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, B, StringRef, D, StringRef): for<'a> FunctionArgs<Output<'a> = (A, B, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, B, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, B, E> Function<R, (A, B, StringRef, StringRef, E)> for Func
where
    Func: Fn(A, B, &str, &str, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, B, StringRef, StringRef, E): for<'a> FunctionArgs<Output<'a> = (A, B, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, B, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, B> Function<R, (A, B, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(A, B, &str, &str, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    B: for<'a> FunctionArg<Output<'a> = B>,

    (A, B, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (A, B, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, B, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, D, E> Function<R, (A, StringRef, C, D, E)> for Func
where
    Func: Fn(A, &str, C, D, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, StringRef, C, D, E): for<'a> FunctionArgs<Output<'a> = (A, &'a str, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a str, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, D> Function<R, (A, StringRef, C, D, StringRef)> for Func
where
    Func: Fn(A, &str, C, D, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, StringRef, C, D, StringRef): for<'a> FunctionArgs<Output<'a> = (A, &'a str, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a str, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, E> Function<R, (A, StringRef, C, StringRef, E)> for Func
where
    Func: Fn(A, &str, C, &str, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, StringRef, C, StringRef, E): for<'a> FunctionArgs<Output<'a> = (A, &'a str, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a str, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Function<R, (A, StringRef, C, StringRef, StringRef)> for Func
where
    Func: Fn(A, &str, C, &str, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (A, StringRef, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (A, &'a str, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a str, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, D, E> Function<R, (A, StringRef, StringRef, D, E)> for Func
where
    Func: Fn(A, &str, &str, D, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, StringRef, StringRef, D, E): for<'a> FunctionArgs<Output<'a> = (A, &'a str, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a str, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, D> Function<R, (A, StringRef, StringRef, D, StringRef)> for Func
where
    Func: Fn(A, &str, &str, D, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, StringRef, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (A, &'a str, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a str, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, E> Function<R, (A, StringRef, StringRef, StringRef, E)> for Func
where
    Func: Fn(A, &str, &str, &str, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, StringRef, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (A, &'a str, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a str, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A> Function<R, (A, StringRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(A, &str, &str, &str, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,

    (A, StringRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (A, &'a str, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a str, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, D, E> Function<R, (A, ValueRef, C, D, E)> for Func
where
    Func: Fn(A, &Value, C, D, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, ValueRef, C, D, E): for<'a> FunctionArgs<Output<'a> = (A, &'a Value, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a Value, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, D> Function<R, (A, ValueRef, C, D, StringRef)> for Func
where
    Func: Fn(A, &Value, C, D, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, ValueRef, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (A, &'a Value, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a Value, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, C, E> Function<R, (A, ValueRef, C, StringRef, E)> for Func
where
    Func: Fn(A, &Value, C, &str, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, ValueRef, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (A, &'a Value, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a Value, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, C> Function<R, (A, ValueRef, C, StringRef, StringRef)> for Func
where
    Func: Fn(A, &Value, C, &str, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (A, ValueRef, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (A, &'a Value, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a Value, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, D, E> Function<R, (A, ValueRef, StringRef, D, E)> for Func
where
    Func: Fn(A, &Value, &str, D, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, ValueRef, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (A, &'a Value, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a Value, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, D> Function<R, (A, ValueRef, StringRef, D, StringRef)> for Func
where
    Func: Fn(A, &Value, &str, D, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (A, ValueRef, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (A, &'a Value, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a Value, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A, E> Function<R, (A, ValueRef, StringRef, StringRef, E)> for Func
where
    Func: Fn(A, &Value, &str, &str, E) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (A, ValueRef, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (A, &'a Value, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a Value, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, A> Function<R, (A, ValueRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(A, &Value, &str, &str, &str) -> R,
    R: FunctionReturn,

    A: for<'a> FunctionArg<Output<'a> = A>,

    (A, ValueRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (A, &'a Value, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (A, &'a Value, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D, E> Function<R, (StringRef, B, C, D, E)> for Func
where
    Func: Fn(&str, B, C, D, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, B, C, D, E): for<'a> FunctionArgs<Output<'a> = (&'a str, B, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, B, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Function<R, (StringRef, B, C, D, StringRef)> for Func
where
    Func: Fn(&str, B, C, D, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, B, C, D, StringRef): for<'a> FunctionArgs<Output<'a> = (&'a str, B, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, B, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, E> Function<R, (StringRef, B, C, StringRef, E)> for Func
where
    Func: Fn(&str, B, C, &str, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, B, C, StringRef, E): for<'a> FunctionArgs<Output<'a> = (&'a str, B, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, B, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (StringRef, B, C, StringRef, StringRef)> for Func
where
    Func: Fn(&str, B, C, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (StringRef, B, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, B, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, B, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, D, E> Function<R, (StringRef, B, StringRef, D, E)> for Func
where
    Func: Fn(&str, B, &str, D, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, B, StringRef, D, E): for<'a> FunctionArgs<Output<'a> = (&'a str, B, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, B, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Function<R, (StringRef, B, StringRef, D, StringRef)> for Func
where
    Func: Fn(&str, B, &str, D, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, B, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, B, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, B, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, E> Function<R, (StringRef, B, StringRef, StringRef, E)> for Func
where
    Func: Fn(&str, B, &str, &str, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, B, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a str, B, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, B, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (StringRef, B, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&str, B, &str, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (StringRef, B, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, B, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, B, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D, E> Function<R, (StringRef, StringRef, C, D, E)> for Func
where
    Func: Fn(&str, &str, C, D, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, StringRef, C, D, E): for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a str, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (StringRef, StringRef, C, D, StringRef)> for Func
where
    Func: Fn(&str, &str, C, D, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, StringRef, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a str, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, E> Function<R, (StringRef, StringRef, C, StringRef, E)> for Func
where
    Func: Fn(&str, &str, C, &str, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, StringRef, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a str, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (StringRef, StringRef, C, StringRef, StringRef)> for Func
where
    Func: Fn(&str, &str, C, &str, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (StringRef, StringRef, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a str, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D, E> Function<R, (StringRef, StringRef, StringRef, D, E)> for Func
where
    Func: Fn(&str, &str, &str, D, E) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, StringRef, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a str, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (StringRef, StringRef, StringRef, D, StringRef)> for Func
where
    Func: Fn(&str, &str, &str, D, &str) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, StringRef, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a str, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, E> Function<R, (StringRef, StringRef, StringRef, StringRef, E)> for Func
where
    Func: Fn(&str, &str, &str, &str, E) -> R,
    R: FunctionReturn,

    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, StringRef, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a str, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (StringRef, StringRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&str, &str, &str, &str, &str) -> R,
    R: FunctionReturn,

    (StringRef, StringRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a str, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a str, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D, E> Function<R, (StringRef, ValueRef, C, D, E)> for Func
where
    Func: Fn(&str, &Value, C, D, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, ValueRef, C, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a Value, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (StringRef, ValueRef, C, D, StringRef)> for Func
where
    Func: Fn(&str, &Value, C, D, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, ValueRef, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a Value, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, E> Function<R, (StringRef, ValueRef, C, StringRef, E)> for Func
where
    Func: Fn(&str, &Value, C, &str, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, ValueRef, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a Value, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (StringRef, ValueRef, C, StringRef, StringRef)> for Func
where
    Func: Fn(&str, &Value, C, &str, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (StringRef, ValueRef, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a Value, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D, E> Function<R, (StringRef, ValueRef, StringRef, D, E)> for Func
where
    Func: Fn(&str, &Value, &str, D, E) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, ValueRef, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a Value, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (StringRef, ValueRef, StringRef, D, StringRef)> for Func
where
    Func: Fn(&str, &Value, &str, D, &str) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (StringRef, ValueRef, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a Value, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, E> Function<R, (StringRef, ValueRef, StringRef, StringRef, E)> for Func
where
    Func: Fn(&str, &Value, &str, &str, E) -> R,
    R: FunctionReturn,

    E: for<'a> FunctionArg<Output<'a> = E>,

    (StringRef, ValueRef, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a Value, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (StringRef, ValueRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&str, &Value, &str, &str, &str) -> R,
    R: FunctionReturn,

    (StringRef, ValueRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a str, &'a Value, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a str, &'a Value, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D, E> Function<R, (ListRef, B, C, D, E)> for Func
where
    Func: Fn(&[Value], B, C, D, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, B, C, D, E): for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], B, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Function<R, (ListRef, B, C, D, StringRef)> for Func
where
    Func: Fn(&[Value], B, C, D, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, B, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], B, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, E> Function<R, (ListRef, B, C, StringRef, E)> for Func
where
    Func: Fn(&[Value], B, C, &str, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, B, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], B, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (ListRef, B, C, StringRef, StringRef)> for Func
where
    Func: Fn(&[Value], B, C, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (ListRef, B, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], B, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, D, E> Function<R, (ListRef, B, StringRef, D, E)> for Func
where
    Func: Fn(&[Value], B, &str, D, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, B, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], B, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Function<R, (ListRef, B, StringRef, D, StringRef)> for Func
where
    Func: Fn(&[Value], B, &str, D, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, B, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], B, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, E> Function<R, (ListRef, B, StringRef, StringRef, E)> for Func
where
    Func: Fn(&[Value], B, &str, &str, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, B, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], B, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (ListRef, B, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&[Value], B, &str, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (ListRef, B, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], B, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], B, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D, E> Function<R, (ListRef, StringRef, C, D, E)> for Func
where
    Func: Fn(&[Value], &str, C, D, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, StringRef, C, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a str, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (ListRef, StringRef, C, D, StringRef)> for Func
where
    Func: Fn(&[Value], &str, C, D, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, StringRef, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a str, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, E> Function<R, (ListRef, StringRef, C, StringRef, E)> for Func
where
    Func: Fn(&[Value], &str, C, &str, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, StringRef, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a str, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ListRef, StringRef, C, StringRef, StringRef)> for Func
where
    Func: Fn(&[Value], &str, C, &str, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ListRef, StringRef, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a str, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D, E> Function<R, (ListRef, StringRef, StringRef, D, E)> for Func
where
    Func: Fn(&[Value], &str, &str, D, E) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, StringRef, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a str, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (ListRef, StringRef, StringRef, D, StringRef)> for Func
where
    Func: Fn(&[Value], &str, &str, D, &str) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, StringRef, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a str, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, E> Function<R, (ListRef, StringRef, StringRef, StringRef, E)> for Func
where
    Func: Fn(&[Value], &str, &str, &str, E) -> R,
    R: FunctionReturn,

    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, StringRef, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a str, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ListRef, StringRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&[Value], &str, &str, &str, &str) -> R,
    R: FunctionReturn,

    (ListRef, StringRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a str, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a str, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D, E> Function<R, (ListRef, ValueRef, C, D, E)> for Func
where
    Func: Fn(&[Value], &Value, C, D, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, ValueRef, C, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a Value, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (ListRef, ValueRef, C, D, StringRef)> for Func
where
    Func: Fn(&[Value], &Value, C, D, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, ValueRef, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a Value, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, E> Function<R, (ListRef, ValueRef, C, StringRef, E)> for Func
where
    Func: Fn(&[Value], &Value, C, &str, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, ValueRef, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a Value, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ListRef, ValueRef, C, StringRef, StringRef)> for Func
where
    Func: Fn(&[Value], &Value, C, &str, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ListRef, ValueRef, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a Value, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D, E> Function<R, (ListRef, ValueRef, StringRef, D, E)> for Func
where
    Func: Fn(&[Value], &Value, &str, D, E) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, ValueRef, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a Value, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (ListRef, ValueRef, StringRef, D, StringRef)> for Func
where
    Func: Fn(&[Value], &Value, &str, D, &str) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (ListRef, ValueRef, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a Value, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, E> Function<R, (ListRef, ValueRef, StringRef, StringRef, E)> for Func
where
    Func: Fn(&[Value], &Value, &str, &str, E) -> R,
    R: FunctionReturn,

    E: for<'a> FunctionArg<Output<'a> = E>,

    (ListRef, ValueRef, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a Value, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ListRef, ValueRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&[Value], &Value, &str, &str, &str) -> R,
    R: FunctionReturn,

    (ListRef, ValueRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a [Value], &'a Value, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a [Value], &'a Value, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D, E> Function<R, (MapRef, B, C, D, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, C, D, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, B, C, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a BTreeMap<String, Value>, B, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Function<R, (MapRef, B, C, D, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, C, D, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, B, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a BTreeMap<String, Value>, B, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, E> Function<R, (MapRef, B, C, StringRef, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, C, &str, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, B, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a BTreeMap<String, Value>, B, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (MapRef, B, C, StringRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, C, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (MapRef, B, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, C, &'a str, &'a str)>,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, B, C, &'a str, &'a str),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, D, E> Function<R, (MapRef, B, StringRef, D, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, &str, D, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, B, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a BTreeMap<String, Value>, B, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Function<R, (MapRef, B, StringRef, D, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, &str, D, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, B, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, &'a str, D, &'a str)>,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, B, &'a str, D, &'a str),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, E> Function<R, (MapRef, B, StringRef, StringRef, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, &str, &str, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, B, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, B, &'a str, &'a str, E)>,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, B, &'a str, &'a str, E),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (MapRef, B, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, B, &str, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (MapRef, B, StringRef, StringRef, StringRef): for<'a> FunctionArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, B, &'a str, &'a str, &'a str),
    >,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, B, &'a str, &'a str, &'a str),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D, E> Function<R, (MapRef, StringRef, C, D, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, C, D, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, StringRef, C, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a str, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (MapRef, StringRef, C, D, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, C, D, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, StringRef, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, C, D, &'a str)>,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a str, C, D, &'a str),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, E> Function<R, (MapRef, StringRef, C, StringRef, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, C, &str, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, StringRef, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, C, &'a str, E)>,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a str, C, &'a str, E),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (MapRef, StringRef, C, StringRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, C, &str, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (MapRef, StringRef, C, StringRef, StringRef): for<'a> FunctionArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, &'a str, C, &'a str, &'a str),
    >,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a str, C, &'a str, &'a str),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D, E> Function<R, (MapRef, StringRef, StringRef, D, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, D, E) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, StringRef, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str, D, E)>,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a str, &'a str, D, E),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (MapRef, StringRef, StringRef, D, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, D, &str) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, StringRef, StringRef, D, StringRef): for<'a> FunctionArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str, D, &'a str),
    >,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a str, &'a str, D, &'a str),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, E> Function<R, (MapRef, StringRef, StringRef, StringRef, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, &str, E) -> R,
    R: FunctionReturn,

    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, StringRef, StringRef, StringRef, E): for<'a> FunctionArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, &'a str, &'a str, &'a str, E),
    >,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a str, &'a str, &'a str, E),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (MapRef, StringRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &str, &str, &str, &str) -> R,
    R: FunctionReturn,

    (MapRef, StringRef, StringRef, StringRef, StringRef): for<'a> FunctionArgs<
        Output<'a> = (
            &'a BTreeMap<String, Value>,
            &'a str,
            &'a str,
            &'a str,
            &'a str,
        ),
    >,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (
            &'a BTreeMap<String, Value>,
            &'a str,
            &'a str,
            &'a str,
            &'a str,
        ),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D, E> Function<R, (MapRef, ValueRef, C, D, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, C, D, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, ValueRef, C, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a Value, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (MapRef, ValueRef, C, D, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, C, D, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, ValueRef, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, C, D, &'a str)>,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a Value, C, D, &'a str),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, E> Function<R, (MapRef, ValueRef, C, StringRef, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, C, &str, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, ValueRef, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, C, &'a str, E)>,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a Value, C, &'a str, E),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (MapRef, ValueRef, C, StringRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, C, &str, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (MapRef, ValueRef, C, StringRef, StringRef): for<'a> FunctionArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, C, &'a str, &'a str),
    >,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a Value, C, &'a str, &'a str),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D, E> Function<R, (MapRef, ValueRef, StringRef, D, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, &str, D, E) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, ValueRef, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, &'a str, D, E)>,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a Value, &'a str, D, E),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (MapRef, ValueRef, StringRef, D, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, &str, D, &str) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (MapRef, ValueRef, StringRef, D, StringRef): for<'a> FunctionArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, &'a str, D, &'a str),
    >,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a Value, &'a str, D, &'a str),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, E> Function<R, (MapRef, ValueRef, StringRef, StringRef, E)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, &str, &str, E) -> R,
    R: FunctionReturn,

    E: for<'a> FunctionArg<Output<'a> = E>,

    (MapRef, ValueRef, StringRef, StringRef, E): for<'a> FunctionArgs<
        Output<'a> = (&'a BTreeMap<String, Value>, &'a Value, &'a str, &'a str, E),
    >,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (&'a BTreeMap<String, Value>, &'a Value, &'a str, &'a str, E),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (MapRef, ValueRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&BTreeMap<String, Value>, &Value, &str, &str, &str) -> R,
    R: FunctionReturn,

    (MapRef, ValueRef, StringRef, StringRef, StringRef): for<'a> FunctionArgs<
        Output<'a> = (
            &'a BTreeMap<String, Value>,
            &'a Value,
            &'a str,
            &'a str,
            &'a str,
        ),
    >,
{
    fn call<'a>(
        &self,
        (a, b, c, d, e): (
            &'a BTreeMap<String, Value>,
            &'a Value,
            &'a str,
            &'a str,
            &'a str,
        ),
    ) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D, E> Function<R, (ValueRef, B, C, D, E)> for Func
where
    Func: Fn(&Value, B, C, D, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, B, C, D, E): for<'a> FunctionArgs<Output<'a> = (&'a Value, B, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, B, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, D> Function<R, (ValueRef, B, C, D, StringRef)> for Func
where
    Func: Fn(&Value, B, C, D, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, B, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, B, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, B, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C, E> Function<R, (ValueRef, B, C, StringRef, E)> for Func
where
    Func: Fn(&Value, B, C, &str, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, B, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, B, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, B, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, C> Function<R, (ValueRef, B, C, StringRef, StringRef)> for Func
where
    Func: Fn(&Value, B, C, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    C: for<'a> FunctionArg<Output<'a> = C>,

    (ValueRef, B, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, B, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, B, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, D, E> Function<R, (ValueRef, B, StringRef, D, E)> for Func
where
    Func: Fn(&Value, B, &str, D, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, B, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, B, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, B, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, D> Function<R, (ValueRef, B, StringRef, D, StringRef)> for Func
where
    Func: Fn(&Value, B, &str, D, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, B, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, B, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, B, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B, E> Function<R, (ValueRef, B, StringRef, StringRef, E)> for Func
where
    Func: Fn(&Value, B, &str, &str, E) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, B, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, B, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, B, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, B> Function<R, (ValueRef, B, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&Value, B, &str, &str, &str) -> R,
    R: FunctionReturn,

    B: for<'a> FunctionArg<Output<'a> = B>,

    (ValueRef, B, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, B, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, B, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D, E> Function<R, (ValueRef, StringRef, C, D, E)> for Func
where
    Func: Fn(&Value, &str, C, D, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, StringRef, C, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a str, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (ValueRef, StringRef, C, D, StringRef)> for Func
where
    Func: Fn(&Value, &str, C, D, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, StringRef, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a str, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, E> Function<R, (ValueRef, StringRef, C, StringRef, E)> for Func
where
    Func: Fn(&Value, &str, C, &str, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, StringRef, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a str, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ValueRef, StringRef, C, StringRef, StringRef)> for Func
where
    Func: Fn(&Value, &str, C, &str, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ValueRef, StringRef, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a str, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D, E> Function<R, (ValueRef, StringRef, StringRef, D, E)> for Func
where
    Func: Fn(&Value, &str, &str, D, E) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, StringRef, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a str, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (ValueRef, StringRef, StringRef, D, StringRef)> for Func
where
    Func: Fn(&Value, &str, &str, D, &str) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, StringRef, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a str, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, E> Function<R, (ValueRef, StringRef, StringRef, StringRef, E)> for Func
where
    Func: Fn(&Value, &str, &str, &str, E) -> R,
    R: FunctionReturn,

    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, StringRef, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a str, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ValueRef, StringRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&Value, &str, &str, &str, &str) -> R,
    R: FunctionReturn,

    (ValueRef, StringRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a str, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a str, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D, E> Function<R, (ValueRef, ValueRef, C, D, E)> for Func
where
    Func: Fn(&Value, &Value, C, D, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, ValueRef, C, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, C, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a Value, C, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, D> Function<R, (ValueRef, ValueRef, C, D, StringRef)> for Func
where
    Func: Fn(&Value, &Value, C, D, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, ValueRef, C, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, C, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a Value, C, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C, E> Function<R, (ValueRef, ValueRef, C, StringRef, E)> for Func
where
    Func: Fn(&Value, &Value, C, &str, E) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, ValueRef, C, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, C, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a Value, C, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, C> Function<R, (ValueRef, ValueRef, C, StringRef, StringRef)> for Func
where
    Func: Fn(&Value, &Value, C, &str, &str) -> R,
    R: FunctionReturn,

    C: for<'a> FunctionArg<Output<'a> = C>,

    (ValueRef, ValueRef, C, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, C, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a Value, C, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D, E> Function<R, (ValueRef, ValueRef, StringRef, D, E)> for Func
where
    Func: Fn(&Value, &Value, &str, D, E) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,
    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, ValueRef, StringRef, D, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, &'a str, D, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a Value, &'a str, D, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, D> Function<R, (ValueRef, ValueRef, StringRef, D, StringRef)> for Func
where
    Func: Fn(&Value, &Value, &str, D, &str) -> R,
    R: FunctionReturn,

    D: for<'a> FunctionArg<Output<'a> = D>,

    (ValueRef, ValueRef, StringRef, D, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, &'a str, D, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a Value, &'a str, D, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R, E> Function<R, (ValueRef, ValueRef, StringRef, StringRef, E)> for Func
where
    Func: Fn(&Value, &Value, &str, &str, E) -> R,
    R: FunctionReturn,

    E: for<'a> FunctionArg<Output<'a> = E>,

    (ValueRef, ValueRef, StringRef, StringRef, E):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, &'a str, &'a str, E)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a Value, &'a str, &'a str, E)) -> R {
        self(a, b, c, d, e)
    }
}

#[doc(hidden)]
impl<Func, R> Function<R, (ValueRef, ValueRef, StringRef, StringRef, StringRef)> for Func
where
    Func: Fn(&Value, &Value, &str, &str, &str) -> R,
    R: FunctionReturn,

    (ValueRef, ValueRef, StringRef, StringRef, StringRef):
        for<'a> FunctionArgs<Output<'a> = (&'a Value, &'a Value, &'a str, &'a str, &'a str)>,
{
    fn call<'a>(&self, (a, b, c, d, e): (&'a Value, &'a Value, &'a str, &'a str, &'a str)) -> R {
        self(a, b, c, d, e)
    }
}