ironcalc_base 0.7.1

use std::array::IntoIter;

use crate::{
    calc_result::CalcResult,
    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
    language::{get_default_language, Functions, Language},
    model::Model,
};

pub(crate) mod binary_search;
mod database;
mod date_and_time;
mod engineering;
mod financial;
mod financial_util;
mod information;
mod logical;
mod lookup_and_reference;
mod macros;
mod math_util;
mod mathematical;
mod mathematical_sum;
mod statistical;
mod subtotal;
mod text;
mod text_util;
pub(crate) mod util;
mod xlookup;

/// List of all implemented functions
#[derive(PartialEq, Clone, Debug)]
pub enum Function {
    // Logical
    And,
    False,
    If,
    Iferror,
    Ifna,
    Ifs,
    Not,
    Or,
    Switch,
    True,
    Xor,

    // Mathematical and trigonometry
    Abs,
    Acos,
    Acosh,
    Asin,
    Asinh,
    Atan,
    Atan2,
    Atanh,
    Choose,
    Column,
    Columns,
    Cos,
    Cosh,
    Log,
    Log10,
    Ln,
    Max,
    Min,
    Pi,
    Power,
    Product,
    Rand,
    Randbetween,
    Round,
    Rounddown,
    Roundup,
    Sin,
    Sinh,
    Sqrt,
    Sqrtpi,
    Sum,
    Sumif,
    Sumifs,
    Sumx2my2,
    Sumx2py2,
    Sumxmy2,
    Tan,
    Tanh,
    Acot,
    Acoth,
    Cot,
    Coth,
    Csc,
    Csch,
    Sec,
    Sech,
    Exp,
    Fact,
    Factdouble,
    Sign,
    Radians,
    Degrees,
    Int,
    Even,
    Odd,
    Ceiling,
    CeilingMath,
    CeilingPrecise,
    Floor,
    FloorMath,
    FloorPrecise,
    IsoCeiling,
    Mod,
    Quotient,
    Mround,
    Trunc,
    Gcd,
    Lcm,
    Base,
    Decimal,
    Roman,
    Arabic,
    Combin,
    Combina,
    Sumsq,

    // Information
    ErrorType,
    Formulatext,
    Isblank,
    Iserr,
    Iserror,
    Iseven,
    Isformula,
    Islogical,
    Isna,
    Isnontext,
    Isnumber,
    Isodd,
    Isref,
    Istext,
    Na,
    Sheet,
    Type,

    Sheets,
    N,
    Cell,
    Info,

    // Lookup and reference
    Hlookup,
    Index,
    Indirect,
    Lookup,
    Match,
    Offset,
    Row,
    Rows,
    Vlookup,
    Xlookup,

    // Text
    Concat,
    Concatenate,
    Exact,
    Find,
    Left,
    Len,
    Lower,
    Mid,
    Rept,
    Right,
    Search,
    Substitute,
    T,
    Text,
    Textafter,
    Textbefore,
    Textjoin,
    Trim,
    Unicode,
    Upper,
    Value,
    Valuetotext,

    // Statistical
    Average,
    Averagea,
    Averageif,
    Averageifs,
    Count,
    Counta,
    Countblank,
    Countif,
    Countifs,
    Maxifs,
    Minifs,
    Geomean,

    Avedev,
    BetaDist,
    BetaInv,
    BinomDist,
    BinomDistRange,
    BinomInv,
    ChisqDist,
    ChisqDistRT,
    ChisqInv,
    ChisqInvRT,
    ChisqTest,
    ConfidenceNorm,
    ConfidenceT,
    CovarianceP,
    CovarianceS,
    Devsq,
    ExponDist,
    FDist,
    FDistRT,
    FInv,
    FInvRT,
    FTest,
    Fisher,
    FisherInv,
    // Forecast,
    Gamma,
    GammaDist,
    GammaInv,
    GammaLn,
    GammaLnPrecise,
    Gauss,
    Harmean,
    HypGeomDist,
    Kurt,
    Large,
    // Linest,
    // Logest,
    LogNormDist,
    LogNormInv,
    MaxA,
    Median,
    MinA,
    // ModeMult,
    // ModeSingl,
    NegbinomDist,
    NormDist,
    NormInv,
    NormSdist,
    NormSInv,
    Pearson,
    // PercentileExc,
    // PercentileInc,
    // PercentrankExc,
    // PercentrankInc,
    // Permut,
    // Permutationa,
    Phi,
    PoissonDist,
    // Prob,
    // QuartileExc,
    // QuartileInc,
    RankAvg,
    RankEq,
    Skew,
    SkewP,
    Small,
    Standardize,
    StDevP,
    StDevS,
    Stdeva,
    Stdevpa,
    TDist,
    TDist2T,
    TDistRT,
    TInv,
    TInv2T,
    TTest,
    // Trend,
    // Trimmean,
    VarP,
    VarS,
    VarpA,
    VarA,
    WeibullDist,
    ZTest,

    // Date and time
    Date,
    Datedif,
    Datevalue,
    Day,
    Edate,
    Eomonth,
    Month,
    Time,
    Timevalue,
    Hour,
    Minute,
    Second,
    Now,
    Today,
    Year,
    Networkdays,
    NetworkdaysIntl,
    Days,
    Days360,
    Weekday,
    Weeknum,
    Workday,
    WorkdayIntl,
    Yearfrac,
    Isoweeknum,

    // Financial
    Cumipmt,
    Cumprinc,
    Db,
    Ddb,
    Dollarde,
    Dollarfr,
    Effect,
    Fv,
    Ipmt,
    Irr,
    Ispmt,
    Mirr,
    Nominal,
    Nper,
    Npv,
    Pduration,
    Pmt,
    Ppmt,
    Pv,
    Rate,
    Rri,
    Sln,
    Syd,
    Tbilleq,
    Tbillprice,
    Tbillyield,
    Xirr,
    Xnpv,

    // Engineering: Bessel and transcendental functions
    Besseli,
    Besselj,
    Besselk,
    Bessely,
    Erf,
    Erfc,
    ErfcPrecise,
    ErfPrecise,

    // Engineering: Number systems
    Bin2dec,
    Bin2hex,
    Bin2oct,
    Dec2Bin,
    Dec2hex,
    Dec2oct,
    Hex2bin,
    Hex2dec,
    Hex2oct,
    Oct2bin,
    Oct2dec,
    Oct2hex,

    // Engineering: Bit functions
    Bitand,
    Bitlshift,
    Bitor,
    Bitrshift,
    Bitxor,

    // Engineering: Complex functions
    Complex,
    Imabs,
    Imaginary,
    Imargument,
    Imconjugate,
    Imcos,
    Imcosh,
    Imcot,
    Imcsc,
    Imcsch,
    Imdiv,
    Imexp,
    Imln,
    Imlog10,
    Imlog2,
    Impower,
    Improduct,
    Imreal,
    Imsec,
    Imsech,
    Imsin,
    Imsinh,
    Imsqrt,
    Imsub,
    Imsum,
    Imtan,

    // Engineering: Misc function
    Convert,
    Delta,
    Gestep,
    Subtotal,

    // Database
    Daverage,
    Dcount,
    Dget,
    Dmax,
    Dmin,
    Dsum,
    Dcounta,
    Dproduct,
    Dstdev,
    Dvar,
    Dvarp,
    Dstdevp,

    Correl,
    Rsq,
    Intercept,
    Slope,
    Steyx,
}

macro_rules! impl_function_lookup {
    ($($field:ident => $variant:ident),+ $(,)?) => {
        impl Functions {
            pub fn lookup(&self, name: &str) -> Option<Function> {
                let key = name.to_uppercase();
                $(
                    if self.$field == key {
                        return Some(Function::$variant);
                    }
                )*
                None
            }
        }
    }
}

