Trait Write 

pub trait Write {
    type Error;

    // Required methods
    fn write_all(&mut self, bytes: &[u8]) -> IoResult<()>;
    fn write_gate<F: RichField + Extendable<D>, const D: usize>(
        &mut self,
        gate: &GateRef<F, D>,
        gate_serializer: &dyn GateSerializer<F, D>,
        common_data: &CommonCircuitData<F, D>,
    ) -> IoResult<()>;
    fn write_generator<F: RichField + Extendable<D>, const D: usize>(
        &mut self,
        generator: &WitnessGeneratorRef<F, D>,
        generator_serializer: &dyn WitnessGeneratorSerializer<F, D>,
        common_data: &CommonCircuitData<F, D>,
    ) -> IoResult<()>;

    // Provided methods
    fn write_bool(&mut self, x: bool) -> IoResult<()> { ... }
    fn write_target_bool(&mut self, x: BoolTarget) -> IoResult<()> { ... }
    fn write_target_bool_vec(&mut self, v: &[BoolTarget]) -> IoResult<()> { ... }
    fn write_u8(&mut self, x: u8) -> IoResult<()> { ... }
    fn write_u16(&mut self, x: u16) -> IoResult<()> { ... }
    fn write_u32(&mut self, x: u32) -> IoResult<()> { ... }
    fn write_usize(&mut self, x: usize) -> IoResult<()> { ... }
    fn write_usize_vec(&mut self, v: &[usize]) -> IoResult<()> { ... }
    fn write_field<F>(&mut self, x: F) -> IoResult<()>
       where F: PrimeField64 { ... }
    fn write_field_vec<F>(&mut self, v: &[F]) -> IoResult<()>
       where F: PrimeField64 { ... }
    fn write_field_ext<F, const D: usize>(
        &mut self,
        x: F::Extension,
    ) -> IoResult<()>
       where F: RichField + Extendable<D> { ... }
    fn write_field_ext_vec<F, const D: usize>(
        &mut self,
        v: &[F::Extension],
    ) -> IoResult<()>
       where F: RichField + Extendable<D> { ... }
    fn write_target(&mut self, x: Target) -> IoResult<()> { ... }
    fn write_target_ext<const D: usize>(
        &mut self,
        x: ExtensionTarget<D>,
    ) -> IoResult<()> { ... }
    fn write_target_array<const N: usize>(
        &mut self,
        v: &[Target; N],
    ) -> IoResult<()> { ... }
    fn write_target_vec(&mut self, v: &[Target]) -> IoResult<()> { ... }
    fn write_target_ext_vec<const D: usize>(
        &mut self,
        v: &[ExtensionTarget<D>],
    ) -> IoResult<()> { ... }
    fn write_hash<F, H>(&mut self, h: H::Hash) -> IoResult<()>
       where F: RichField,
             H: Hasher<F> { ... }
    fn write_target_hash(&mut self, h: &HashOutTarget) -> IoResult<()> { ... }
    fn write_hash_vec<F, H>(&mut self, v: &[H::Hash]) -> IoResult<()>
       where F: RichField,
             H: Hasher<F> { ... }
    fn write_merkle_cap<F, H>(&mut self, cap: &MerkleCap<F, H>) -> IoResult<()>
       where F: RichField,
             H: Hasher<F> { ... }
    fn write_target_merkle_cap(&mut self, cap: &MerkleCapTarget) -> IoResult<()> { ... }
    fn write_merkle_tree<F, H>(
        &mut self,
        tree: &MerkleTree<F, H>,
    ) -> IoResult<()>
       where F: RichField,
             H: Hasher<F> { ... }
    fn write_opening_set<F, const D: usize>(
        &mut self,
        os: &OpeningSet<F, D>,
    ) -> IoResult<()>
       where F: RichField + Extendable<D> { ... }
    fn write_target_opening_set<const D: usize>(
        &mut self,
        os: &OpeningSetTarget<D>,
    ) -> IoResult<()> { ... }
    fn write_merkle_proof<F, H>(
        &mut self,
        p: &MerkleProof<F, H>,
    ) -> IoResult<()>
       where F: RichField,
             H: Hasher<F> { ... }
    fn write_target_merkle_proof(
        &mut self,
        pt: &MerkleProofTarget,
    ) -> IoResult<()> { ... }
    fn write_fri_initial_proof<F, C, const D: usize>(
        &mut self,
        fitp: &FriInitialTreeProof<F, C::Hasher>,
    ) -> IoResult<()>
       where F: RichField + Extendable<D>,
             C: GenericConfig<D, F = F> { ... }
    fn write_target_fri_initial_proof(
        &mut self,
        fitpt: &FriInitialTreeProofTarget,
    ) -> IoResult<()> { ... }
    fn write_fri_query_step<F, C, const D: usize>(
        &mut self,
        fqs: &FriQueryStep<F, C::Hasher, D>,
    ) -> IoResult<()>
       where F: RichField + Extendable<D>,
             C: GenericConfig<D, F = F> { ... }
    fn write_target_fri_query_step<const D: usize>(
        &mut self,
        fqst: &FriQueryStepTarget<D>,
    ) -> IoResult<()> { ... }
    fn write_fri_query_rounds<F, C, const D: usize>(
        &mut self,
        fqrs: &[FriQueryRound<F, C::Hasher, D>],
    ) -> IoResult<()>
       where F: RichField + Extendable<D>,
             C: GenericConfig<D, F = F> { ... }
    fn write_target_fri_query_rounds<const D: usize>(
        &mut self,
        fqrst: &[FriQueryRoundTarget<D>],
    ) -> IoResult<()> { ... }
    fn write_fri_proof<F, C, const D: usize>(
        &mut self,
        fp: &FriProof<F, C::Hasher, D>,
    ) -> IoResult<()>
       where F: RichField + Extendable<D>,
             C: GenericConfig<D, F = F> { ... }
    fn write_target_fri_proof<const D: usize>(
        &mut self,
        fpt: &FriProofTarget<D>,
    ) -> IoResult<()> { ... }
    fn write_fri_reduction_strategy(
        &mut self,
        reduction_strategy: &FriReductionStrategy,
    ) -> IoResult<()> { ... }
    fn write_fri_config(&mut self, config: &FriConfig) -> IoResult<()> { ... }
    fn write_fri_params(&mut self, fri_params: &FriParams) -> IoResult<()> { ... }
    fn write_circuit_config(&mut self, config: &CircuitConfig) -> IoResult<()> { ... }
    fn write_selectors_info(
        &mut self,
        selectors_info: &SelectorsInfo,
    ) -> IoResult<()> { ... }
    fn write_polynomial_batch<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
        &mut self,
        poly_batch: &PolynomialBatch<F, C, D>,
    ) -> IoResult<()> { ... }
    fn write_common_circuit_data<F: RichField + Extendable<D>, const D: usize>(
        &mut self,
        common_data: &CommonCircuitData<F, D>,
        gate_serializer: &dyn GateSerializer<F, D>,
    ) -> IoResult<()> { ... }
    fn write_circuit_data<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
        &mut self,
        circuit_data: &CircuitData<F, C, D>,
        gate_serializer: &dyn GateSerializer<F, D>,
        generator_serializer: &dyn WitnessGeneratorSerializer<F, D>,
    ) -> IoResult<()> { ... }
    fn write_prover_only_circuit_data<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
        &mut self,
        prover_only_circuit_data: &ProverOnlyCircuitData<F, C, D>,
        generator_serializer: &dyn WitnessGeneratorSerializer<F, D>,
        common_data: &CommonCircuitData<F, D>,
    ) -> IoResult<()> { ... }
    fn write_prover_circuit_data<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
        &mut self,
        prover_circuit_data: &ProverCircuitData<F, C, D>,
        gate_serializer: &dyn GateSerializer<F, D>,
        generator_serializer: &dyn WitnessGeneratorSerializer<F, D>,
    ) -> IoResult<()> { ... }
    fn write_verifier_only_circuit_data<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
        &mut self,
        verifier_only_circuit_data: &VerifierOnlyCircuitData<C, D>,
    ) -> IoResult<()> { ... }
    fn write_verifier_circuit_data<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>(
        &mut self,
        verifier_circuit_data: &VerifierCircuitData<F, C, D>,
        gate_serializer: &dyn GateSerializer<F, D>,
    ) -> IoResult<()> { ... }
    fn write_target_verifier_circuit(
        &mut self,
        verifier_circuit: &VerifierCircuitTarget,
    ) -> IoResult<()> { ... }
    fn write_proof<F, C, const D: usize>(
        &mut self,
        proof: &Proof<F, C, D>,
    ) -> IoResult<()>
       where F: RichField + Extendable<D>,
             C: GenericConfig<D, F = F> { ... }
    fn write_target_proof<const D: usize>(
        &mut self,
        proof: &ProofTarget<D>,
    ) -> IoResult<()> { ... }
    fn write_proof_with_public_inputs<F, C, const D: usize>(
        &mut self,
        proof_with_pis: &ProofWithPublicInputs<F, C, D>,
    ) -> IoResult<()>
       where F: RichField + Extendable<D>,
             C: GenericConfig<D, F = F> { ... }
    fn write_target_proof_with_public_inputs<const D: usize>(
        &mut self,
        proof_with_pis: &ProofWithPublicInputsTarget<D>,
    ) -> IoResult<()> { ... }
    fn write_compressed_fri_query_rounds<F, C, const D: usize>(
        &mut self,
        cfqrs: &CompressedFriQueryRounds<F, C::Hasher, D>,
    ) -> IoResult<()>
       where F: RichField + Extendable<D>,
             C: GenericConfig<D, F = F> { ... }
    fn write_compressed_fri_proof<F, C, const D: usize>(
        &mut self,
        fp: &CompressedFriProof<F, C::Hasher, D>,
    ) -> IoResult<()>
       where F: RichField + Extendable<D>,
             C: GenericConfig<D, F = F> { ... }
    fn write_compressed_proof<F, C, const D: usize>(
        &mut self,
        proof: &CompressedProof<F, C, D>,
    ) -> IoResult<()>
       where F: RichField + Extendable<D>,
             C: GenericConfig<D, F = F> { ... }
    fn write_compressed_proof_with_public_inputs<F, C, const D: usize>(
        &mut self,
        proof_with_pis: &CompressedProofWithPublicInputs<F, C, D>,
    ) -> IoResult<()>
       where F: RichField + Extendable<D>,
             C: GenericConfig<D, F = F> { ... }
    fn write_lut(&mut self, lut: &[(u16, u16)]) -> IoResult<()> { ... }
    fn write_target_lut(&mut self, lut: &[(Target, Target)]) -> IoResult<()> { ... }
}

