Add `Vec<(K,V)>` to preserve insert order.

[Norbytus]

While write tests for __call_static, some test running get error cause get wrong result,

use std::collections::HashMap;

use ext_php_rs::prelude::*;
use ext_php_rs::types::Zval;

pub fn startup(_ty: i32, _: i32) -> i32 {
    0
}

#[php_class]
#[derive(Default)]
struct Test {}

#[php_impl]
impl Test {
    #[php(constructor)]
    fn __constructor() -> Self {
        Self {}
    }
    pub fn __call_static(name: String, arguments: HashMap<String, &Zval>) -> Zval {
        let mut zval = Zval::new();
        if name == "callStaticSomeMagic" {
            let concat_args = format!(
                "Hello from static call {}",
                arguments
                    .iter()
                    .filter(|(_, v)| v.is_long())
                    .map(|(_, s)| s.long().unwrap().to_string())
                    .collect::<Vec<_>>()
                    .join(" ")
            );

            let _ = zval.set_string(&concat_args, false);
            zval
        } else {
            zval.set_null();
            zval
        }
    }
}

#[php_module]
fn module(module: ModuleBuilder) -> ModuleBuilder {
    module.class::<Test>()
}

<?php

$t = new Test;

var_dump($t::callStaticSomeMagic(1, 2, 3));
// Some time show correct result but some time input number in different order

[Xenira]

Thinking about this it is not surprising, that this happens.

HashMap does not preserve ordering information. Using indexmap could be a solution here.

[kakserpom]

You can work with Zval directly instead of using HashMap in the argument.

[Xenira]

Ye that works. Will use this issue to add a feature indexmap though.

[kakserpom]

I think it might better to use an iterator like this:

pub fn __call_static(name: String, arguments: impl Iterator<Item = (String, &Zval)>) -> Zval

And then convert into indexmap or whatever in userland if needed:
let arguments = IndexMap::from_iter(arguments);

It is not necessary to add "indexmap" as a feature.