Different solutions to create a KernelBuilder

kero_solution.rs

pub enum Arg {
    Int(i32),
    Float(f32),
    String(String),
    Ptr(isize),
}

pub enum KernelError {
    KernelInvalid,
}

pub struct KernelBuilder {
    program: Vec<u8>,
    name: String,
    args: Vec<Arg>,
}

impl KernelBuilder {
    pub fn new(program: Vec<u8>, name: String) -> KernelBuilder {
        KernelBuilder {
            program: program,
            name: name,
            args: Vec::new(),
        }
    }

    pub fn arg(&mut self, arg: Arg) -> &KernelBuilder {
        self.args.push(arg);
        self
    }

    pub fn build(&self) -> Result<Kernel, KernelError> {
        // this can return Err(KernelInvalid) or Ok(Kernel)
        Kernel::try_build(&self,program, &self.name, &self.args)
    }
}

fn main() {
    let program = unimplemented!();
    let name = unimplemented!();

    let mut builder = KernelBuilder::new(program, name);

    builder.arg(arg1)
           .arg(arg2);

    // this can throw 1 error
    let kernel = builder.build().unwrap();
}

nick_solution.rs

pub enum Arg {
    Int(i32),
    Float(f32),
    String(String),
    Ptr(isize),
}

pub enum KernelError {
    KernelProgramUnspecified,
    KernelNameUnspecified,
    KernelInvalid,
}

pub struct KernelBuilder {
    program: Option<Vec<u8>>,
    name: Option<String>,
    args: Vec<Arg>,
}

impl KernelBuilder {
    pub fn new() -> KernelBuilder {
        KernelBuilder {
            program: None,
            name: None,
            args: Vec::new(),
        }
    }

    pub fn program(&mut self, program: Vec<u8>) -> &KernelBuilder {
        self.program = Some(program);
        self
    }

    pub fn name(&mut self, name: String) -> &KernelBuilder {
        self.name = Some(name);
        self
    }

    pub fn arg(&mut self, arg: Arg) -> &KernelBuilder {
        self.args.push(arg);
        self
    }

    pub fn build(&self) -> Result<Kernel, KernelError> {
        let program = self.program.ok_or(KernelProgramUnspecified)?;
        let name = self.name.ok_or(KernelNameUnspecified)?;

        // this can return Err(KernelInvalid) or Ok(Kernel)
        Kernel::try_build(&program, &name, &self.args)
    }
}

fn main() {
    let program = unimplemented!();
    let name = unimplemented!();

    let mut builder = KernelBuilder::new();

    builder.program(program)
           .name(name)
           .arg(arg1)
           .arg(arg2);

    // this can throw 3 different errors
    let kernel = builder.build().unwrap();
}