Writing

Required Associated Types

type Error

Error Type

Required Methods

fn write_all(&mut self, bytes: &[u8]) -> IoResult<()>

Writes all bytes to self.

fn write_gate<F: RichField + Extendable<D>, const D: usize>( &mut self, gate: &GateRef<F, D>, gate_serializer: &dyn GateSerializer<F, D>, common_data: &CommonCircuitData<F, D>, ) -> IoResult<()>

fn write_generator<F: RichField + Extendable<D>, const D: usize>( &mut self, generator: &WitnessGeneratorRef<F, D>, generator_serializer: &dyn WitnessGeneratorSerializer<F, D>, common_data: &CommonCircuitData<F, D>, ) -> IoResult<()>

Provided Methods

fn write_bool(&mut self, x: bool) -> IoResult<()>

Writes a bool x to self.

fn write_target_bool(&mut self, x: BoolTarget) -> IoResult<()>

Writes a target bool x to self.

fn write_target_bool_vec(&mut self, v: &[BoolTarget]) -> IoResult<()>

Writes a vector of BoolTarget v to self.

fn write_u8(&mut self, x: u8) -> IoResult<()>

Writes a byte x to self.

fn write_u16(&mut self, x: u16) -> IoResult<()>

Writes a word x to self.

fn write_u32(&mut self, x: u32) -> IoResult<()>

