Struct parameters

[Virgiel]

In one of my projects, I have long queries like this one:

INSERT INTO pro 
  (title, fname, lname, sex, photo, specialty, expertise, street, postcode, city, phone, link, lat, lng, source, show, trait)
  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17) 
  RETURNING id;

And I need code like this one to pass all arguments:

[
    &item.pro.title.as_str(),
    &item.pro.fname.as_str(),
    &item.pro.lname.as_str(),
    &item.pro.sex,
    &item.pro.photo.as_ref().map(Photo::name),
    &item.pro.specialty.as_ref(),
    &item.pro.expertise.as_ref(),
    &item.pro.street.as_str(),
    &item.pro.postcode.as_str(),
    &item.pro.city.as_str(),
    &item.pro.phone.as_ref().map(ToString::to_string),
    &item.pro.link.as_ref().map(ToString::to_string),
    &item.pro.lat,
    &item.pro.lng,
    &item.source.as_ref(),
    &item.show,
    &item.pro.r#trait.as_ref(),
]

In addition to being cumbersome, it is also error-prone, every time I change the query I can easily swap any column of the same time without any compiler error. However, I like how small and succinct cornucopia functions can be and we should keep that.

My idea is the following. This code :

--! example (hello, world) #
/* some fancy SQL */

Generate this:

fn example(hello: &str, world: &i32) -> /* Query or Result */ {
    /* some fancy Rust */
}

struct ExampleParams<'a> {
    hello: &'a str,
    world: &'a i32
}

impl <'a> ExampleParams<'a> {
    fn example(self) -> /* Query or Result */ {
        example(self.hello, self.world)
    }
}

We could do even crazier things by allowing user naming of params struct.

--! insert (TestParams) #
/* some fancy SQL */

--! update (TestParams) #
/* some fancy SQL */

fn insert(hello: &str, world: &i32) -> /* Query or Result */ {
    /* some fancy Rust */
}

fn update(world: &i32, hello: &str) -> /* Query or Result */ {
    /* some fancy Rust */
}

struct TestParams<'a> {
    hello: &'a str,
    world: &'a i32
}

impl <'a> TestParams<'a> {
    fn insert(self) -> /* Query or Result */ {
        insert(self.hello, self.world)
    }

    fn update(self) -> /* Query or Result */ {
        update(self.world, self.hello)
    }
}

async fn usage(client: &C) -> Result<(), Error> {
    let mut params = TestParams {
        hello: "42",
        world: &42,
    };
    insert(client, params.hello, params.world).await?;
    params.world = &79;
    TestParams.update(client).await?;
    Ok(())
}

Another example:

struct Test {
    hello: String,
    world: i32,
}

impl Test {
    pub fn params(&self) -> TestParams {
        TestParams {
            hello: &self.hello,
            world: &self.world,
        }
    }
}

async fn usage(client: &C) -> Result<(), Error> {
    let mut test = Test {
        hello: "42".to_string(),
        world: 42,
    };
    insert(client, &test.hello, &test.world).await?;
    test.world = 79;
    test.params().update(client).await?;
    Ok(())
}

If we found a trait or create one with a function similar to params we could be generic over it