impl_function_lookup! {
    // Logical
    and         => And,
    r#false     => False,
    r#if        => If,
    iferror     => Iferror,
    ifna        => Ifna,
    ifs         => Ifs,
    not         => Not,
    or          => Or,
    switch      => Switch,
    r#true      => True,
    xor         => Xor,

    // Mathematical and trigonometry
    abs             => Abs,
    acos            => Acos,
    acosh           => Acosh,
    asin            => Asin,
    asinh           => Asinh,
    atan            => Atan,
    atan2           => Atan2,
    atanh           => Atanh,
    choose          => Choose,
    column          => Column,
    columns         => Columns,
    cos             => Cos,
    cosh            => Cosh,
    log             => Log,
    log10           => Log10,
    ln              => Ln,
    max             => Max,
    min             => Min,
    pi              => Pi,
    power           => Power,
    product         => Product,
    rand            => Rand,
    randbetween     => Randbetween,
    round           => Round,
    rounddown       => Rounddown,
    roundup         => Roundup,
    sin             => Sin,
    sinh            => Sinh,
    sqrt            => Sqrt,
    sqrtpi          => Sqrtpi,
    sum             => Sum,
    sumif           => Sumif,
    sumifs          => Sumifs,
    sumx2my2        => Sumx2my2,
    sumx2py2        => Sumx2py2,
    sumxmy2         => Sumxmy2,
    tan             => Tan,
    tanh            => Tanh,
    acot            => Acot,
    acoth           => Acoth,
    cot             => Cot,
    coth            => Coth,
    csc             => Csc,
    csch            => Csch,
    sec             => Sec,
    sech            => Sech,
    exp             => Exp,
    fact            => Fact,
    factdouble      => Factdouble,
    sign            => Sign,
    radians         => Radians,
    degrees         => Degrees,
    int             => Int,
    even            => Even,
    odd             => Odd,
    ceiling         => Ceiling,
    ceilingmath     => CeilingMath,
    ceilingprecise  => CeilingPrecise,
    floor           => Floor,
    floormath       => FloorMath,
    floorprecise    => FloorPrecise,
    isoceiling      => IsoCeiling,
    r#mod           => Mod,
    quotient        => Quotient,
    mround          => Mround,
    trunc           => Trunc,
    gcd             => Gcd,
    lcm             => Lcm,
    base            => Base,
    decimal         => Decimal,
    roman           => Roman,
    arabic          => Arabic,
    combin          => Combin,
    combina         => Combina,
    sumsq           => Sumsq,

    // Information
    errortype   => ErrorType,
    formulatext => Formulatext,
    isblank     => Isblank,
    iserr       => Iserr,
    iserror     => Iserror,
    iseven      => Iseven,
    isformula   => Isformula,
    islogical   => Islogical,
    isna        => Isna,
    isnontext   => Isnontext,
    isnumber    => Isnumber,
    isodd       => Isodd,
    isref       => Isref,
    istext      => Istext,
    na          => Na,
    sheet       => Sheet,
    r#type      => Type,

    sheets      => Sheets,
    n           => N,
    cell        => Cell,
    info        => Info,

    // Lookup and reference
    hlookup => Hlookup,
    index   => Index,
    indirect=> Indirect,
    lookup  => Lookup,
    r#match => Match,
    offset  => Offset,
    row     => Row,
    rows    => Rows,
    vlookup => Vlookup,
    xlookup => Xlookup,

    // Text
    concat      => Concat,
    concatenate => Concatenate,
    exact       => Exact,
    find        => Find,
    left        => Left,
    len         => Len,
    lower       => Lower,
    mid         => Mid,
    rept        => Rept,
    right       => Right,
    search      => Search,
    substitute  => Substitute,
    t           => T,
    text        => Text,
    textafter   => Textafter,
    textbefore  => Textbefore,
    textjoin    => Textjoin,
    trim        => Trim,
    unicode     => Unicode,
    upper       => Upper,
    value       => Value,
    valuetotext => Valuetotext,

    // Statistical
    average        => Average,
    averagea       => Averagea,
    averageif      => Averageif,
    averageifs     => Averageifs,
    count          => Count,
    counta         => Counta,
    countblank     => Countblank,
    countif        => Countif,
    countifs       => Countifs,
    maxifs         => Maxifs,
    minifs         => Minifs,
    geomean        => Geomean,
    avedev         => Avedev,
    betadist       => BetaDist,
    betainv        => BetaInv,
    binomdist      => BinomDist,
    binomdistrange => BinomDistRange,
    binominv       => BinomInv,
    chisqdist      => ChisqDist,
    chisqdistrt    => ChisqDistRT,
    chisqinv       => ChisqInv,
    chisqinvrt     => ChisqInvRT,
    chisqtest      => ChisqTest,
    confidencenorm => ConfidenceNorm,
    confidencet    => ConfidenceT,
    covariancep    => CovarianceP,
    covariances    => CovarianceS,
    devsq          => Devsq,
    expondist      => ExponDist,
    fdist          => FDist,
    fdistrt        => FDistRT,
    finv           => FInv,
    finvrt         => FInvRT,
    ftest          => FTest,
    fisher         => Fisher,
    fisherinv      => FisherInv,
    gamma          => Gamma,
    gammadist      => GammaDist,
    gammainv       => GammaInv,
    gammaln        => GammaLn,
    gammalnprecise => GammaLnPrecise,
    gauss          => Gauss,
    harmean        => Harmean,
    hypgeomdist    => HypGeomDist,
    kurt           => Kurt,
    large          => Large,
    lognormdist    => LogNormDist,
    lognorminv     => LogNormInv,
    maxa           => MaxA,
    median         => Median,
    mina           => MinA,
    negbinomdist   => NegbinomDist,
    normdist       => NormDist,
    norminv        => NormInv,
    normsdist      => NormSdist,
    normsinv       => NormSInv,
    pearson        => Pearson,
    phi            => Phi,
    poissondist    => PoissonDist,
    rankavg        => RankAvg,
    rankeq         => RankEq,
    skew           => Skew,
    skewp          => SkewP,
    small          => Small,
    standardize    => Standardize,
    stdevp         => StDevP,
    stdevs         => StDevS,
    stdeva         => Stdeva,
    stdevpa        => Stdevpa,
    tdist          => TDist,
    tdist2t        => TDist2T,
    tdistrt        => TDistRT,
    tinv           => TInv,
    tinv2t         => TInv2T,
    ttest          => TTest,
    varp           => VarP,
    vars           => VarS,
    varpa          => VarpA,
    vara           => VarA,
    weibulldist    => WeibullDist,
    ztest          => ZTest,

    // Date and time
    date            => Date,
    datedif         => Datedif,
    datevalue       => Datevalue,
    day             => Day,
    edate           => Edate,
    eomonth         => Eomonth,
    month           => Month,
    time            => Time,
    timevalue       => Timevalue,
    hour            => Hour,
    minute          => Minute,
    second          => Second,
    now             => Now,
    today           => Today,
    year            => Year,
    networkdays     => Networkdays,
    networkdaysintl => NetworkdaysIntl,
    days            => Days,
    days360         => Days360,
    weekday         => Weekday,
    weeknum         => Weeknum,
    workday         => Workday,
    workdayintl     => WorkdayIntl,
    yearfrac        => Yearfrac,
    isoweeknum      => Isoweeknum,

    // Financial
    cumipmt    => Cumipmt,
    cumprinc   => Cumprinc,
    db         => Db,
    ddb        => Ddb,
    dollarde   => Dollarde,
    dollarfr   => Dollarfr,
    effect     => Effect,
    fv         => Fv,
    ipmt       => Ipmt,
    irr        => Irr,
    ispmt      => Ispmt,
    mirr       => Mirr,
    nominal    => Nominal,
    nper       => Nper,
    npv        => Npv,
    pduration  => Pduration,
    pmt        => Pmt,
    ppmt       => Ppmt,
    pv         => Pv,
    rate       => Rate,
    rri        => Rri,
    sln        => Sln,
    syd        => Syd,
    tbilleq    => Tbilleq,
    tbillprice => Tbillprice,
    tbillyield => Tbillyield,
    xirr       => Xirr,
    xnpv       => Xnpv,

    // Engineering: Bessel and transcendental functions
    besseli       => Besseli,
    besselj       => Besselj,
    besselk       => Besselk,
    bessely       => Bessely,
    erf           => Erf,
    erfc          => Erfc,
    erfcprecise   => ErfcPrecise,
    erfprecise    => ErfPrecise,

    // Engineering: Number systems
    bin2dec  => Bin2dec,
    bin2hex  => Bin2hex,
    bin2oct  => Bin2oct,
    dec2bin  => Dec2Bin,
    dec2hex  => Dec2hex,
    dec2oct  => Dec2oct,
    hex2bin  => Hex2bin,
    hex2dec  => Hex2dec,
    hex2oct  => Hex2oct,
    oct2bin  => Oct2bin,
    oct2dec  => Oct2dec,
    oct2hex  => Oct2hex,

    // Engineering: Bit functions
    bitand    => Bitand,
    bitlshift => Bitlshift,
    bitor     => Bitor,
    bitrshift => Bitrshift,
    bitxor    => Bitxor,

    // Engineering: Complex functions
    complex     => Complex,
    imabs       => Imabs,
    imaginary   => Imaginary,
    imargument  => Imargument,
    imconjugate => Imconjugate,
    imcos       => Imcos,
    imcosh      => Imcosh,
    imcot       => Imcot,
    imcsc       => Imcsc,
    imcsch      => Imcsch,
    imdiv       => Imdiv,
    imexp       => Imexp,
    imln        => Imln,
    imlog10     => Imlog10,
    imlog2      => Imlog2,
    impower     => Impower,
    improduct   => Improduct,
    imreal      => Imreal,
    imsec       => Imsec,
    imsech      => Imsech,
    imsin       => Imsin,
    imsinh      => Imsinh,
    imsqrt      => Imsqrt,
    imsub       => Imsub,
    imsum       => Imsum,
    imtan       => Imtan,

    // Engineering: Misc function
    convert  => Convert,
    delta    => Delta,
    gestep   => Gestep,
    subtotal => Subtotal,

    // Database
    daverage => Daverage,
    dcount   => Dcount,
    dget     => Dget,
    dmax     => Dmax,
    dmin     => Dmin,
    dsum     => Dsum,
    dcounta  => Dcounta,
    dproduct => Dproduct,
    dstdev   => Dstdev,
    dvar     => Dvar,
    dvarp    => Dvarp,
    dstdevp  => Dstdevp,

    // More statistical
    correl    => Correl,
    rsq       => Rsq,
    intercept => Intercept,
    slope     => Slope,
    steyx     => Steyx,
}