Writes a word x to self.

fn write_usize(&mut self, x: usize) -> IoResult<()>

Writes a word x to self.

fn write_usize_vec(&mut self, v: &[usize]) -> IoResult<()>

Writes a vector of words v to self.

fn write_field<F>(&mut self, x: F) -> IoResult<()>

where F: PrimeField64,

Writes an element x from the field F to self.

fn write_field_vec<F>(&mut self, v: &[F]) -> IoResult<()>

where F: PrimeField64,

Writes a vector v of elements from the field F to self.

fn write_field_ext<F, const D: usize>( &mut self, x: F::Extension, ) -> IoResult<()>

where F: RichField + Extendable<D>,

Writes an element x from the field extension of F to self.

fn write_field_ext_vec<F, const D: usize>( &mut self, v: &[F::Extension], ) -> IoResult<()>

where F: RichField + Extendable<D>,

Writes a vector v of elements from the field extension of F to self.

fn write_target(&mut self, x: Target) -> IoResult<()>

Writes a Target x to self.

fn write_target_ext<const D: usize>( &mut self, x: ExtensionTarget<D>, ) -> IoResult<()>

Writes an ExtensionTarget x to self.

fn write_target_array<const N: usize>( &mut self, v: &[Target; N], ) -> IoResult<()>

