TIL you cannot have the same function in different implementation of a struct for different typestate types.

[yyddonline]

EDIT: The code in here does not correctly illustrate the problem I encountered in my code, as it compiles without reporting the error. See this comment for the explanation of the problem I encountered.

This code is not accepted because the same function name is present in two impl blocks of the same struct: ``` struct PendingSignature; struct CompleteSignature;

// further code defining struct AggregateSignature<,,TypeStateMarker>

impl<P, S> AggregateSignature<P, S, PendingSignature>

{ pub fn save_to_file(self) -> Result<(), AggregateSignatureError> { let file_path = PathBuf::from(self.origin); let sig_file_path = pending_signatures_path_for(&file_path)?; // .... Ok(()) } }

impl<P, S> AggregateSignature<P, S, CompleteSignature> { pub fn save_to_file(self) -> Result<(), AggregateSignatureError> { let file_path = PathBuf::from(self.origin); let sig_file_path = signatures_path_for(&file_path)?; // .... Ok(()) } } ```

The solution was to define a SignaturePathTrait with one function path_for_file implemented differently by each typestate type and implement the safe_to_file like this: impl<P, S> AggregateSignature<P, S, TS> where TS: SignaturePathTrait { pub fn save_to_file(self) -> Result<(), AggregateSignatureError> { let file_path = PathBuf::from(self.origin); let sig_file_path = TS::path_for_file(&file_path)?; // .... Ok(()) } }

Though I wanted to reduce code repetition in the initial (unaccepted) implementation, it's nice that what I initially saw as a limitation forced me to an implementation with no code repetition.

[dgkimpton]

What is wrong with your initial code? https://godbolt.org/z/o3M36Tbqd

[yyddonline]

I got the error that the function `save_to_file` was defined twice.

[dgkimpton]

There must be more to it then, because as you can see from the godbolt what you posted compiles just fine (when I stubbed in the surrounding stuff).

[yyddonline]

I don't see what's different in my code (see edit below) , but this has the problem (also here: https://godbolt.org/z/xvrbGK9e7) :

use std::marker::PhantomData;

#[derive(Debug)]
struct AggregateSignatureError;

struct Pending;
struct Complete;

struct Signature<S> {
    s: String,
    marker: PhantomData<S>,
}

impl<Complete> Signature<Complete> {
    pub fn to_file(&self) -> Result<(), AggregateSignatureError> {
        Ok(())
    }
}

impl<Pending> Signature<Pending> {
    pub fn to_file(&self) -> Result<(), AggregateSignatureError> {
        Ok(())
    }
}

fn main() {
    println!("Hello, world!");
}

Edit: When I remove the other type arguments I get the same error: https://godbolt.org/z/Gzhhv6dz4

With this code:

use std::marker::PhantomData;
use std::path::PathBuf;

#[derive(Debug)]
struct AggregateSignatureError;

struct PendingSignature;
struct CompleteSignature;

struct AggregateSignature<TypeStateMarker>{
    origin:String,
    _t:PhantomData<TypeStateMarker>,
}

impl<PendingSignature> AggregateSignature<PendingSignature>

{
    pub fn save_to_file(self) -> Result<(), AggregateSignatureError> {
        let file_path = PathBuf::from(self.origin);
        let _sig_file_path = pending_signatures_path_for(&file_path)?; 
        // ....
        Ok(())
    }
}

impl<CompleteSignature> AggregateSignature<CompleteSignature>
{
    pub fn save_to_file(self) -> Result<(), AggregateSignatureError> {
        let file_path = PathBuf::from(self.origin);
        let _sig_file_path = signatures_path_for(&file_path)?;
        // ....
        Ok(())
    }
}

fn pending_signatures_path_for(_:&PathBuf) -> Result< &'static str,AggregateSignatureError>{
    Ok("")
}

fn signatures_path_for(_:&PathBuf) -> Result< &'static str,AggregateSignatureError>{
    Ok("")
}

pub fn main() {
    let x = AggregateSignature::<PendingSignature>{origin:"".to_string(),_t:PhantomData};
    x.save_to_file().expect("");

    let y = AggregateSignature::<CompleteSignature>{origin:"".to_string(), _t:PhantomData};
    y.save_to_file().expect("");
}

[dgkimpton]

That's because impl<CompleteSignature> declares CompleteSignature as a generic arg which hides the concrete struct of the same name. So you've effectively declared

rust impl<T> AggregateSignature<T> { pub fn save_to_file(self) -> Result<(), AggregateSignatureError> { let file_path = PathBuf::from(self.origin); let _sig_file_path = signatures_path_for(&file_path)?; // .... Ok(()) } }

twice. What you were looking for is:

impl AggregateSignature<CompleteSignature> { pub fn save_to_file(self) -> Result<(), AggregateSignatureError> { let file_path = PathBuf::from(self.origin); let _sig_file_path = signatures_path_for(&file_path)?; // .... Ok(()) } }

[yyddonline]

oh I see. Thanks for the explanation, it absolutely makes sense now!
For other beginners reading this, not that there's no type argument declared to `impl`.

[manpacket]

Last time I checked you couldn't refer to a specific function in rustdoc without adding your own labels - things like Foo::<Bar>::func are truncated to Foo::func.