impl Function {
    pub fn to_localized_name(&self, language: &Language) -> String {
        let functions = &language.functions;
        match self {
            Function::And => functions.and.clone(),
            Function::False => functions.r#false.clone(),
            Function::If => functions.r#if.clone(),
            Function::Iferror => functions.iferror.clone(),
            Function::Ifna => functions.ifna.clone(),
            Function::Ifs => functions.ifs.clone(),
            Function::Not => functions.not.clone(),
            Function::Or => functions.or.clone(),
            Function::Switch => functions.switch.clone(),
            Function::True => functions.r#true.clone(),
            Function::Xor => functions.xor.clone(),
            Function::Abs => functions.abs.clone(),
            Function::Acos => functions.acos.clone(),
            Function::Acosh => functions.acosh.clone(),
            Function::Asin => functions.asin.clone(),
            Function::Asinh => functions.asinh.clone(),
            Function::Atan => functions.atan.clone(),
            Function::Atan2 => functions.atan2.clone(),
            Function::Atanh => functions.atanh.clone(),
            Function::Choose => functions.choose.clone(),
            Function::Column => functions.column.clone(),
            Function::Columns => functions.columns.clone(),
            Function::Cos => functions.cos.clone(),
            Function::Cosh => functions.cosh.clone(),
            Function::Log => functions.log.clone(),
            Function::Log10 => functions.log10.clone(),
            Function::Ln => functions.ln.clone(),
            Function::Max => functions.max.clone(),
            Function::Min => functions.min.clone(),
            Function::Pi => functions.pi.clone(),
            Function::Power => functions.power.clone(),
            Function::Product => functions.product.clone(),
            Function::Rand => functions.rand.clone(),
            Function::Randbetween => functions.randbetween.clone(),
            Function::Round => functions.round.clone(),
            Function::Rounddown => functions.rounddown.clone(),
            Function::Roundup => functions.roundup.clone(),
            Function::Sin => functions.sin.clone(),
            Function::Sinh => functions.sinh.clone(),
            Function::Sqrt => functions.sqrt.clone(),
            Function::Sqrtpi => functions.sqrtpi.clone(),
            Function::Sum => functions.sum.clone(),
            Function::Sumif => functions.sumif.clone(),
            Function::Sumifs => functions.sumifs.clone(),
            Function::Sumx2my2 => functions.sumx2my2.clone(),
            Function::Sumx2py2 => functions.sumx2py2.clone(),
            Function::Sumxmy2 => functions.sumxmy2.clone(),
            Function::Tan => functions.tan.clone(),
            Function::Tanh => functions.tanh.clone(),
            Function::Acot => functions.acot.clone(),
            Function::Acoth => functions.acoth.clone(),
            Function::Cot => functions.cot.clone(),
            Function::Coth => functions.coth.clone(),
            Function::Csc => functions.csc.clone(),
            Function::Csch => functions.csch.clone(),
            Function::Sec => functions.sec.clone(),
            Function::Sech => functions.sech.clone(),
            Function::Exp => functions.exp.clone(),
            Function::Fact => functions.fact.clone(),
            Function::Factdouble => functions.factdouble.clone(),
            Function::Sign => functions.sign.clone(),
            Function::Radians => functions.radians.clone(),
            Function::Degrees => functions.degrees.clone(),
            Function::Int => functions.int.clone(),
            Function::Even => functions.even.clone(),
            Function::Odd => functions.odd.clone(),
            Function::Ceiling => functions.ceiling.clone(),
            Function::CeilingMath => functions.ceilingmath.clone(),
            Function::CeilingPrecise => functions.ceilingprecise.clone(),
            Function::Floor => functions.floor.clone(),
            Function::FloorMath => functions.floormath.clone(),
            Function::FloorPrecise => functions.floorprecise.clone(),
            Function::IsoCeiling => functions.isoceiling.clone(),
            Function::Mod => functions.r#mod.clone(),
            Function::Quotient => functions.quotient.clone(),
            Function::Mround => functions.mround.clone(),
            Function::Trunc => functions.trunc.clone(),
            Function::Gcd => functions.gcd.clone(),
            Function::Lcm => functions.lcm.clone(),
            Function::Base => functions.base.clone(),
            Function::Decimal => functions.decimal.clone(),
            Function::Roman => functions.roman.clone(),
            Function::Arabic => functions.arabic.clone(),
            Function::Combin => functions.combin.clone(),
            Function::Combina => functions.combina.clone(),
            Function::Sumsq => functions.sumsq.clone(),
            Function::ErrorType => functions.errortype.clone(),
            Function::Formulatext => functions.formulatext.clone(),
            Function::Isblank => functions.isblank.clone(),
            Function::Iserr => functions.iserr.clone(),
            Function::Iserror => functions.iserror.clone(),
            Function::Iseven => functions.iseven.clone(),
            Function::Isformula => functions.isformula.clone(),
            Function::Islogical => functions.islogical.clone(),
            Function::Isna => functions.isna.clone(),
            Function::Isnontext => functions.isnontext.clone(),
            Function::Isnumber => functions.isnumber.clone(),
            Function::Isodd => functions.isodd.clone(),
            Function::Isref => functions.isref.clone(),
            Function::Istext => functions.istext.clone(),
            Function::Na => functions.na.clone(),
            Function::Sheet => functions.sheet.clone(),
            Function::Type => functions.r#type.clone(),
            Function::Sheets => functions.sheets.clone(),
            Function::N => functions.n.clone(),
            Function::Cell => functions.cell.clone(),
            Function::Info => functions.info.clone(),
            Function::Hlookup => functions.hlookup.clone(),
            Function::Index => functions.index.clone(),
            Function::Indirect => functions.indirect.clone(),
            Function::Lookup => functions.lookup.clone(),
            Function::Match => functions.r#match.clone(),
            Function::Offset => functions.offset.clone(),
            Function::Row => functions.row.clone(),
            Function::Rows => functions.rows.clone(),
            Function::Vlookup => functions.vlookup.clone(),
            Function::Xlookup => functions.xlookup.clone(),
            Function::Concat => functions.concat.clone(),
            Function::Concatenate => functions.concatenate.clone(),
            Function::Exact => functions.exact.clone(),
            Function::Find => functions.find.clone(),
            Function::Left => functions.left.clone(),
            Function::Len => functions.len.clone(),
            Function::Lower => functions.lower.clone(),
            Function::Mid => functions.mid.clone(),
            Function::Rept => functions.rept.clone(),
            Function::Right => functions.right.clone(),
            Function::Search => functions.search.clone(),
            Function::Substitute => functions.substitute.clone(),
            Function::T => functions.t.clone(),
            Function::Text => functions.text.clone(),
            Function::Textafter => functions.textafter.clone(),
            Function::Textbefore => functions.textbefore.clone(),
            Function::Textjoin => functions.textjoin.clone(),
            Function::Trim => functions.trim.clone(),
            Function::Unicode => functions.unicode.clone(),
            Function::Upper => functions.upper.clone(),
            Function::Value => functions.value.clone(),
            Function::Valuetotext => functions.valuetotext.clone(),
            Function::Average => functions.average.clone(),
            Function::Averagea => functions.averagea.clone(),
            Function::Averageif => functions.averageif.clone(),
            Function::Averageifs => functions.averageifs.clone(),
            Function::Count => functions.count.clone(),
            Function::Counta => functions.counta.clone(),
            Function::Countblank => functions.countblank.clone(),
            Function::Countif => functions.countif.clone(),
            Function::Countifs => functions.countifs.clone(),
            Function::Maxifs => functions.maxifs.clone(),
            Function::Minifs => functions.minifs.clone(),
            Function::Geomean => functions.geomean.clone(),
            Function::Avedev => functions.avedev.clone(),
            Function::BetaDist => functions.betadist.clone(),
            Function::BetaInv => functions.betainv.clone(),
            Function::BinomDist => functions.binomdist.clone(),
            Function::BinomDistRange => functions.binomdistrange.clone(),
            Function::BinomInv => functions.binominv.clone(),
            Function::ChisqDist => functions.chisqdist.clone(),
            Function::ChisqDistRT => functions.chisqdistrt.clone(),
            Function::ChisqInv => functions.chisqinv.clone(),
            Function::ChisqInvRT => functions.chisqinvrt.clone(),
            Function::ChisqTest => functions.chisqtest.clone(),
            Function::ConfidenceNorm => functions.confidencenorm.clone(),
            Function::ConfidenceT => functions.confidencet.clone(),
            Function::CovarianceP => functions.covariancep.clone(),
            Function::CovarianceS => functions.covariances.clone(),
            Function::Devsq => functions.devsq.clone(),
            Function::ExponDist => functions.expondist.clone(),
            Function::FDist => functions.fdist.clone(),
            Function::FDistRT => functions.fdistrt.clone(),
            Function::FInv => functions.finv.clone(),
            Function::FInvRT => functions.finvrt.clone(),
            Function::FTest => functions.ftest.clone(),
            Function::Fisher => functions.fisher.clone(),
            Function::FisherInv => functions.fisherinv.clone(),
            Function::Gamma => functions.gamma.clone(),
            Function::GammaDist => functions.gammadist.clone(),
            Function::GammaInv => functions.gammainv.clone(),
            Function::GammaLn => functions.gammaln.clone(),
            Function::GammaLnPrecise => functions.gammalnprecise.clone(),
            Function::Gauss => functions.gauss.clone(),
            Function::Harmean => functions.harmean.clone(),
            Function::HypGeomDist => functions.hypgeomdist.clone(),
            Function::Kurt => functions.kurt.clone(),
            Function::Large => functions.large.clone(),
            Function::LogNormDist => functions.lognormdist.clone(),
            Function::LogNormInv => functions.lognorminv.clone(),
            Function::MaxA => functions.maxa.clone(),
            Function::Median => functions.median.clone(),
            Function::MinA => functions.mina.clone(),
            Function::NegbinomDist => functions.negbinomdist.clone(),
            Function::NormDist => functions.normdist.clone(),
            Function::NormInv => functions.norminv.clone(),
            Function::NormSdist => functions.normsdist.clone(),
            Function::NormSInv => functions.normsinv.clone(),
            Function::Pearson => functions.pearson.clone(),
            Function::Phi => functions.phi.clone(),
            Function::PoissonDist => functions.poissondist.clone(),
            Function::RankAvg => functions.rankavg.clone(),
            Function::RankEq => functions.rankeq.clone(),
            Function::Skew => functions.skew.clone(),
            Function::SkewP => functions.skewp.clone(),
            Function::Small => functions.small.clone(),
            Function::Standardize => functions.standardize.clone(),
            Function::StDevP => functions.stdevp.clone(),
            Function::StDevS => functions.stdevs.clone(),
            Function::Stdeva => functions.stdeva.clone(),
            Function::Stdevpa => functions.stdevpa.clone(),
            Function::TDist => functions.tdist.clone(),
            Function::TDist2T => functions.tdist2t.clone(),
            Function::TDistRT => functions.tdistrt.clone(),
            Function::TInv => functions.tinv.clone(),
            Function::TInv2T => functions.tinv2t.clone(),
            Function::TTest => functions.ttest.clone(),
            Function::VarP => functions.varp.clone(),
            Function::VarS => functions.vars.clone(),
            Function::VarpA => functions.varpa.clone(),
            Function::VarA => functions.vara.clone(),
            Function::WeibullDist => functions.weibulldist.clone(),
            Function::ZTest => functions.ztest.clone(),
            Function::Date => functions.date.clone(),
            Function::Datedif => functions.datedif.clone(),
            Function::Datevalue => functions.datevalue.clone(),
            Function::Day => functions.day.clone(),
            Function::Edate => functions.edate.clone(),
            Function::Eomonth => functions.eomonth.clone(),
            Function::Month => functions.month.clone(),
            Function::Time => functions.time.clone(),
            Function::Timevalue => functions.timevalue.clone(),
            Function::Hour => functions.hour.clone(),
            Function::Minute => functions.minute.clone(),
            Function::Second => functions.second.clone(),
            Function::Now => functions.now.clone(),
            Function::Today => functions.today.clone(),
            Function::Year => functions.year.clone(),
            Function::Networkdays => functions.networkdays.clone(),
            Function::NetworkdaysIntl => functions.networkdaysintl.clone(),
            Function::Days => functions.days.clone(),
            Function::Days360 => functions.days360.clone(),
            Function::Weekday => functions.weekday.clone(),
            Function::Weeknum => functions.weeknum.clone(),
            Function::Workday => functions.workday.clone(),
            Function::WorkdayIntl => functions.workdayintl.clone(),
            Function::Yearfrac => functions.yearfrac.clone(),
            Function::Isoweeknum => functions.isoweeknum.clone(),
            Function::Cumipmt => functions.cumipmt.clone(),
            Function::Cumprinc => functions.cumprinc.clone(),
            Function::Db => functions.db.clone(),
            Function::Ddb => functions.ddb.clone(),
            Function::Dollarde => functions.dollarde.clone(),
            Function::Dollarfr => functions.dollarfr.clone(),
            Function::Effect => functions.effect.clone(),
            Function::Fv => functions.fv.clone(),
            Function::Ipmt => functions.ipmt.clone(),
            Function::Irr => functions.irr.clone(),
            Function::Ispmt => functions.ispmt.clone(),
            Function::Mirr => functions.mirr.clone(),
            Function::Nominal => functions.nominal.clone(),
            Function::Nper => functions.nper.clone(),
            Function::Npv => functions.npv.clone(),
            Function::Pduration => functions.pduration.clone(),
            Function::Pmt => functions.pmt.clone(),
            Function::Ppmt => functions.ppmt.clone(),
            Function::Pv => functions.pv.clone(),
            Function::Rate => functions.rate.clone(),
            Function::Rri => functions.rri.clone(),
            Function::Sln => functions.sln.clone(),
            Function::Syd => functions.syd.clone(),
            Function::Tbilleq => functions.tbilleq.clone(),
            Function::Tbillprice => functions.tbillprice.clone(),
            Function::Tbillyield => functions.tbillyield.clone(),
            Function::Xirr => functions.xirr.clone(),
            Function::Xnpv => functions.xnpv.clone(),
            Function::Besseli => functions.besseli.clone(),
            Function::Besselj => functions.besselj.clone(),
            Function::Besselk => functions.besselk.clone(),
            Function::Bessely => functions.bessely.clone(),
            Function::Erf => functions.erf.clone(),
            Function::Erfc => functions.erfc.clone(),
            Function::ErfcPrecise => functions.erfcprecise.clone(),
            Function::ErfPrecise => functions.erfprecise.clone(),
            Function::Bin2dec => functions.bin2dec.clone(),
            Function::Bin2hex => functions.bin2hex.clone(),
            Function::Bin2oct => functions.bin2oct.clone(),
            Function::Dec2Bin => functions.dec2bin.clone(),
            Function::Dec2hex => functions.dec2hex.clone(),
            Function::Dec2oct => functions.dec2oct.clone(),
            Function::Hex2bin => functions.hex2bin.clone(),
            Function::Hex2dec => functions.hex2dec.clone(),
            Function::Hex2oct => functions.hex2oct.clone(),
            Function::Oct2bin => functions.oct2bin.clone(),
            Function::Oct2dec => functions.oct2dec.clone(),
            Function::Oct2hex => functions.oct2hex.clone(),
            Function::Bitand => functions.bitand.clone(),
            Function::Bitlshift => functions.bitlshift.clone(),
            Function::Bitor => functions.bitor.clone(),
            Function::Bitrshift => functions.bitrshift.clone(),
            Function::Bitxor => functions.bitxor.clone(),
            Function::Complex => functions.complex.clone(),
            Function::Imabs => functions.imabs.clone(),
            Function::Imaginary => functions.imaginary.clone(),
            Function::Imargument => functions.imargument.clone(),
            Function::Imconjugate => functions.imconjugate.clone(),
            Function::Imcos => functions.imcos.clone(),
            Function::Imcosh => functions.imcosh.clone(),
            Function::Imcot => functions.imcot.clone(),
            Function::Imcsc => functions.imcsc.clone(),
            Function::Imcsch => functions.imcsch.clone(),
            Function::Imdiv => functions.imdiv.clone(),
            Function::Imexp => functions.imexp.clone(),
            Function::Imln => functions.imln.clone(),
            Function::Imlog10 => functions.imlog10.clone(),
            Function::Imlog2 => functions.imlog2.clone(),
            Function::Impower => functions.impower.clone(),
            Function::Improduct => functions.improduct.clone(),
            Function::Imreal => functions.imreal.clone(),
            Function::Imsec => functions.imsec.clone(),
            Function::Imsech => functions.imsech.clone(),
            Function::Imsin => functions.imsin.clone(),
            Function::Imsinh => functions.imsinh.clone(),
            Function::Imsqrt => functions.imsqrt.clone(),
            Function::Imsub => functions.imsub.clone(),
            Function::Imsum => functions.imsum.clone(),
            Function::Imtan => functions.imtan.clone(),
            Function::Convert => functions.convert.clone(),
            Function::Delta => functions.delta.clone(),
            Function::Gestep => functions.gestep.clone(),
            Function::Subtotal => functions.subtotal.clone(),
            Function::Daverage => functions.daverage.clone(),
            Function::Dcount => functions.dcount.clone(),
            Function::Dget => functions.dget.clone(),
            Function::Dmax => functions.dmax.clone(),
            Function::Dmin => functions.dmin.clone(),
            Function::Dsum => functions.dsum.clone(),
            Function::Dcounta => functions.dcounta.clone(),
            Function::Dproduct => functions.dproduct.clone(),
            Function::Dstdev => functions.dstdev.clone(),
            Function::Dvar => functions.dvar.clone(),
            Function::Dvarp => functions.dvarp.clone(),
            Function::Dstdevp => functions.dstdevp.clone(),
            Function::Correl => functions.correl.clone(),
            Function::Rsq => functions.rsq.clone(),
            Function::Intercept => functions.intercept.clone(),
            Function::Slope => functions.slope.clone(),
            Function::Steyx => functions.steyx.clone(),
        }
    }
    pub fn into_iter() -> IntoIter<Function, 345> {
        [
            Function::And,
            Function::False,
            Function::If,
            Function::Iferror,
            Function::Ifna,
            Function::Ifs,
            Function::Not,
            Function::Or,
            Function::Switch,
            Function::True,
            Function::Xor,
            Function::Sin,
            Function::Cos,
            Function::Tan,
            Function::Asin,
            Function::Acos,
            Function::Atan,
            Function::Sinh,
            Function::Cosh,
            Function::Tanh,
            Function::Asinh,
            Function::Acosh,
            Function::Atanh,
            Function::Abs,
            Function::Pi,
            Function::Ln,
            Function::Log,
            Function::Log10,
            Function::Sqrt,
            Function::Sqrtpi,
            Function::Atan2,
            Function::Acot,
            Function::Acoth,
            Function::Cot,
            Function::Coth,
            Function::Csc,
            Function::Csch,
            Function::Sec,
            Function::Sech,
            Function::Power,
            Function::Exp,
            Function::Fact,
            Function::Factdouble,
            Function::Sign,
            Function::Int,
            Function::Even,
            Function::Odd,
            Function::Ceiling,
            Function::CeilingMath,
            Function::CeilingPrecise,
            Function::Floor,
            Function::FloorMath,
            Function::FloorPrecise,
            Function::IsoCeiling,
            Function::Mod,
            Function::Quotient,
            Function::Mround,
            Function::Trunc,
            Function::Gcd,
            Function::Lcm,
            Function::Base,
            Function::Decimal,
            Function::Max,
            Function::Min,
            Function::Product,
            Function::Rand,
            Function::Randbetween,
            Function::Radians,
            Function::Degrees,
            Function::Round,
            Function::Rounddown,
            Function::Roundup,
            Function::Sum,
            Function::Sumif,
            Function::Sumifs,
            Function::Sumx2my2,
            Function::Sumx2py2,
            Function::Sumxmy2,
            Function::Choose,
            Function::Column,
            Function::Columns,
            Function::Index,
            Function::Indirect,
            Function::Hlookup,
            Function::Lookup,
            Function::Match,
            Function::Offset,
            Function::Row,
            Function::Rows,
            Function::Vlookup,
            Function::Xlookup,
            Function::Concatenate,
            Function::Exact,
            Function::Value,
            Function::T,
            Function::Valuetotext,
            Function::Concat,
            Function::Find,
            Function::Left,
            Function::Len,
            Function::Lower,
            Function::Mid,
            Function::Right,
            Function::Search,
            Function::Text,
            Function::Trim,
            Function::Unicode,
            Function::Upper,
            Function::Isnumber,
            Function::Isnontext,
            Function::Istext,
            Function::Islogical,
            Function::Isblank,
            Function::Iserr,
            Function::Iserror,
            Function::Isna,
            Function::Na,
            Function::Isref,
            Function::Isodd,
            Function::Iseven,
            Function::ErrorType,
            Function::Formulatext,
            Function::Isformula,
            Function::Type,
            Function::Sheet,
            Function::Average,
            Function::Avedev,
            Function::Averagea,
            Function::Averageif,
            Function::Averageifs,
            Function::Count,
            Function::Counta,
            Function::Countblank,
            Function::Countif,
            Function::Countifs,
            Function::Maxifs,
            Function::Minifs,
            Function::Geomean,
            Function::Year,
            Function::Day,
            Function::Month,
            Function::Eomonth,
            Function::Date,
            Function::Datedif,
            Function::Datevalue,
            Function::Edate,
            Function::Networkdays,
            Function::NetworkdaysIntl,
            Function::Time,
            Function::Timevalue,
            Function::Hour,
            Function::Minute,
            Function::Second,
            Function::Today,
            Function::Now,
            Function::Days,
            Function::Days360,
            Function::Weekday,
            Function::Weeknum,
            Function::Workday,
            Function::WorkdayIntl,
            Function::Yearfrac,
            Function::Isoweeknum,
            Function::Pmt,
            Function::Pv,
            Function::Rate,
            Function::Nper,
            Function::Fv,
            Function::Ppmt,
            Function::Ipmt,
            Function::Npv,
            Function::Mirr,
            Function::Irr,
            Function::Xirr,
            Function::Xnpv,
            Function::Rept,
            Function::Textafter,
            Function::Textbefore,
            Function::Textjoin,
            Function::Substitute,
            Function::Ispmt,
            Function::Rri,
            Function::Sln,
            Function::Syd,
            Function::Nominal,
            Function::Effect,
            Function::Pduration,
            Function::Tbillyield,
            Function::Tbillprice,
            Function::Tbilleq,
            Function::Dollarde,
            Function::Dollarfr,
            Function::Ddb,
            Function::Db,
            Function::Cumprinc,
            Function::Cumipmt,
            Function::Besseli,
            Function::Besselj,
            Function::Besselk,
            Function::Bessely,
            Function::Erf,
            Function::ErfPrecise,
            Function::Erfc,
            Function::ErfcPrecise,
            Function::Bin2dec,
            Function::Bin2hex,
            Function::Bin2oct,
            Function::Dec2Bin,
            Function::Dec2hex,
            Function::Dec2oct,
            Function::Hex2bin,
            Function::Hex2dec,
            Function::Hex2oct,
            Function::Oct2bin,
            Function::Oct2dec,
            Function::Oct2hex,
            Function::Bitand,
            Function::Bitlshift,
            Function::Bitor,
            Function::Bitrshift,
            Function::Bitxor,
            Function::Complex,
            Function::Imabs,
            Function::Imaginary,
            Function::Imargument,
            Function::Imconjugate,
            Function::Imcos,
            Function::Imcosh,
            Function::Imcot,
            Function::Imcsc,
            Function::Imcsch,
            Function::Imdiv,
            Function::Imexp,
            Function::Imln,
            Function::Imlog10,
            Function::Imlog2,
            Function::Impower,
            Function::Improduct,
            Function::Imreal,
            Function::Imsec,
            Function::Imsech,
            Function::Imsin,
            Function::Imsinh,
            Function::Imsqrt,
            Function::Imsub,
            Function::Imsum,
            Function::Imtan,
            Function::Convert,
            Function::Delta,
            Function::Gestep,
            Function::Subtotal,
            Function::Roman,
            Function::Arabic,
            Function::Combin,
            Function::Combina,
            Function::Sumsq,
            Function::N,
            Function::Cell,
            Function::Info,
            Function::Sheets,
            Function::Daverage,
            Function::Dcount,
            Function::Dget,
            Function::Dmax,
            Function::Dmin,
            Function::Dsum,
            Function::Dcounta,
            Function::Dproduct,
            Function::Dstdev,
            Function::Dvar,
            Function::Dvarp,
            Function::Dstdevp,
            Function::BetaDist,
            Function::BetaInv,
            Function::BinomDist,
            Function::BinomDistRange,
            Function::BinomInv,
            Function::ChisqDist,
            Function::ChisqDistRT,
            Function::ChisqInv,
            Function::ChisqInvRT,
            Function::ChisqTest,
            Function::ConfidenceNorm,
            Function::ConfidenceT,
            Function::CovarianceP,
            Function::CovarianceS,
            Function::Devsq,
            Function::ExponDist,
            Function::FDist,
            Function::FDistRT,
            Function::FInv,
            Function::FInvRT,
            Function::FTest,
            Function::Fisher,
            Function::FisherInv,
            Function::Gamma,
            Function::GammaDist,
            Function::GammaInv,
            Function::GammaLn,
            Function::GammaLnPrecise,
            Function::HypGeomDist,
            Function::LogNormDist,
            Function::LogNormInv,
            Function::NegbinomDist,
            Function::NormDist,
            Function::NormInv,
            Function::NormSdist,
            Function::NormSInv,
            Function::Pearson,
            Function::Phi,
            Function::PoissonDist,
            Function::Standardize,
            Function::StDevP,
            Function::StDevS,
            Function::Stdeva,
            Function::Stdevpa,
            Function::TDist,
            Function::TDist2T,
            Function::TDistRT,
            Function::TInv,
            Function::TInv2T,
            Function::TTest,
            Function::VarP,
            Function::VarS,
            Function::VarpA,
            Function::VarA,
            Function::WeibullDist,
            Function::ZTest,
            Function::Correl,
            Function::Rsq,
            Function::Intercept,
            Function::Slope,
            Function::Steyx,
            Function::Large,
            Function::Median,
            Function::Small,
            Function::RankAvg,
            Function::RankEq,
            Function::Skew,
            Function::SkewP,
            Function::Harmean,
            Function::Gauss,
            Function::Kurt,
            Function::MaxA,
            Function::MinA,
        ]
        .into_iter()
    }
}