Writes a vector of Target v to self.

fn write_target_vec(&mut self, v: &[Target]) -> IoResult<()>

Writes a vector of Target v to self.

fn write_target_ext_vec<const D: usize>( &mut self, v: &[ExtensionTarget<D>], ) -> IoResult<()>

Writes a vector of ExtensionTarget v to self.

fn write_hash<F, H>(&mut self, h: H::Hash) -> IoResult<()>

where F: RichField, H: Hasher<F>,

Writes a hash h to self.

fn write_target_hash(&mut self, h: &HashOutTarget) -> IoResult<()>

Writes a HashOutTarget h to self.

fn write_hash_vec<F, H>(&mut self, v: &[H::Hash]) -> IoResult<()>

where F: RichField, H: Hasher<F>,

Writes a vector of Hash v to self.

fn write_merkle_cap<F, H>(&mut self, cap: &MerkleCap<F, H>) -> IoResult<()>

where F: RichField, H: Hasher<F>,

Writes cap, a value of type MerkleCap, to self.

fn write_target_merkle_cap(&mut self, cap: &MerkleCapTarget) -> IoResult<()>

Writes cap, a value of type MerkleCapTarget, to self.

fn write_merkle_tree<F, H>(&mut self, tree: &MerkleTree<F, H>) -> IoResult<()>

where F: RichField, H: Hasher<F>,

Writes tree, a value of type MerkleTree, to self.

fn write_opening_set<F, const D: usize>( &mut self, os: &OpeningSet<F, D>, ) -> IoResult<()>

where F: RichField + Extendable<D>,

Writes a value os of type OpeningSet to self.

fn write_target_opening_set<const D: usize>( &mut self, os: &OpeningSetTarget<D>, ) -> IoResult<()>

Writes a value os of type OpeningSet to self.

fn write_merkle_proof<F, H>(&mut self, p: &MerkleProof<F, H>) -> IoResult<()>

where F: RichField, H: Hasher<F>,

Writes a value p of type MerkleProof to self.

fn write_target_merkle_proof(&mut self, pt: &MerkleProofTarget) -> IoResult<()>

Writes a value pt of type MerkleProofTarget to self.

fn write_fri_initial_proof<F, C, const D: usize>( &mut self, fitp: &FriInitialTreeProof<F, C::Hasher>, ) -> IoResult<()>

where F: RichField + Extendable<D>, C: GenericConfig<D, F = F>,

Writes a value fitp of type FriInitialTreeProof to self.

fn write_target_fri_initial_proof( &mut self, fitpt: &FriInitialTreeProofTarget, ) -> IoResult<()>

Writes a value fitpt of type FriInitialTreeProofTarget to self.

fn write_fri_query_step<F, C, const D: usize>( &mut self, fqs: &FriQueryStep<F, C::Hasher, D>, ) -> IoResult<()>

where F: RichField + Extendable<D>, C: GenericConfig<D, F = F>,

Writes a value fqs of type FriQueryStep to self.

fn write_target_fri_query_step<const D: usize>( &mut self, fqst: &FriQueryStepTarget<D>, ) -> IoResult<()>

Writes a value fqst of type FriQueryStepTarget to self.

fn write_fri_query_rounds<F, C, const D: usize>( &mut self, fqrs: &[FriQueryRound<F, C::Hasher, D>], ) -> IoResult<()>

where F: RichField + Extendable<D>, C: GenericConfig<D, F = F>,

Writes a value fqrs of type FriQueryRound to self.

fn write_target_fri_query_rounds<const D: usize>( &mut self, fqrst: &[FriQueryRoundTarget<D>], ) -> IoResult<()>

Writes a value fqrst of type FriQueryRoundTarget to self.

fn write_fri_proof<F, C, const D: usize>( &mut self, fp: &FriProof<F, C::Hasher, D>, ) -> IoResult<()>

where F: RichField + Extendable<D>, C: GenericConfig<D, F = F>,

Writes a value fp of type FriProof to self.

fn write_target_fri_proof<const D: usize>( &mut self, fpt: &FriProofTarget<D>, ) -> IoResult<()>

Writes a value fpt of type FriProofTarget to self.

fn write_fri_reduction_strategy( &mut self, reduction_strategy: &FriReductionStrategy, ) -> IoResult<()>

fn write_fri_config(&mut self, config: &FriConfig) -> IoResult<()>

fn write_fri_params(&mut self, fri_params: &FriParams) -> IoResult<()>

fn write_circuit_config(&mut self, config: &CircuitConfig) -> IoResult<()>