impl Function {
    /// Some functions in Excel like CONCAT are stringified as `_xlfn.CONCAT`.
    pub fn to_xlsx_string(&self) -> String {
        match self {
            Function::Concat => "_xlfn.CONCAT".to_string(),
            Function::Ifna => "_xlfn.IFNA".to_string(),
            Function::Ifs => "_xlfn.IFS".to_string(),
            Function::Maxifs => "_xlfn.MAXIFS".to_string(),
            Function::Minifs => "_xlfn.MINIFS".to_string(),
            Function::Switch => "_xlfn.SWITCH".to_string(),
            Function::Xlookup => "_xlfn.XLOOKUP".to_string(),
            Function::Xor => "_xlfn.XOR".to_string(),
            Function::Textbefore => "_xlfn.TEXTBEFORE".to_string(),
            Function::Textafter => "_xlfn.TEXTAFTER".to_string(),
            Function::Textjoin => "_xlfn.TEXTJOIN".to_string(),
            Function::Unicode => "_xlfn.UNICODE".to_string(),
            Function::Rri => "_xlfn.RRI".to_string(),
            Function::Pduration => "_xlfn.PDURATION".to_string(),
            Function::Bitand => "_xlfn.BITAND".to_string(),
            Function::Bitor => "_xlfn.BITOR".to_string(),
            Function::Bitxor => "_xlfn.BITXOR".to_string(),
            Function::Bitlshift => "_xlfn.BITLSHIFT".to_string(),
            Function::Bitrshift => "_xlfn.BITRSHIFT".to_string(),
            Function::Imtan => "_xlfn.IMTAN".to_string(),
            Function::Imsinh => "_xlfn.IMSINH".to_string(),
            Function::Imcosh => "_xlfn.IMCOSH".to_string(),
            Function::Imcot => "_xlfn.IMCOT".to_string(),
            Function::Imcsc => "_xlfn.IMCSC".to_string(),
            Function::Imcsch => "_xlfn.IMCSCH".to_string(),
            Function::Imsec => "_xlfn.IMSEC".to_string(),
            Function::ErfcPrecise => "_xlfn.ERFC.PRECISE".to_string(),
            Function::ErfPrecise => "_xlfn.ERF.PRECISE".to_string(),
            Function::Valuetotext => "_xlfn.VALUETOTEXT".to_string(),
            Function::Isformula => "_xlfn.ISFORMULA".to_string(),
            Function::Sheet => "_xlfn.SHEET".to_string(),
            Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
            Function::Isoweeknum => "_xlfn.ISOWEEKNUM".to_string(),
            Function::Ceiling => "_xlfn.CEILING".to_string(),
            Function::CeilingMath => "_xlfn.CEILING.MATH".to_string(),
            Function::CeilingPrecise => "_xlfn.CEILING.PRECISE".to_string(),
            Function::FloorMath => "_xlfn.FLOOR.MATH".to_string(),
            Function::FloorPrecise => "_xlfn.FLOOR.PRECISE".to_string(),
            Function::IsoCeiling => "_xlfn.ISO.CEILING".to_string(),
            Function::Base => "_xlfn.BASE".to_string(),
            Function::Decimal => "_xlfn.DECIMAL".to_string(),
            Function::Arabic => "_xlfn.ARABIC".to_string(),
            Function::Combina => "_xlfn.COMBINA".to_string(),
            Function::Sheets => "_xlfn.SHEETS".to_string(),
            Function::Acoth => "_xlfn.ACOTH".to_string(),
            Function::Cot => "_xlfn.COT".to_string(),
            Function::Coth => "_xlfn.COTH".to_string(),
            Function::Csc => "_xlfn.CSC".to_string(),
            Function::Csch => "_xlfn.CSCH".to_string(),
            Function::Sec => "_xlfn.SEC".to_string(),
            Function::Sech => "_xlfn.SECH".to_string(),
            Function::Acot => "_xlfn.ACOT".to_string(),
            Function::GammaLnPrecise => "_xlfn.GAMMALN.PRECISE".to_string(),
            Function::Gamma => "_xlfn.GAMMA".to_string(),
            Function::GammaInv => "_xlfn.GAMMA.INV".to_string(),
            Function::GammaLn => "_xlfn.GAMMALN".to_string(),
            Function::BetaDist => "_xlfn.BETA.DIST".to_string(),
            Function::BetaInv => "_xlfn.BETA.INV".to_string(),

            Function::BinomDist => "_xlfn.BINOM.DIST".to_string(),
            Function::BinomDistRange => "_xlfn.BINOM.DIST.RANGE".to_string(),
            Function::BinomInv => "_xlfn.BINOM.INV".to_string(),
            Function::NegbinomDist => "_xlfn.NEGBINOM.DIST".to_string(),

            Function::ChisqDist => "_xlfn.CHISQ.DIST".to_string(),
            Function::ChisqDistRT => "_xlfn.CHISQ.DIST.RT".to_string(),
            Function::ChisqInv => "_xlfn.CHISQ.INV".to_string(),
            Function::ChisqInvRT => "_xlfn.CHISQ.INV.RT".to_string(),
            Function::ChisqTest => "_xlfn.CHISQ.TEST".to_string(),

            Function::ConfidenceNorm => "_xlfn.CONFIDENCE.NORM".to_string(),
            Function::ConfidenceT => "_xlfn.CONFIDENCE.T".to_string(),

            Function::CovarianceP => "_xlfn.COVARIANCE.P".to_string(),
            Function::CovarianceS => "_xlfn.COVARIANCE.S".to_string(),

            Function::ExponDist => "_xlfn.EXPON.DIST".to_string(),

            Function::FDist => "_xlfn.F.DIST".to_string(),
            Function::FDistRT => "_xlfn.F.DIST.RT".to_string(),
            Function::FInv => "_xlfn.F.INV".to_string(),
            Function::FInvRT => "_xlfn.F.INV.RT".to_string(),
            Function::FTest => "_xlfn.F.TEST".to_string(),

            Function::HypGeomDist => "_xlfn.HYPGEOM.DIST".to_string(),

            Function::LogNormDist => "_xlfn.LOGNORM.DIST".to_string(),
            Function::LogNormInv => "_xlfn.LOGNORM.INV".to_string(),

            Function::NormDist => "_xlfn.NORM.DIST".to_string(),
            Function::NormInv => "_xlfn.NORM.INV".to_string(),
            Function::NormSdist => "_xlfn.NORM.S.DIST".to_string(),
            Function::NormSInv => "_xlfn.NORM.S.INV".to_string(),

            Function::Phi => "_xlfn.PHI".to_string(),

            Function::PoissonDist => "_xlfn.POISSON.DIST".to_string(),

            Function::StDevP => "_xlfn.STDEV.P".to_string(),
            Function::StDevS => "_xlfn.STDEV.S".to_string(),

            Function::TDist => "_xlfn.T.DIST".to_string(),
            Function::TDist2T => "_xlfn.T.DIST.2T".to_string(),
            Function::TDistRT => "_xlfn.T.DIST.RT".to_string(),
            Function::TInv => "_xlfn.T.INV".to_string(),
            Function::TInv2T => "_xlfn.T.INV.2T".to_string(),
            Function::TTest => "_xlfn.T.TEST".to_string(),

            Function::VarP => "_xlfn.VAR.P".to_string(),
            Function::VarS => "_xlfn.VAR.S".to_string(),

            Function::WeibullDist => "_xlfn.WEIBULL.DIST".to_string(),
            Function::ZTest => "_xlfn.Z.TEST".to_string(),
            Function::SkewP => "_xlfn.SKEW.P".to_string(),
            Function::RankAvg => "_xlfn.RANK.AVG".to_string(),
            Function::RankEq => "_xlfn.RANK.EQ".to_string(),

            _ => {
                let language = get_default_language();
                self.to_localized_name(language)
            }
        }
    }