fn write_selectors_info( &mut self, selectors_info: &SelectorsInfo, ) -> IoResult<()>

fn write_polynomial_batch<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( &mut self, poly_batch: &PolynomialBatch<F, C, D>, ) -> IoResult<()>

fn write_common_circuit_data<F: RichField + Extendable<D>, const D: usize>( &mut self, common_data: &CommonCircuitData<F, D>, gate_serializer: &dyn GateSerializer<F, D>, ) -> IoResult<()>

fn write_circuit_data<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( &mut self, circuit_data: &CircuitData<F, C, D>, gate_serializer: &dyn GateSerializer<F, D>, generator_serializer: &dyn WitnessGeneratorSerializer<F, D>, ) -> IoResult<()>

fn write_prover_only_circuit_data<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( &mut self, prover_only_circuit_data: &ProverOnlyCircuitData<F, C, D>, generator_serializer: &dyn WitnessGeneratorSerializer<F, D>, common_data: &CommonCircuitData<F, D>, ) -> IoResult<()>

fn write_prover_circuit_data<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( &mut self, prover_circuit_data: &ProverCircuitData<F, C, D>, gate_serializer: &dyn GateSerializer<F, D>, generator_serializer: &dyn WitnessGeneratorSerializer<F, D>, ) -> IoResult<()>

fn write_verifier_only_circuit_data<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( &mut self, verifier_only_circuit_data: &VerifierOnlyCircuitData<C, D>, ) -> IoResult<()>

fn write_verifier_circuit_data<F: RichField + Extendable<D>, C: GenericConfig<D, F = F>, const D: usize>( &mut self, verifier_circuit_data: &VerifierCircuitData<F, C, D>, gate_serializer: &dyn GateSerializer<F, D>, ) -> IoResult<()>

fn write_target_verifier_circuit( &mut self, verifier_circuit: &VerifierCircuitTarget, ) -> IoResult<()>

fn write_proof<F, C, const D: usize>( &mut self, proof: &Proof<F, C, D>, ) -> IoResult<()>

where F: RichField + Extendable<D>, C: GenericConfig<D, F = F>,

Writes a value proof of type Proof to self.

fn write_target_proof<const D: usize>( &mut self, proof: &ProofTarget<D>, ) -> IoResult<()>

Writes a value proof of type Proof to self.

fn write_proof_with_public_inputs<F, C, const D: usize>( &mut self, proof_with_pis: &ProofWithPublicInputs<F, C, D>, ) -> IoResult<()>

where F: RichField + Extendable<D>, C: GenericConfig<D, F = F>,

Writes a value proof_with_pis of type ProofWithPublicInputs to self.

fn write_target_proof_with_public_inputs<const D: usize>( &mut self, proof_with_pis: &ProofWithPublicInputsTarget<D>, ) -> IoResult<()>

Writes a value proof_with_pis of type ProofWithPublicInputsTarget to self.

fn write_compressed_fri_query_rounds<F, C, const D: usize>( &mut self, cfqrs: &CompressedFriQueryRounds<F, C::Hasher, D>, ) -> IoResult<()>

where F: RichField + Extendable<D>, C: GenericConfig<D, F = F>,

Writes a value cfqrs of type CompressedFriQueryRounds to self.

fn write_compressed_fri_proof<F, C, const D: usize>( &mut self, fp: &CompressedFriProof<F, C::Hasher, D>, ) -> IoResult<()>

where F: RichField + Extendable<D>, C: GenericConfig<D, F = F>,

Writes a value fq of type CompressedFriProof to self.

fn write_compressed_proof<F, C, const D: usize>( &mut self, proof: &CompressedProof<F, C, D>, ) -> IoResult<()>

where F: RichField + Extendable<D>, C: GenericConfig<D, F = F>,

Writes a value proof of type CompressedProof to self.

fn write_compressed_proof_with_public_inputs<F, C, const D: usize>( &mut self, proof_with_pis: &CompressedProofWithPublicInputs<F, C, D>, ) -> IoResult<()>

where F: RichField + Extendable<D>, C: GenericConfig<D, F = F>,

Writes a value proof_with_pis of type CompressedProofWithPublicInputs to self.

fn write_lut(&mut self, lut: &[(u16, u16)]) -> IoResult<()>

Writes a lookup table to self.

fn write_target_lut(&mut self, lut: &[(Target, Target)]) -> IoResult<()>

Writes a target lookup table to self.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Write for Vec<u8>

type Error = Infallible