    pub(crate) fn returns_reference(&self) -> bool {
        matches!(self, Function::Indirect | Function::Offset)
    }
}

impl<'a> Model<'a> {
    pub(crate) fn evaluate_function(
        &mut self,
        kind: &Function,
        args: &[Node],
        cell: CellReferenceIndex,
    ) -> CalcResult {
        match kind {
            Function::And => self.fn_and(args, cell),
            Function::False => self.fn_false(args, cell),
            Function::If => self.fn_if(args, cell),
            Function::Iferror => self.fn_iferror(args, cell),
            Function::Ifna => self.fn_ifna(args, cell),
            Function::Ifs => self.fn_ifs(args, cell),
            Function::Not => self.fn_not(args, cell),
            Function::Or => self.fn_or(args, cell),
            Function::Switch => self.fn_switch(args, cell),
            Function::True => self.fn_true(args, cell),
            Function::Xor => self.fn_xor(args, cell),
            Function::Log => self.fn_log(args, cell),
            Function::Log10 => self.fn_log10(args, cell),
            Function::Ln => self.fn_ln(args, cell),
            Function::Sin => self.fn_sin(args, cell),
            Function::Cos => self.fn_cos(args, cell),
            Function::Tan => self.fn_tan(args, cell),
            Function::Asin => self.fn_asin(args, cell),
            Function::Acos => self.fn_acos(args, cell),
            Function::Atan => self.fn_atan(args, cell),
            Function::Sinh => self.fn_sinh(args, cell),
            Function::Cosh => self.fn_cosh(args, cell),
            Function::Tanh => self.fn_tanh(args, cell),
            Function::Asinh => self.fn_asinh(args, cell),
            Function::Acosh => self.fn_acosh(args, cell),
            Function::Atanh => self.fn_atanh(args, cell),
            Function::Pi => self.fn_pi(args, cell),
            Function::Abs => self.fn_abs(args, cell),
            Function::Sqrt => self.fn_sqrt(args, cell),
            Function::Sqrtpi => self.fn_sqrtpi(args, cell),
            Function::Atan2 => self.fn_atan2(args, cell),
            Function::Power => self.fn_power(args, cell),
            Function::Max => self.fn_max(args, cell),
            Function::Min => self.fn_min(args, cell),
            Function::Product => self.fn_product(args, cell),
            Function::Rand => self.fn_rand(args, cell),
            Function::Randbetween => self.fn_randbetween(args, cell),
            Function::Round => self.fn_round(args, cell),
            Function::Rounddown => self.fn_rounddown(args, cell),
            Function::Roundup => self.fn_roundup(args, cell),
            Function::Sum => self.fn_sum(args, cell),
            Function::Sumif => self.fn_sumif(args, cell),
            Function::Sumifs => self.fn_sumifs(args, cell),
            Function::Choose => self.fn_choose(args, cell),
            Function::Column => self.fn_column(args, cell),
            Function::Columns => self.fn_columns(args, cell),
            Function::Index => self.fn_index(args, cell),
            Function::Indirect => self.fn_indirect(args, cell),
            Function::Hlookup => self.fn_hlookup(args, cell),
            Function::Lookup => self.fn_lookup(args, cell),
            Function::Match => self.fn_match(args, cell),
            Function::Offset => self.fn_offset(args, cell),
            Function::Row => self.fn_row(args, cell),
            Function::Rows => self.fn_rows(args, cell),
            Function::Vlookup => self.fn_vlookup(args, cell),
            Function::Xlookup => self.fn_xlookup(args, cell),
            Function::Concatenate => self.fn_concatenate(args, cell),
            Function::Exact => self.fn_exact(args, cell),
            Function::Value => self.fn_value(args, cell),
            Function::T => self.fn_t(args, cell),
            Function::Valuetotext => self.fn_valuetotext(args, cell),
            Function::Concat => self.fn_concat(args, cell),
            Function::Find => self.fn_find(args, cell),
            Function::Left => self.fn_left(args, cell),
            Function::Len => self.fn_len(args, cell),
            Function::Lower => self.fn_lower(args, cell),
            Function::Mid => self.fn_mid(args, cell),
            Function::Right => self.fn_right(args, cell),
            Function::Search => self.fn_search(args, cell),
            Function::Text => self.fn_text(args, cell),
            Function::Trim => self.fn_trim(args, cell),
            Function::Unicode => self.fn_unicode(args, cell),
            Function::Upper => self.fn_upper(args, cell),
            Function::Isnumber => self.fn_isnumber(args, cell),
            Function::Isnontext => self.fn_isnontext(args, cell),
            Function::Istext => self.fn_istext(args, cell),
            Function::Islogical => self.fn_islogical(args, cell),
            Function::Isblank => self.fn_isblank(args, cell),
            Function::Iserr => self.fn_iserr(args, cell),
            Function::Iserror => self.fn_iserror(args, cell),
            Function::Isna => self.fn_isna(args, cell),
            Function::Na => CalcResult::new_error(Error::NA, cell, "".to_string()),
            Function::Isref => self.fn_isref(args, cell),
            Function::Isodd => self.fn_isodd(args, cell),
            Function::Iseven => self.fn_iseven(args, cell),
            Function::ErrorType => self.fn_errortype(args, cell),
            Function::Formulatext => self.fn_formulatext(args, cell),
            Function::Isformula => self.fn_isformula(args, cell),
            Function::Type => self.fn_type(args, cell),
            Function::Sheet => self.fn_sheet(args, cell),
            Function::Average => self.fn_average(args, cell),
            Function::Averagea => self.fn_averagea(args, cell),
            Function::Avedev => self.fn_avedev(args, cell),
            Function::Averageif => self.fn_averageif(args, cell),
            Function::Averageifs => self.fn_averageifs(args, cell),
            Function::Count => self.fn_count(args, cell),
            Function::Counta => self.fn_counta(args, cell),
            Function::Countblank => self.fn_countblank(args, cell),
            Function::Countif => self.fn_countif(args, cell),
            Function::Countifs => self.fn_countifs(args, cell),
            Function::Maxifs => self.fn_maxifs(args, cell),
            Function::Minifs => self.fn_minifs(args, cell),
            Function::Geomean => self.fn_geomean(args, cell),
            Function::Year => self.fn_year(args, cell),
            Function::Day => self.fn_day(args, cell),
            Function::Eomonth => self.fn_eomonth(args, cell),
            Function::Month => self.fn_month(args, cell),
            Function::Date => self.fn_date(args, cell),
            Function::Datedif => self.fn_datedif(args, cell),
            Function::Datevalue => self.fn_datevalue(args, cell),
            Function::Edate => self.fn_edate(args, cell),
            Function::Networkdays => self.fn_networkdays(args, cell),
            Function::NetworkdaysIntl => self.fn_networkdays_intl(args, cell),
            Function::Time => self.fn_time(args, cell),
            Function::Timevalue => self.fn_timevalue(args, cell),
            Function::Hour => self.fn_hour(args, cell),
            Function::Minute => self.fn_minute(args, cell),
            Function::Second => self.fn_second(args, cell),
            Function::Today => self.fn_today(args, cell),
            Function::Now => self.fn_now(args, cell),
            Function::Days => self.fn_days(args, cell),
            Function::Days360 => self.fn_days360(args, cell),
            Function::Weekday => self.fn_weekday(args, cell),
            Function::Weeknum => self.fn_weeknum(args, cell),
            Function::Workday => self.fn_workday(args, cell),
            Function::WorkdayIntl => self.fn_workday_intl(args, cell),
            Function::Yearfrac => self.fn_yearfrac(args, cell),
            Function::Isoweeknum => self.fn_isoweeknum(args, cell),
            Function::Pmt => self.fn_pmt(args, cell),
            Function::Pv => self.fn_pv(args, cell),
            Function::Rate => self.fn_rate(args, cell),
            Function::Nper => self.fn_nper(args, cell),
            Function::Fv => self.fn_fv(args, cell),
            Function::Ppmt => self.fn_ppmt(args, cell),
            Function::Ipmt => self.fn_ipmt(args, cell),
            Function::Npv => self.fn_npv(args, cell),
            Function::Mirr => self.fn_mirr(args, cell),
            Function::Irr => self.fn_irr(args, cell),
            Function::Xirr => self.fn_xirr(args, cell),
            Function::Xnpv => self.fn_xnpv(args, cell),
            Function::Rept => self.fn_rept(args, cell),
            Function::Textafter => self.fn_textafter(args, cell),
            Function::Textbefore => self.fn_textbefore(args, cell),
            Function::Textjoin => self.fn_textjoin(args, cell),
            Function::Substitute => self.fn_substitute(args, cell),
            Function::Ispmt => self.fn_ispmt(args, cell),
            Function::Rri => self.fn_rri(args, cell),
            Function::Sln => self.fn_sln(args, cell),
            Function::Syd => self.fn_syd(args, cell),
            Function::Nominal => self.fn_nominal(args, cell),
            Function::Effect => self.fn_effect(args, cell),
            Function::Pduration => self.fn_pduration(args, cell),
            Function::Tbillyield => self.fn_tbillyield(args, cell),
            Function::Tbillprice => self.fn_tbillprice(args, cell),
            Function::Tbilleq => self.fn_tbilleq(args, cell),
            Function::Dollarde => self.fn_dollarde(args, cell),
            Function::Dollarfr => self.fn_dollarfr(args, cell),
            Function::Ddb => self.fn_ddb(args, cell),
            Function::Db => self.fn_db(args, cell),
            Function::Cumprinc => self.fn_cumprinc(args, cell),
            Function::Cumipmt => self.fn_cumipmt(args, cell),
            Function::Besseli => self.fn_besseli(args, cell),
            Function::Besselj => self.fn_besselj(args, cell),
            Function::Besselk => self.fn_besselk(args, cell),
            Function::Bessely => self.fn_bessely(args, cell),
            Function::Erf => self.fn_erf(args, cell),
            Function::ErfPrecise => self.fn_erfprecise(args, cell),
            Function::Erfc => self.fn_erfc(args, cell),
            Function::ErfcPrecise => self.fn_erfcprecise(args, cell),
            Function::Bin2dec => self.fn_bin2dec(args, cell),
            Function::Bin2hex => self.fn_bin2hex(args, cell),
            Function::Bin2oct => self.fn_bin2oct(args, cell),
            Function::Dec2Bin => self.fn_dec2bin(args, cell),
            Function::Dec2hex => self.fn_dec2hex(args, cell),
            Function::Dec2oct => self.fn_dec2oct(args, cell),
            Function::Hex2bin => self.fn_hex2bin(args, cell),
            Function::Hex2dec => self.fn_hex2dec(args, cell),
            Function::Hex2oct => self.fn_hex2oct(args, cell),
            Function::Oct2bin => self.fn_oct2bin(args, cell),
            Function::Oct2dec => self.fn_oct2dec(args, cell),
            Function::Oct2hex => self.fn_oct2hex(args, cell),
            Function::Bitand => self.fn_bitand(args, cell),
            Function::Bitlshift => self.fn_bitlshift(args, cell),
            Function::Bitor => self.fn_bitor(args, cell),
            Function::Bitrshift => self.fn_bitrshift(args, cell),
            Function::Bitxor => self.fn_bitxor(args, cell),
            Function::Complex => self.fn_complex(args, cell),
            Function::Imabs => self.fn_imabs(args, cell),
            Function::Imaginary => self.fn_imaginary(args, cell),
            Function::Imargument => self.fn_imargument(args, cell),
            Function::Imconjugate => self.fn_imconjugate(args, cell),
            Function::Imcos => self.fn_imcos(args, cell),
            Function::Imcosh => self.fn_imcosh(args, cell),
            Function::Imcot => self.fn_imcot(args, cell),
            Function::Imcsc => self.fn_imcsc(args, cell),
            Function::Imcsch => self.fn_imcsch(args, cell),
            Function::Imdiv => self.fn_imdiv(args, cell),
            Function::Imexp => self.fn_imexp(args, cell),
            Function::Imln => self.fn_imln(args, cell),
            Function::Imlog10 => self.fn_imlog10(args, cell),
            Function::Imlog2 => self.fn_imlog2(args, cell),
            Function::Impower => self.fn_impower(args, cell),
            Function::Improduct => self.fn_improduct(args, cell),
            Function::Imreal => self.fn_imreal(args, cell),
            Function::Imsec => self.fn_imsec(args, cell),
            Function::Imsech => self.fn_imsech(args, cell),
            Function::Imsin => self.fn_imsin(args, cell),
            Function::Imsinh => self.fn_imsinh(args, cell),
            Function::Imsqrt => self.fn_imsqrt(args, cell),
            Function::Imsub => self.fn_imsub(args, cell),
            Function::Imsum => self.fn_imsum(args, cell),
            Function::Imtan => self.fn_imtan(args, cell),
            Function::Convert => self.fn_convert(args, cell),
            Function::Delta => self.fn_delta(args, cell),
            Function::Gestep => self.fn_gestep(args, cell),
            Function::Subtotal => self.fn_subtotal(args, cell),
            Function::Acot => self.fn_acot(args, cell),
            Function::Acoth => self.fn_acoth(args, cell),
            Function::Cot => self.fn_cot(args, cell),
            Function::Coth => self.fn_coth(args, cell),
            Function::Csc => self.fn_csc(args, cell),
            Function::Csch => self.fn_csch(args, cell),
            Function::Sec => self.fn_sec(args, cell),
            Function::Sech => self.fn_sech(args, cell),
            Function::Exp => self.fn_exp(args, cell),
            Function::Fact => self.fn_fact(args, cell),
            Function::Factdouble => self.fn_factdouble(args, cell),
            Function::Sign => self.fn_sign(args, cell),
            Function::Radians => self.fn_radians(args, cell),
            Function::Degrees => self.fn_degrees(args, cell),
            Function::Int => self.fn_int(args, cell),
            Function::Even => self.fn_even(args, cell),
            Function::Odd => self.fn_odd(args, cell),
            Function::Ceiling => self.fn_ceiling(args, cell),
            Function::CeilingMath => self.fn_ceiling_math(args, cell),
            Function::CeilingPrecise => self.fn_ceiling_precise(args, cell),
            Function::Floor => self.fn_floor(args, cell),
            Function::FloorMath => self.fn_floor_math(args, cell),
            Function::FloorPrecise => self.fn_floor_precise(args, cell),
            Function::IsoCeiling => self.fn_iso_ceiling(args, cell),
            Function::Mod => self.fn_mod(args, cell),
            Function::Quotient => self.fn_quotient(args, cell),
            Function::Mround => self.fn_mround(args, cell),
            Function::Trunc => self.fn_trunc(args, cell),
            Function::Gcd => self.fn_gcd(args, cell),
            Function::Lcm => self.fn_lcm(args, cell),
            Function::Base => self.fn_base(args, cell),
            Function::Decimal => self.fn_decimal(args, cell),
            Function::Roman => self.fn_roman(args, cell),
            Function::Arabic => self.fn_arabic(args, cell),
            Function::Combin => self.fn_combin(args, cell),
            Function::Combina => self.fn_combina(args, cell),
            Function::Sumsq => self.fn_sumsq(args, cell),
            Function::N => self.fn_n(args, cell),
            Function::Cell => self.fn_cell(args, cell),
            Function::Info => self.fn_info(args, cell),
            Function::Sheets => self.fn_sheets(args, cell),
            Function::Daverage => self.fn_daverage(args, cell),
            Function::Dcount => self.fn_dcount(args, cell),
            Function::Dget => self.fn_dget(args, cell),
            Function::Dmax => self.fn_dmax(args, cell),
            Function::Dmin => self.fn_dmin(args, cell),
            Function::Dsum => self.fn_dsum(args, cell),
            Function::Dcounta => self.fn_dcounta(args, cell),
            Function::Dproduct => self.fn_dproduct(args, cell),
            Function::Dstdev => self.fn_dstdev(args, cell),
            Function::Dvar => self.fn_dvar(args, cell),
            Function::Dvarp => self.fn_dvarp(args, cell),
            Function::Dstdevp => self.fn_dstdevp(args, cell),
            Function::BetaDist => self.fn_beta_dist(args, cell),
            Function::BetaInv => self.fn_beta_inv(args, cell),
            Function::BinomDist => self.fn_binom_dist(args, cell),
            Function::BinomDistRange => self.fn_binom_dist_range(args, cell),
            Function::BinomInv => self.fn_binom_inv(args, cell),
            Function::ChisqDist => self.fn_chisq_dist(args, cell),
            Function::ChisqDistRT => self.fn_chisq_dist_rt(args, cell),
            Function::ChisqInv => self.fn_chisq_inv(args, cell),
            Function::ChisqInvRT => self.fn_chisq_inv_rt(args, cell),
            Function::ChisqTest => self.fn_chisq_test(args, cell),
            Function::ConfidenceNorm => self.fn_confidence_norm(args, cell),
            Function::ConfidenceT => self.fn_confidence_t(args, cell),
            Function::CovarianceP => self.fn_covariance_p(args, cell),
            Function::CovarianceS => self.fn_covariance_s(args, cell),
            Function::Devsq => self.fn_devsq(args, cell),
            Function::ExponDist => self.fn_expon_dist(args, cell),
            Function::FDist => self.fn_f_dist(args, cell),
            Function::FDistRT => self.fn_f_dist_rt(args, cell),
            Function::FInv => self.fn_f_inv(args, cell),
            Function::FInvRT => self.fn_f_inv_rt(args, cell),
            Function::Fisher => self.fn_fisher(args, cell),
            Function::FisherInv => self.fn_fisher_inv(args, cell),
            Function::FTest => self.fn_f_test(args, cell),
            Function::Gamma => self.fn_gamma(args, cell),
            Function::GammaDist => self.fn_gamma_dist(args, cell),
            Function::GammaInv => self.fn_gamma_inv(args, cell),
            Function::GammaLn => self.fn_gamma_ln(args, cell),
            Function::GammaLnPrecise => self.fn_gamma_ln_precise(args, cell),
            Function::HypGeomDist => self.fn_hyp_geom_dist(args, cell),
            Function::LogNormDist => self.fn_log_norm_dist(args, cell),
            Function::LogNormInv => self.fn_log_norm_inv(args, cell),
            Function::NegbinomDist => self.fn_negbinom_dist(args, cell),
            Function::NormDist => self.fn_norm_dist(args, cell),
            Function::NormInv => self.fn_norm_inv(args, cell),
            Function::NormSdist => self.fn_norm_s_dist(args, cell),
            Function::NormSInv => self.fn_norm_s_inv(args, cell),
            Function::Pearson => self.fn_pearson(args, cell),
            Function::Phi => self.fn_phi(args, cell),
            Function::PoissonDist => self.fn_poisson_dist(args, cell),
            Function::Standardize => self.fn_standardize(args, cell),
            Function::StDevP => self.fn_stdev_p(args, cell),
            Function::StDevS => self.fn_stdev_s(args, cell),
            Function::Stdeva => self.fn_stdeva(args, cell),
            Function::Stdevpa => self.fn_stdevpa(args, cell),
            Function::TDist => self.fn_t_dist(args, cell),
            Function::TDist2T => self.fn_t_dist_2t(args, cell),
            Function::TDistRT => self.fn_t_dist_rt(args, cell),
            Function::TInv => self.fn_t_inv(args, cell),
            Function::TInv2T => self.fn_t_inv_2t(args, cell),
            Function::TTest => self.fn_t_test(args, cell),
            Function::VarP => self.fn_var_p(args, cell),
            Function::VarS => self.fn_var_s(args, cell),
            Function::VarpA => self.fn_varpa(args, cell),
            Function::VarA => self.fn_vara(args, cell),
            Function::WeibullDist => self.fn_weibull_dist(args, cell),
            Function::ZTest => self.fn_z_test(args, cell),
            Function::Sumx2my2 => self.fn_sumx2my2(args, cell),
            Function::Sumx2py2 => self.fn_sumx2py2(args, cell),
            Function::Sumxmy2 => self.fn_sumxmy2(args, cell),
            Function::Correl => self.fn_correl(args, cell),
            Function::Rsq => self.fn_rsq(args, cell),
            Function::Intercept => self.fn_intercept(args, cell),
            Function::Slope => self.fn_slope(args, cell),
            Function::Steyx => self.fn_steyx(args, cell),
            Function::Gauss => self.fn_gauss(args, cell),
            Function::Harmean => self.fn_harmean(args, cell),
            Function::Kurt => self.fn_kurt(args, cell),
            Function::Large => self.fn_large(args, cell),
            Function::MaxA => self.fn_maxa(args, cell),
            Function::Median => self.fn_median(args, cell),
            Function::MinA => self.fn_mina(args, cell),
            Function::RankAvg => self.fn_rank_avg(args, cell),
            Function::RankEq => self.fn_rank_eq(args, cell),
            Function::Skew => self.fn_skew(args, cell),
            Function::SkewP => self.fn_skew_p(args, cell),
            Function::Small => self.fn_small(args, cell),
        }
    }
}

#[cfg(test)]
mod tests {
    #![allow(clippy::unwrap_used)]
    use std::{
        fs::File,
        io::{BufRead, BufReader},
    };

    #[test]
    fn function_iterator() {
        // This checks that the number of functions in the enum is the same
        // as the number of functions in the Iterator.

        // This is tricky. In Rust we cannot loop over all the members of an enum.
        // There are alternatives like using an external crate like strum.
        // But I am not in the mood for that.

        // What we do here is read this file , extract the functions in the enum
        // and check they are the same as in the iterator
        let file = File::open("src/functions/mod.rs").unwrap();
        let reader = BufReader::new(file);
        let mut start = false;
        let mut list = Vec::new();

        for line in reader.lines() {
            let text = line.unwrap();
            let text = text.trim().trim_end_matches(',');
            if text == "pub enum Function {" {
                start = true;
                continue;
            }
            if start {
                if text == "}" {
                    break;
                }
                if text.starts_with("//") {
                    // skip comments
                    continue;
                }
                if text.is_empty() {
                    // skip empty lines
                    continue;
                }
                list.push(text.to_owned());
            }
        }
        // We make a list with their functions names, but we escape ".": ERROR.TYPE => ERRORTYPE
        // let iter_list = Function::into_iter()
        //     .map(|f| format!("{f}").replace('.', ""))
        //     .collect::<Vec<_>>();

        // let len = iter_list.len();

        // assert_eq!(list.len(), len);
        // // We still need to check there are no duplicates. This will fail if a function in iter_list
        // // is included twice and one is missing
        // for function in list {
        //     assert!(iter_list.contains(&function.to_uppercase()));
        // }
    }
}